Gerenciador de Senhas

Salve galera,

Aqui vai uma dica de app útil para Android. É uma app bem simples, que criei para suprir uma necessidade própria.. e achei interessantes compartilhar ela no google play.

  Gerenciador de Senhas

"Dificuldades em controlar e lembrar-se de todos os dados de acesso a sites, conta bancaria, e-mails e outros? Esse aplicativo resolve seu problema lembrando você de todas as suas senhas no momento em que você precisa. Mantenha suas senhas seguras e sempre a mão com esse aplicativo. Requer autenticação de acesso para manipular e visualizar as senhas."

A aplicação requer autenticação, para ter a certeza de que é você mesmo que está visualizando as senhas. O campo login não é obrigatório, e depois de um tempo percebi que ele pode ser usado para salvar as letras que compõem a senha da conta bancária.

Como disse, ela é bem simples e útil, e o melhor de tudo..  é gratuíta! Vale a pena testar!!

Segue o link para o download Gerenciador de Senhas.



Até a próxima!

Glassfish - Secure Admin must be enabled to access the DAS remotely.

Salve galera,

Após a instalação do Glassfish, quando você tentar acessar o painel administrativo remotamente, você vai se deparar com a seguinte mensagem:

Secure Admin must be enabled to access the DAS remotely. 

Como liberar o acesso? 

1º Passo - Entre na pasta bin do glassfish e pare o servidor caso ele esteja rodando. Execute o seguinte comando:

$ ./asadmin stop-domain

2º Passo - Execute o seguinte comando e defina uma senha 

$ ./asadmin change-master-password

3º Passo - Inicie o servidor com o seguinte comando

$ ./asadmin start-domain

4º Passo - Defina uma senha administrativa, para acesso remoto

$ ./asadmin change-admin-password

5º Passo - Faça a liberação para acesso remoto

$ ./asadmin enable-secure-admin 


E agora o acesso remoto está liberado! espero que ajude =D

até a próxima!

Redimensionar Imagem em Java

Salve galera,

Quem aqui nunca precisou pegar uma imagem de 2000x1800 e colocar em um espaço de 500x500? É exatamente esse problema que esse post vem resolver. Na verdade, precisamos fazer um calculo ninja jedi para conseguir escalar a imagem.

Esse calculo consiste em:

• Descobrir o que é menor na imagem, se é a altura ou a largura.
• Caso existir um lado menor, descobir seu percentual em relação ao lado maior.
• Agora em cima do espaço disponível (500x500)temos que tirar o percentual calculado anteriormente do menor lado da imagem.

Se a imagem já tiver altura igual a largura, nada será feito.

Então aqui está ele, o calculo, pronto para uso.

class ImageResizerService {
 
    public byte[] read(String file) {
        byte[] buffer = new byte[1024];

        InputStream is = new FileInputStream(file);
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        while (is.read(buffer) != -1) {
            out.write(buffer);
        }
        try {
            return out.toByteArray();
        }finally {
            is.close()   
            out.close()            
        }
        
    }

    public byte[] read(String file, double requiredWidth, double requiredHeight) {


        BufferedImage imagem = ImageIO.read(new File(file));

        double originalWidth = imagem.getWidth();
        double originalHeight = imagem.getHeight();
        double newWidth = 0;
        double newHeight = 0;
        double diff = 0;

        if (requiredHeight == 0) {
            requiredHeight = requiredWidth;
        }

        if (requiredWidth == 0) {
            requiredWidth = requiredHeight;
        }

        if(originalWidth < requiredWidth && originalHeight < requiredHeight){
            return read(file)
        }

        if(requiredWidth == 0 && requiredHeight == 0){
            return read(file)
        }

        if (originalWidth > originalHeight) {
            diff = originalWidth - originalHeight;
            newWidth = requiredWidth;            
            diff = diff / originalWidth;
            newHeight = newWidth - (newWidth * diff);
        } else if (originalWidth < originalHeight) {
            diff = originalHeight - originalWidth;
            newHeight = requiredHeight;            
            diff = diff / originalHeight;
            newWidth = newHeight - (newHeight * diff);
        } else {

            if (requiredHeight > requiredWidth) {
                requiredHeight = requiredWidth;
            } else if (requiredHeight < requiredWidth) {
                requiredWidth = requiredHeight;
            }

            newHeight = requiredHeight;
            newWidth = requiredWidth;
        }



        int type = BufferedImage.TYPE_INT_RGB;
        boolean isPng = file.toUpperCase().endsWith("PNG")

        if (isPng) {
            type = BufferedImage.BITMASK;
        }


        BufferedImage new_img = new BufferedImage((int) newWidth, (int) newHeight, type);
        Graphics2D g = new_img.createGraphics();
        g.setComposite(AlphaComposite.Src);
        g.drawImage(imagem, 0, 0, (int) newWidth, (int) newHeight, null);
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        if (isPng) {
            ImageIO.write(new_img, "PNG", out);
        }else{
            ImageIO.write(new_img, "JPG", out);
        }

        try {
            return out.toByteArray();
        } finally {
            out.close();
        }
    }

}

Se esse é o melhor ou mais fácil algoritimo não sei, desenvolvi ele apartir da minha necessidade, e até o momento não tive problemas com "deformação" de imagens. Ah, e notem que caso seja solicitada uma um tamanho maior do que o tamanho da imagem existente, ele não faz nada, pois o objetivo é não perder a qualidade da imagem. E caso o tamanho solicitado seja menor do que a imagem existente mas não obedeça suas proporções, ele manterá a proporção, não obedecendo as medidas silicitadas, sempre nivelando por um dos valores (altura ou largura). Nesse caso, pomos sempre passar ou só largura, ou só altura.

Até a próxima!

Apache mascarando porta do Glassfish

Salve galera,

Uma situação muito comum para quem desenvolve aplicações que executam em um container java, como Glassfish ou Tomcat, é a necessidade de "mascarar" a porta do container atrás de um servidor web tradicional. Vou tentar explicar melhor.
Normalmente, subimos nosso container em uma porta diferente da 80, que é a porta web padrão, como por exemplo na porta 8080. Então para o usuário acessar nossa aplicação, ele precisa conectar em http://www.minhaempresa.com.br:8080/MinhaAplicacaoJava. Isso pode gerar alguns problemas, como o usuário não fixar a url do sistema, ou se confundir na hora da digitação, além de se tornar menos profissional, ao meu ver.
O objetivo proposto no artigo, é poder acessar a aplicação no seguinte endereço:
http://www.minhaempresa.com.br/MinhaAplicacaoJava. Sendo que teremos um servidor web apache rodando na porta 80 e um servidor java Glassfish rodando na porta 8080.

Depois de pesquisar um pouco, percebi que a maneira mais simples e transparente para atingir o objetivo, era instalar um módulo no servidor apache para tal funcionalidade. O nome do módulo é mod_jk.

Vamos  a instalação

Ambiente ondo foi implementado:

• Glassfish 3.1.2.2 (build 5).
• CentOS Linux release 6.0 (Final)
• Java 7 build 1.7.0_01-b08
• Apache 2.2.15
• Tomcat Connectors 1.2.37

A única dependência que tive que instalar no linux foram gcc-c++ e httpd-devel, pois deu problema na compilação do conector. Caso você tenha o mesmo problema, aqui mostro como instalar no Centos:

$ yum install gcc gcc-c++ autoconf automake
$ yum -y install httpd-devel

Ubuntu

$ sudo apt-get install libapache2-mod-jk

Para fazer o processo no ubuntu, você pode acessar: http://recklessdeveloper.blogspot.com.br/2011/06/apache-e-glassfish-301-com-modjk-no.html

O conector você pode baixar em: http://tomcat.apache.org/connectors-doc/. Como eu baixei o source, então tive que compilar. A complilação é bem simples. Você deve descompactar os fontes do mod_jk, entrar na pasta e executar os seguintes comandos:

cd native/
$ ./configure --with-apxs=/usr/sbin/apxs
$ make
$ make install

Após a compilação e instalação, você deve criar o arquivo de configuração. No meu caso, ele foi criado em:

$ /etc/httpd/conf/workers.properties

Esse arquivo deve ter o seguinte conteúdo:

worker.list=worker1
worker.worker1.type=ajp13
worker.worker1.host=localhost
worker.worker1.port=8009

Observação: Essa porta não precisa estar liberada externamente caso os dois servidors estejam rodando na mesma maquina.

Agora devemos configurar o httpd.conf:

LoadModule jk_module modules/mod_jk.so

JkWorkersFile conf/workers.properties
JkLogFile /var/log/mod_jk.log
JkLogLevel debug
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories
JkRequestLogFormat "%w %V %T"
JKMount /MinhaAplicacaoJava/* worker1

Em JkWorkersFile configuramos o arquivo criado anteriormente. Em JKMount configuramos o contexto da nossa aplicação no Glassfish. Você pode adicionar varios pontos de montagem, um para cada aplicação.

Agora precisamos avisar o Glassfish que ele vai ouvir as requisições desse cara. Entre na pasta bin do Glassfish e execute os seguintes comandos:

$ ./asadmin create-http-listener --listenerport 8009 --listeneraddress 0.0.0.0 --defaultvs server jk-connector

$ ./asadmin set configs.config.server-config.network-config.network-listeners.network-listener.jk-connector.jk-enabled=true

$ .asadmin create-jvm-options  -Dcom.sun.enterprise.web.connector.enableJK.propertyFile=domain-dir=/etc/httpd/conf/workers.properties

E pronto. Agora reinicie o Apache e o Glassfish e pode testar. Caso não funcione, verifique o arquivo de logs gerado em /var/log/mod_jk.log.

Até a próxima! vlw