Arquivo para janeiro de 2013

Verificação de data online via web-services usando XStream.

O objetivo desse post é oferecer dicas de como trabalhar com web-services usando as bibliotecas XStream e HttpClient 4.x, que já abordamos em um post anterior, e além disso verificar a data corrente online. As vezes pode ser necessário verificar de tempos em tempos se a data de uma aplicação cliente é exatamente a mesma de uma aplicação servidora. Não é algo tão corriqueiro, entretanto tem uma importância razoável visto que uma bateria de BIOS ruim ou um usuário mal intencionado ou por erro podem alterar a data da máquina. Dentre as várias soluções para verificar essa data a mais lógica é verificar essa data online. Verificar a data na aplicação servidora não é muito interessante pois o cliente pode, ocasionalmente, perder a comunicação com a aplicação servidora. Diante disso a saída é consumir algum web-service que disponibilize essas informações. Como era de se esperar não encontrei um no Brasil (mesmo que existisse provavelmente seria pago como é o caso do CEP). Dos vários web-services internacionais o mais interessante, par esse propósito, é o disponibilizado pelo Earth Tools.org. Ele oferece uma série de informações sobre clima e outras coisas e claro também sobre data.

Partindo para o desenvolvimento a primeira coisa que precisamos é definir as dependências no nosso POM. As dependências mais importantes de nosso projeto são as do HttpClient e a XStream. As primeiras são necessárias para podermos nos comunicar com o web-service já a segunda converte XML em objetos Java.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
    <!-- VERIFIQUE O POM COMPLETO NO GITHUB https://github.com/leandrocgsi/DateSynchronizer -->
 
    <dependencies>
 
        <!-- DEPENDÊNCIA DA XSTREAM RESPONSÁVEL POR CONVERTER XML EM OBJETOS -->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.3</version>
        </dependency>
             
        <!-- DEPENDÊNCIA DA JERSEY -->
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-server</artifactId>
            <version>1.8</version>
        </dependency>
        
        <!-- DEPENDÊNCIA DO ASM --> 
        <dependency>
            <artifactId>asm</artifactId>
            <groupId>asm</groupId>
            <type>jar</type>
            <version>3.1</version>
        </dependency>
         
        <!-- DEPENDÊNCIA DO HTTP CLIENT -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.0.3</version>
        </dependency>
          
        <!-- DEPENDÊNCIA DO HTTP MIME -->   
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.0.3</version>
        </dependency>
         
        <!-- DEPENDÊNCIA DO HTTP CORE -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.0.1</version>
        </dependency>
             
        <!-- DEPENDÊNCIA DA JMONKEYENGINE-->
        <dependency>
            <groupId>com.projectdarkstar.ext.com.jmonkeyengine</groupId>
            <artifactId>jme-xml</artifactId>
            <version>2.0-S1</version>
            <type>jar</type>
        </dependency>
    </dependencies>
</project>

Agora partindo para as classes Java precisamos acessar a seguinte URL http://www.earthtools.org/timezone/-18.5134/-46.512809 que recebe como parâmetro em sua parte final dois números correspondentes a longitude e latitude de onde estamos acessando. Se acessarmos essa URL via browser veremos um XML similar ao da imagem abaixo.

Estrutura do XML

Podemos identificar, no XML, a necessidade de criarmos dois beans responsáveis por armazenar as informações do XML. O primeiro deles assinalado com o numero 1 (timezone) dará origem ao bean Timezone, que além de uma série de atributos simples possui um atributo composto por outro objeto (location) que por sua vez dará origem ao bean Location. Na criação do bean ao adicionarmos a anotação @XStreamAlias indicamos que aquele objeto representa um nó do arquivo XML. Fora isso nossas classes não possuem nada demais apenas geters, setters, serialização e construtor.

package br.com.semeru.datesynchronizer.beans;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import java.io.Serializable;

// Anotação que indica para a XStream que timezone
// é um nó de um arquivo XML ou seja ele é um objeto
@XStreamAlias("timezone")
public class Timezone implements Serializable{

    //Atributo para serialização do bean
    private static final long serialVersionUID = 1L;
    
    //Atributo do XML
    private String version;

    /*Essa anotação indica que o atributo XML abaixo 
    é um atributo um pouco mais complexo e representa
    um objeto dentro de timezone*/
    @XStreamAlias("location")
    private Location location;
    
    //Outro atributo do XML
    private String offset;
    private String suffix;
    private String localtime;
    private String isotime;
    private String utctime;
    private String dst;

    // Construtor, getters e setters omitidos
        
}

Observe que o bean Timezone se relaciona de 1 para 1 com Location.

package br.com.semeru.datesynchronizer.beans;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import java.io.Serializable;

/* Anotação que indica para a XStream que location
é um nó de um arquivo XML ou seja ele é um objeto */
@XStreamAlias("location")
public class Location implements Serializable{
    
    private static final long serialVersionUID = 1L;
    
    private String latitude;
    private String longitude;

    // Construtor, getters e setters omitidos
        
}

Feito isto é só nos acessarmos a URL e converter o XML em objetos. Inicialmente definimos a URL e um main que invoca um outro método (readXMLURL) que por sua vez se conecta à URL e recupera um inputStream que por sua vez é passado como parâmetro na invocação do método parserXMLToObject que recupera o XML do inputStream e converte-o em objeto retornando um objeto do tipo Timezone que agora podemos usar na aplicação.

package br.com.semeru.datesynchronizer;

import br.com.semeru.datesynchronizer.beans.Timezone;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import java.io.IOException;
import java.io.InputStream;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

public class RecoveryDateWitchURL {

    //Determino a URL de onde será recuperada a informação do webservice
    private static String url = "http://www.earthtools.org/timezone/-18.5134/-46.512809";
        
    //Método main
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        
        //Invoco o método passando como parâmetro a URL
        readXMLURL(url);
    }

    // Método responsável por recuperar um inputstream a
    // partir de uma URL e converter o resultado em objeto
    private static void readXMLURL(String url) throws IOException {
        
        //Crio uma instancia de cliente HTTP
        HttpClient client = new DefaultHttpClient();
        
        //Crio uma instancia de HTTPGet passando a URL como parâmetro
        HttpGet method = new HttpGet(url);
        
        //Atribuo à HTTP response o resutado da execução do método get
        HttpResponse httpResponse = client.execute(method);
        
        //Declaro uma variável que recebe o código de status da requisição HTTP
        int statusCode = httpResponse.getStatusLine().getStatusCode();
        
        //Verifico se o código do status é igual a SC_OK (200)
        if (statusCode == HttpStatus.SC_OK) {
            
            //Se for significa que a requisição foi bem sucedida e então
            //crio uma instancia de InputStream pegando o conteúdo da response
            InputStream inputStream = httpResponse.getEntity().getContent();
            
            //Invoco o método parserXMLToObject passando o inputStream como parâmetro
            parserXMLToObject(inputStream);
        }
    }
    
    //Método que efetivmente converte o input stream em XML e depois em objeto
    private static Timezone parserXMLToObject(InputStream inputStream) {
        
        //Crio uma instancia de XStream que recebe via
        //construtor uma instancia de DomDriver
        XStream xStream = new XStream(new DomDriver());
        
        //Processa as anotações da classe Timezone
        xStream.processAnnotations(Timezone.class);
        
        //Crio uma instancia de Timezone que recebe um cast para Timezone 
        //do inputstream convertido para XML e depois para Objetc
        Timezone timezone = (Timezone) xStream.fromXML(inputStream);
        
        //Imprimo algumas informações de timezone para testar
        System.out.println("O TimeZone É: " + timezone.getLocaltime() + " - " + timezone.getUtctime() + "\n"
                + "e as Cordenadas são: " + timezone.getLocation().getLatitude() + " de Latitude Sul" + timezone.getLocation().getLongitude() + " de Longitude Oeste. :-&gt;");
        
        //Retorno um objeto do tipo Timezone que poderá
        //ser usado em outras partes da aplicação.
        return timezone;
    }

}

Posteriormente pretendo fazer mais posts abordando outros aspectos de web-services. Lembrando sempre que se você ficou alguma dúvida relacionada ao conteúdo desse post sinta-se a vontade para comentar, criticar e/ou contribuir com o seu comentário. Além disso você pode acessar todo o código fonte desse projeto através do GitHub.

Tags: , , , ,

Dicas de migração do HttpClient 3.1 para o HttpClient 4.x

Este post é para aqueles que estavam usando o Apache HttpClient 3.1 até hoje e agora decidiu pagar o preço e migrar para HttpClient 4.x. Atualização de bibliotecas da Fundação Apache geralmente é algo bem tranquilo, entretanto o HttpClient 4.x foi completamente reescrito e a versão 4.x não é compatível com as versões anteriores. Além disso o HttpClient não faz mais parte do Apache Commons. Aqui estão as alterações que você precisará fazer para migrar para o HttpClient 4.x. Este post é um mini tutorial para aqueles que estão migrando de versões anteriores do HttpClient para a versão 4.x. O tempo necessário para migrar dependerá de quantas referências você precisará alterar. Então mãos a obra.

1. Substitua o jar commons-HttpClient-3.1.jar pelos jars httpclient-4.0.3.jar e httpmime-4.0.3.jar. Além desses você também precisará do httpcore-4.0.1.jar.

Se você utiliza o Maven certamente você declarava a dependência abaixo:

<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>

Agora, como já foi dito, são três jars e você irá declarar as dependências da seguinte forma:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.0.3</version>
</dependency>
    
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpmime</artifactId>
    <version>4.0.3</version>
</dependency>

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore</artifactId>
    <version>4.0.1</version>
</dependency> 

2. Altere suas declarações de importação de org.apache.commons.httpclient.* para org.apache.http.*. Por exemplo, altere disso:

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.ConnectTimeoutException;

para isso:

import org.apache.http.client.HttpClient;
import org.apache.http.HttpStatus;
import org.apache.http.HttpException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.HttpResponse;
import org.apache.http.impl.client.DefaultHttpClient;

Observe que além da adição de HttpResponse e DefaultHttpClient ocorreram outras alterações sutis na forma de se trabalhar com o HttpClient.

3. Agora altere o seu código a partir do velho HttpClient para o novo.

HttpClient 3.1:

HttpClient client = new HttpClient();
GetMethod method = new GetMethod(url);
int statusCode = client.executeMethod(method);
if (statusCode == HttpStatus.SC_OK) {
    InputStream is = method.getResponseBodyAsStream();
    // utilizar o input stream da forma que necessitar
}
method.releaseConnection();

HttpClient 4.x:

HttpClient client = new DefaultHttpClient();
HttpGet method = new HttpGet(url);
HttpResponse httpResponse = client.execute(method);
int statusCode = httpResponse.getStatusLine().getStatusCode();
if (statusCode == HttpStatus.SC_OK) {
    InputStream is = httpResponse.getEntity().getContent();
    // utilizar o input stream da forma que necessitar
}

Obviamente nos exemplos acima não utilizamos todas as funcionalidades do novo HttpClient, mas a maioria das alterações são semelhantes às listadas acima. Para ver exemplos mais detalhados sobre como usar HttpClient 4.x, visite o HttpClient 4.0.3 Tutorial. Se você tiver outras dicas sobre a migração para o HttpClient 4.x sinta-se a vontade para postar um comentário.

Tags: , ,

Iniciando Se No JSF – 02 – Configurando O Ambiente E Criando O Primeiro Projeto

Nesse segundo post do Curso De JSF Do Zero À Nuvem Eu explico como instalar e configurar as duas IDE’s mais utilizadas no mercado, os plugins de versionamento e a criação do primeiro projeto.

Inicialmente explico onde baixar e como instalar a IDE Eclipse e os plugins EGit e Github MyLyn Connector para versionar o projeto no GitHub. É algo relativamente simples mas que pode ajudar muito alguém iniciante.


Instalando O Eclipse E Os Plugins m2eclipse, Subclipse E EGit





Posteriormente eu explico como instalar o Netbeans e configurar o Apache Tomcat. Diferentemente do Eclipse não é necessário instalar nenhum plugin.


Instalando O Netbeans E Configurando O Tomcat





Por fim criamos um repositório no GitHub e criamos nosso primeiro projeto.


Criando O Repositório E Iniciando O Projeto Maven



Observação importante:

Se você pretende trabalhar com o Eclipse ou mesmo com as duas IDE’s recomendo que você edite o POM e altere tudo que está entre as tags plugins de modo que fique igual ao trecho abaixo.

<plugins>           
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
            <source>1.6</source>
            <target>1.6</target>
            <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <configuration>
            <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <configuration>
            <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
    </plugin>
</plugins>

No mais boa sorte e bons códigos sem bugs.

Tags: , , , ,

Iniciando Se No JSF – 01 – Apresentação, O Projeto E As Tecnologias

Olá. Este post é para apresentar o curso de JSF a vocês. Quando eu comecei a trabalhar com JSF eu usava apostilas na internet, video aulas no Youtube, livros e vivia correndo atrás de todo mundo que pudesse me ajudar a entender melhor o framework. Aprendi bastante de lá pra cá e como eu não posso retribuir diretamente a todos que me ajudaram nem outros que como eu hoje precisam de ajuda então decidi gravar uma série de video aulas a respeito. Creio que esse é a melhor forma de contribuir, e espero que ajude você a começar com JSF.

Além de JSF você aprenderá o básico de uma série de outras tecnologias que vão desde o Hibernate, Primefaces, Spring Security, Maven, Tomcat, Netbeans, Eclipse e além disso ao final do projeto você aprenderá como fazer o deploy na nuvem. No vídeo abaixo eu apresento o resultado final de todo o projeto e as tecnologias com as quais iremos trabalhar.


Curso De JSF Do Zero À Nuvem – O Projeto E As Tecnologias Envolvidas

No segundo vídeo você irá entender os principais conceitos teóricos do JSF. Além disso você terá dicas de por onde começar com o JSF.


Entendendo O JSF E Dicas

Além dos livros indicados no vídeo existem muitas apostilas gratuitas na web. Temos uma da Algaworks que apesar de abordar a versão 1.2 do JSF é bem interessante para quem está iniciando. Temos duas muito boas da K19 uma de JSF com JPA e outra de JSF com EJB a Caelum surpreendentemente não tem nada sobre o JSF talvez seja pra puchar a sardinha do VRaptor. Outras apostilas como a Do Luis Fernado e a do Diego Rezende que podem ser baixadas do Scribd. Além dessas uma rápida pesquisa no Google pode lhe mostrar uma infinidade de materiais a respeito. No Youtube além das minhas vídeo aulas existem outras que podem ajudar bastante quem está começando.

Se você quiser baixar os slides da apresentação basta ir ao SlideShare e fazer isso.

Quero destacar também que os fontes desse curso podem ser baixados do GitHub. Serão feitos posts correspondentes às video aulas e recomendo que você acompanhe por que assim que possível irei realizando posts para complementar o que foi falado nos vídeos.

Tags: , , , ,

Entendendo o POM do Maven

Continuando a responder a pergunta “para que serve o apache maven?” nesse post eu explico a estrutura básica de um arquivo POM. O POM é um dos arquivos mais importantes em um projeto Maven, ele descreve uma série de configurações que o projeto terá e quais repositórios e dependências seu projeto irá precisar.
No cabeçalho de um POM temos algumas tags básicas que definem qual versão do modelo de POM utilizado. O seu GroupId que seria algo como o prefixo da estrutura de pacotes do projeto. O ArtifactId que define qual é o nome o artefato final .war ou .jar terá quando empacotado. Version define a versão do projeto que irá complementar o nome do artefato. A tag Packaging por sua vez define qual tipo de empacotamento o projeto terá após o processo de build, no nosso caso será um .war. E a tag Name define o nome do projeto.

    <modelVersion>4.0.0</modelVersion>
    <groupId>br.com.semeru</groupId>
    <artifactId>semeru_jsf_maven</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>semeru_jsf_maven</name>

A tag Properties possibilita definir por exemplo a versão do Spring, ou do JSF adotada para o projeto. Se uma dependência for definida como no trecho de código abaixo ao mudarmos a versão do Spring, por exemplo, para 3.1 todas as dependências serão baixadas para a versão 3.1. Podemos definir o contêiner web no qual será feito o deploy da aplicação (Tomcat) e também o tipo de codificação utilizada pelo projeto, no nosso caso o UTF8 .

    <properties>
        <spring.version>3.0.5.RELEASE</spring.version>
        <themes.version>1.0.8</themes.version>
        <jsf.version>2.1.7</jsf.version>
        <jstl.version>1.2</jstl.version>
        <netbeans.hint.deploy.server>Tomcat</netbeans.hint.deploy.server>   
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

A tag Repositories define a lista de repositórios que serão acessados pelo Maven para baixar nossas dependencias. Muitas vezes é necessário colocar um repositório prioritário no inicio do POM para que o Maven inicie a busca pelas dependências a partir dele.

    <repositories>
        
        <!-- PRIMEFACES REPOSITORY -->
        <repository>
            <id>prime-repo</id>
            <name>PrimeFaces Maven Repository</name>
            <url>http://repository.primefaces.org</url>
            <layout>default</layout>
        </repository>        
                
        <!-- FACELETS TAGLIBRARIES REPOSITORY -->
        
        <repository>
            <id>org.springframework.security.taglibs.facelets</id>
            <url>http://spring-security-facelets-taglib.googlecode.com/svn/repo/</url>
        </repository>

    </repositories>

A tag dependencies define quais serão as dependências utilizadas no projeto no trecho de código abaixo declaramos algumas das dependências necessárias para se trabalhar com JavaServer Faces.

    <dependencies>

        <!-- || DEPENDÊNCIAS DO JAVA SERVER FACES || -->                        
        <!-- ############## JSF-API ################ -->
        <dependency>
            <groupId>com.sun.faces</groupId>
            <artifactId>jsf-api</artifactId>
            <version>${jsf.version}</version>
            <scope>compile</scope>
        </dependency>

        <!-- ############## JSF-IMPL ############### -->
        <dependency>
            <groupId>com.sun.faces</groupId>
            <artifactId>jsf-impl</artifactId>
            <version>${jsf.version}</version>
        </dependency>
                
        <!-- ################ JSTL ################# -->
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>jstl</artifactId>  
            <version>${jstl.version}</version>  
        </dependency>  
    </dependencies>

Muitas vezes algumas dependências precisam ser excluídas. Isso acontece por vários motivos primeiro pode ser que o projeto já utilize uma versão diferente da mesma dependência. Um segundo motivo pode ser o fato da dependência em questão gerar conflitos com outras utilizadas no projeto. A sintaxe para remover uma dependência é como o trecho de código abaixo. Nele estamos declarando a dependência do DOM4J mas estamos dizendo ao Maven para não baixar a dependência da XML-APIS. Se tirarmos essa exclusão o Maven vai analizar o POM da DOM4J e verificará que ela possui uma dependência da XML-APIS e assim entenderá que o projeto necessita dela e irá baixá-la para nosso .m2.

        <!-- ############### DOM4J ################# -->
        <dependency>
            <artifactId>dom4j</artifactId>
            <groupId>dom4j</groupId>
            <type>jar</type>
            <version>1.6.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>xml-apis</artifactId>
                    <groupId>xml-apis</groupId>
                </exclusion>
            </exclusions>
        </dependency>

Anteriormente no post Entendendo o Apache Maven eu expliquei outros detalhes importantes do Maven além disso no GUJ tem um tutorial bem legal sobre o assunto.