25 de nov de 2012

Gson – Converta JSON em um objeto Java de forma simples


O JSON (JavaScritp Object Notation) é um formato de representação de dados, que foi criada originalmente para representar objetos em Javascript. Comparando com o XML, o JSON é um formato bem mais leve e por isso vem sendo bastante utilizado.

O Gson é uma biblioteca em Java para transformar objetos Java em JSON e vice-versa.

Vamos construir uma aplicação simples para demonstrar como o Gson funciona. A aplicação vai funcionar da seguinte maneira: ler um arquivo json, transformar em um objeto Java e imprimir na tela as informações.

Primeiro passo é inserir no seu projeto a biblioteca do Gson. Se você usa o Maven acresente a seguinte dependência:
        
            com.google.code.gson
            gson
            2.2.2
        

Arquivo json para teste (pedido.json):
{
    "id" : 123456 ,
    "cliente":{
        "id" : 24,
        "nome" : "Pedr\u00e3o Rasga Zorba"
    },
    "itens":[
         {
            "id" : 1,        
            "nome" : "Cerveja Bhrama Garrrafa 600ml",
            "qtde" : 50
         },
         {
            "id" : 2,        
            "nome" : "Amendoim Jo\u00e3o Pon\u00eas",
            "qtde" : 10
         },
         {
            "id" : 3,
            "nome" : "Papel Higi\u00eanico Limpac\u00fa pacote c/ 4 unidades",
            "qtde" : 2
         }        
    ]    
}

Analisando o json “pedido”, verificamos que ele possui um atributo “id”, um outro objeto “cliente” e um array “itens”. Dessa forma, nosso conjunto de classes java vai ficar da seguinte maneira.

Pedido.java
package com.gsonexample;

import java.util.ArrayList;
import java.util.List;

public class Pedido {
    
    private Integer id;
    private Cliente cliente;
    private List itens;

    public Pedido() {
        itens = new ArrayList();
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Cliente getCliente() {
        return cliente;
    }

    public void setCliente(Cliente cliente) {
        this.cliente = cliente;
    }

    public List getItens() {
        return itens;
    }

    public void setItens(List itens) {
        this.itens = itens;
    }   
       
}

Cliente.java
package com.gsonexample;

public class Cliente {

    private Integer id;
    private String nome;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }
       
}

Item.java
package com.gsonexample;

public class Item {

    private Integer id;
    private String nome;
    private Integer qtde;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public Integer getQtde() {
        return qtde;
    }

    public void setQtde(Integer qtde) {
        this.qtde = qtde;
    }
    
}

Agora vamos usar o Gson para converter o arquivo pedido.json em uma instância da classe “Pedido”.

App.java
package com.gsonexample;

import com.google.gson.Gson;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;

public class App {
    
    public static void main( String[] args ) throws FileNotFoundException{
        
        Reader reader = new FileReader(new File(ClassLoader.getSystemResource("pedido.json").getFile()));
        
        Gson gson = new Gson();
        Pedido pedido = gson.fromJson(reader, Pedido.class);
        
        System.out.print("Pedido: " + pedido.getId() +
                        "\nId Cliente: " + pedido.getCliente().getId() +
                        "\nNome: " + pedido.getCliente().getNome() +
                        "\nItens: ");
        
        for(Item item : pedido.getItens()){
            System.out.println("\n---------------------------------------" +
                            "\nid item: " + item.getId() +
                            "\nnome item: " + item.getNome() +
                            "\nqtde: " + item.getQtde());
        }
        
    }
}

Para fazer o processo inverso, ou seja, transformar o objeto java em json, utilize o método “toJson”.
String json = gson.toJson(pedido);

O Gson disponibiliza diversas outras funcionalidades, como a utilização de anotações por exemplo. Sugiro aos senhores darem uma olhada na documentação do projeto para conhecerem a ferramenta a fundo.

Referências:
http://www.json.org
http://code.google.com/p/google-gson

Código fonte: http://depositfiles.com/files/wmeas28k9

É isso ae patota feliz. Aqui é Java!

18 de nov de 2012

Xmemcached – Client Memcached de alta performance


Como essas paradas de NoSql está muito na moda, decidi escrever sobre um client de memcached que venho utilizando há algum tempo, o Xmemcached.

Antes uma breve explanação sobre o Memcached.

Memcached

O Memcached é um sistema de cacheamento em memória, distribuído e de excelente performance. Ele trabalha em sistema chave/valor, onde você pode armazenar diversos tipos de conteúdo, como textos e objetos serializados. Para mais informações sobre o Memcached, compilação e instalação acesse o link abaixo. Uma versão compilada para Windows está disponível para download junto com a aplicação de exemplo no final do post.
http://code.google.com/p/memcached

Xmemcached

O Xmemcached é um client Java para o Memcached com alta performance, principalmente em ambientes muti-thread, além de disponibilizar outros recursos interessantes, como adição dinâmica de servidores e configuração de pool de conexões.
Abaixo, um link com um teste de performance comparando 3 clientes de Memcached:
http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html

Antes de mais nada, coloque o Memcached para rodar!
Linux:
memcached -p 11211
Windows:
memcached.exe -p 11211

Vão ser necessárias as seguintes dependências para construir o projeto Maven:

 org.slf4j
 slf4j-api
 1.7.2


 com.googlecode.xmemcached
 xmemcached
 1.3.8



Aplicação simples:
package com.xmemcachedexample;

import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.utils.AddrUtil;

public class App {

    public static void main(String[] args) throws Exception {

        MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:11211"));
        MemcachedClient client = builder.build();

        //Classe deve implementar interface java.io.Serializable
        ExampleBean a = new ExampleBean();
        a.setText("Me coloca no cache!");

        //inserir objeto no cache por 30 segundos
        client.set("chave", 30, a);
        System.out.println(client.get("chave"));

        //remover objeto do cache
        client.delete("chave");
        System.out.println(client.get("chave"));

        //contador
        client.incr("contador", 0);
        System.out.println(client.get("contador"));
        client.incr("contador", 2);
        client.incr("contador", 1);
        System.out.println(client.get("contador"));

        client.shutdown();
        
    }
}

Adicionar/Remover servidores dinamicamente:
MemcachedClient client = new XMemcachedClient(AddrUtil.getAddresses("server1:11211 server2:11211"));
//adicionar servidor
client.addServer("server3:11211");
//remover servidor
client.removeServer("server1:11211");


Configurando um pool de conexões:
MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:11211"));
builder.setConnectionPoolSize(5);


Referências:
http://code.google.com/p/xmemcached
http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html
http://code.google.com/p/memcached

Código fonte: http://depositfiles.com/files/vs2kt05wv

É nóis, manow! Aqui é Java!

12 de nov de 2012

Verificar cobertura de testes com o plugin do Cobertura para o Maven


O Cobertura é uma ferramenta que verifica o quanto seu código está sendo testado. Ao final da execução dos testes unitários, o Cobertura gera um relatório contendo todas as classes do projeto e a porcentagem das linhas de código que foram testadas.

É uma ferramenta importante para medir o quão eficiente está a implementação dos testes unitários.

Nesse exemplo vamos usar o plugin do Cobertura para o Maven afim de tornar nossa vida um pouco mais fácil.

Primeiramente precisamos configurar o plugin. Segue o trecho que deve ser inserido no pom.xml:
        
 
  
   org.codehaus.mojo
   cobertura-maven-plugin
   2.5.2
   
    
     html
    
   
  
 


Segundo, precisaremos de uma classe qualquer e um teste unitário:

Calculator.java
package com.coberturaexample;

public class Calculator {

    public double sum(double v1, double v2){
        return v1 + v2;
    }
    
    public double sub(double v1, double v2){
        return v1 - v2;
    }
    
    public double mult(double v1, double v2){
        return v1 * v2;
    }
    
    public double div(double v1, double v2){
        return v1 / v2;
    }
    
}

CalculatorTest.java
package com.coberturaexample;

import org.junit.Assert;
import org.junit.Test;

public class CalculatorTest {

    @Test
    public void testSum() {        
        Calculator calc = new Calculator();        
        double result = calc.sum(1, 2);
        Assert.assertTrue(result == 3);
    }

    @Test
    public void testSub() {
        Calculator calc = new Calculator();
        double result = calc.sub(2, 1);
        Assert.assertTrue(result == 1);
    }

}

Nesse exemplo foram implementados apenas os testes de 2 métodos do total de 4, o que ao final vai gerar uma cobertura de 60% do código.

Seguindo, vamos fazer o build do projeto para gerar as classes e testes:

mvn install

Depois executamos o comando do Cobertura:

mvn cobertura:cobertura

Esse comando vai fazer a instrumentação do código, executar os testes e gerar o relatório de cobertura.

O relatório será gerado no diretório \target\site\cobertura.




Referências:
http://cobertura.sourceforge.net
http://mojo.codehaus.org/cobertura-maven-plugin

Código fonte: http://depositfiles.com/files/y4vm7loso

É isso ae, malandro. Aqui é Java!

1 de nov de 2012

Internacionalização


Essa é uma dica para quem quer construir um aplicativo “poliglota”. Vamos fazer um utilitário bem simples que pode ser usado na internacionalização de aplicações em Java.

Abaixo estão as classes que servirão de suporte para construir o utilitário:

java.util.Locale
É composto de duas informações básicas: idioma e/ou país. Ex.: pt_BR (português, Brasil), en_US (Inglês, Estados Unidos). O idioma sempre em letras minúscula,s seguidos de _ (undeline) e do país em letras maiúsculas, sendo o segundo não obrigatório.

java.util.ResourceBundle
Classe responsável por fazer a leitura do arquivo onde estarão nossos termos e mensagens internacionalizadas.

java.text.MessageFormat
Essa classe vai auxiliar na formatação das mensagens antes de serem apresentadas ao usuário.

Nossa aplicação vai suportar 3 idiomas: inglês, português do Brasil e espanhol. Assumindo que nossa linguagem padrão será o inglês, portanto a aplicação sempre vai exibir os termos em inglês, caso o Locale seja diferente de “pt_BR” ou “es”.

Aqui estão os 3 arquivos de properties onde estarão nossos termos internacionalizados: messages.properties (inglês), messages_es (espanhol) e messages_pt_BR (português do Brasil).

messages.properties
message.title=Internationalization
message.hello=What`s up {0}?
message.goodbye=See ya!

messages_es.properties
message.title=Internacionalización
message.hello=¿Qué pasa {0}?
message.goodbye=¡Hasta la vista!

messages_pt_BR.properties
message.title=Internalionalização
message.hello=E ae {0}, blz?
message.goodbye=Falow!


Boa prática: Criar um enumerator que representa nosso arquivo de properties com todas as suas chaves.
package com.internacionalizacaoexemplo;

public enum MessageEnum {
    
    TITLE("message.title"),
    HELLO("message.hello"),
    GOODBYE("message.goodbye");
    
    private String prop;

    private MessageEnum(String prop) {
        this.prop = prop;
    }

    public String getProp() {
        return prop;
    }    
    
}

ResourceMessages: nossa classe que irá retornar as mensagens internacionalizadas
package com.internacionalizacaoexemplo;

import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;

public class ResourceMessages {
    
    private static final String BUNDLE_NAME = "messages";
    
    public static String getMessage(MessageEnum messageEnum, Locale locale, Object... args ){
        ResourceBundle resourceBundle = null;
        
        if(locale!=null)
            resourceBundle = ResourceBundle.getBundle(BUNDLE_NAME, locale);
        else
            resourceBundle = ResourceBundle.getBundle(BUNDLE_NAME);
        
        String message = null;
        if(resourceBundle!=null){
            message = resourceBundle.getString(messageEnum.getProp());
            if(message!=null && args.length > 0)
                message = MessageFormat.format(message, args);
        }            
        return message;
    }
    
}


Abaixo uma classe para testarmos o ResourceMessages:
package com.internacionalizacaoexemplo;

import java.util.Locale;

public class App 
{
    public static void main( String[] args ){
        
        Locale.setDefault(Locale.ENGLISH);
        
        Locale pt_BR = new Locale("pt", "BR");
        System.out.println("-------------------------------------------------------");
        System.out.println(pt_BR);        
        System.out.println(ResourceMessages.getMessage(MessageEnum.TITLE, pt_BR));
        System.out.println(ResourceMessages.getMessage(MessageEnum.HELLO, pt_BR, "João"));
        System.out.println(ResourceMessages.getMessage(MessageEnum.GOODBYE, pt_BR));        
        
        Locale es_AR = new Locale("es", "AR");
        System.out.println("-------------------------------------------------------");
        System.out.println(es_AR);        
        System.out.println(ResourceMessages.getMessage(MessageEnum.TITLE, es_AR));
        System.out.println(ResourceMessages.getMessage(MessageEnum.HELLO, es_AR, "Juan"));
        System.out.println(ResourceMessages.getMessage(MessageEnum.GOODBYE, es_AR));        
                
        Locale en_US = Locale.US;
        System.out.println("-------------------------------------------------------");
        System.out.println(en_US);        
        System.out.println(ResourceMessages.getMessage(MessageEnum.TITLE, en_US));
        System.out.println(ResourceMessages.getMessage(MessageEnum.HELLO, en_US, "John"));
        System.out.println(ResourceMessages.getMessage(MessageEnum.GOODBYE, en_US));        
                
        Locale chinese = Locale.CHINESE;
        System.out.println("-------------------------------------------------------");
        System.out.println(chinese);        
        System.out.println(ResourceMessages.getMessage(MessageEnum.TITLE, chinese));
        System.out.println(ResourceMessages.getMessage(MessageEnum.HELLO, chinese, "Chin-chan"));
        System.out.println(ResourceMessages.getMessage(MessageEnum.GOODBYE, chinese));        
        
    }
}

Saída:
-------------------------------------------------------
pt_BR
Internalionalização
E ae João, blz?
Falow!
-------------------------------------------------------
es_AR
Internacionalización
¿Qué pasa Juan?
¡Hasta la vista!
-------------------------------------------------------
en_US
Internationalization
What`s up John?
See ya!
-------------------------------------------------------
zh
Internationalization
What`s up Chin-chan?
See ya!


Código fonte: http://depositfiles.com/files/qwrcxn0eq

This is Java! Is we on the tape... traduzindo, é nóis na fita!