23 de dez de 2012

XML com JAXB


O JAXB é um framework Java para processamento de documentos XML. Com ele ó possível converter um XML direto em um bean, o que não era possível por exemplo com DOM.

O JAXB usa anotações para representar elementos, atributos e valores das tags do XML. Como a intenção aqui é apenas introduzir nos senhores, com todo o respeito, vamos à algumas dessas anotações:

  • @XmlRootElement – representa o elemento principal, ou a tag principal do XML.
  • @XmlAccessorType – define onde as anotações JAXB devem ser interpretadas, nos métodos ou atributos
  • @XmlElement – representa uma tag dentro do XML
  • @XmlElementWrapper – encapsula uma lista
  • @XmlAttribute – representa um atributo dentro de uma tag


Antes de começar a desenvolver você vai precisar das dependências:

 javax.xml.bind
 jaxb-api
 2.2.6


 com.sun.xml.bind
 jaxb-impl
 2.2.6


Supunhetamos que nosso modelo de XML seja o seguinte:

    João Borra Cueca
    24
    
        
        
    


Portanto, os beans vão ficar anotados da seguinte maneira:

Pessoa.java
package com.jaxbexample.model;

import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name="pessoa")
@XmlAccessorType(XmlAccessType.FIELD)
public class Pessoa {
    
    @XmlElement
    private String nome;
    
    @XmlElement
    private Integer idade;
    
    @XmlElementWrapper(name="telefones")
    @XmlElement(name="telefone")
    private List telefones;

    public Integer getIdade() {
        return idade;
    }

    public void setIdade(Integer idade) {
        this.idade = idade;
    }

    public String getNome() {
        return nome;
    }

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

    public List getTelefones() {
        return telefones;
    }

    public void setTelefones(List telefones) {
        this.telefones = telefones;
    }
    
    public void addTelefone(Telefone telefone){
        if(telefones==null)
            telefones = new ArrayList();
        telefones.add(telefone);
    }
    
}

Telefone.java
package com.jaxbexample.model;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;

@XmlAccessorType(XmlAccessType.FIELD)
public class Telefone {

    @XmlAttribute(name="codArea")
    private String codArea;
    
    @XmlAttribute(name="numero")
    private String numero;

    public Telefone() {
    }

    public Telefone(String codArea, String numero) {
        this.codArea = codArea;
        this.numero = numero;
    }

    public String getCodArea() {
        return codArea;
    }

    public void setCodArea(String codArea) {
        this.codArea = codArea;
    }

    public String getNumero() {
        return numero;
    }

    public void setNumero(String numero) {
        this.numero = numero;
    }
    
}
Marshalling: é o processo de conversão do bean em xml.

Marshallling.java
package com.jaxbexample;

import com.jaxbexample.model.Pessoa;
import com.jaxbexample.model.Telefone;
import java.io.StringWriter;
import java.io.Writer;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.PropertyException;

public class Marshalling {

    public static void main(String[] args) {

        try {
            
            Pessoa pessoa = new Pessoa();
            pessoa.setNome("João Borra Cueca");
            pessoa.setIdade(24);
            pessoa.addTelefone(new Telefone("12", "1234-5678"));
            pessoa.addTelefone(new Telefone("84", "5678-0123"));
            
            Writer writer = new StringWriter();
            JAXBContext context = JAXBContext.newInstance(Pessoa.class);
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(javax.xml.bind.Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.marshal(pessoa, writer);
            
            System.out.println(writer.toString());
            
        } catch (PropertyException e) {
            e.printStackTrace();
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        
    }
}

Unmarshalling: é o inverso do marshalling, conversão de xml em um bean

Unmarshilling
package com.jaxbexample;

import com.jaxbexample.model.Pessoa;
import java.io.StringReader;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.PropertyException;
import javax.xml.bind.Unmarshaller;

public class Unmarshalling {
    
    public static void main(String[] args) {

        try {
            
            String xml = ""
                            + "Oscar Alho"
                            + "24"
                            + ""
                                + ""
                                + ""
                            + ""
                        + "";
            
            JAXBContext context = JAXBContext.newInstance(Pessoa.class);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            
            Pessoa pessoa = (Pessoa)unmarshaller.unmarshal(new StringReader(xml));
            
            System.out.println(pessoa.getNome());
            
        } catch (PropertyException e) {
            e.printStackTrace();
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        
    }
}

O JAXB é bastante usado, principalmente em frameworks para implementação de web-services. Mas isso é assunto para um outro post.

Código Fonte: http://depositfiles.com/files/i8np23h4f

É isso ae, peixe! Aqui é Java!

8 de dez de 2012

Spring Injection - NoSuchBeanDefinitionException: No unique bean of type


Como vimos no post anterior, injeção de dependência é o bicho. Usando annotations o trabalho fica ainda mais simples. Mas como nem tudo nessa vida são flores...

Vamos imaginar o seguinte cenário. Usando o mesmo exemplo do post anterior, com uma modificação. Agora Printer é uma interface com duas implementações:

Printer.java
public interface Printer {
    
    void print(String text);
    
}

ConsolePrinter.java
@Component
public class ConsolePrinter implements Printer{

    public void print(String text) {
        System.out.print(text);
    }
    
}

FilePrinter.java
@Component
public class FilePrinter implements Printer{

    public void print(String text) {
        ...
    }   
}

Compile o programa... Opa, funcionou!

Execute o programa... Ops!!! Runtime Exception.

org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [com.springinjectionexample2.Printer] is defined: expected single matching bean but found 2: [consolePrinter, filePrinter]

E agora???

O Spring não é vidente, existem dois beans que implementam a interface Printer. Você precisa indicar qual deles deseja usar.

O @Qualifier vai nos ajudar. Vamos fazer uma pequena modificação no AppServices.java
@Service
public class AppServices {
    
    @Autowired
    @Qualifier("consolePrinter") //ou @Qualifier("filePrinter")
    private Printer printer;
    
    public void print(String text){
        printer.print(text);
    }
    
    public void print(Integer number){
        if(number!=null)
            printer.print(number.toString());
    }   
}

Pronto, agora o Spring já sabe qual bean deve utilizar!

O ensinamento de hoje foi esse, pequeno Padawan! May the Java be with you!

Código Fonte: http://depositfiles.com/files/fkrwow6mr

É isso ae, cambada. Aqui é Java!

5 de dez de 2012

Injeção de dependência usando Spring e Annotations


Acho que muitos já ouviram falar ou já trabalharam com Spring. Pois bem, o Spring é um framework Java muito poderoso que implementa entre outras funcionalidades a Injeção de Dependência.

Usando o Spring você poderia muito bem fazer a injeção através de um arquivo XML, criando os beans e referências, o que não é muito complexo. Mas convenhamos, que trabalho de corno!

Para tornar a vida do programador mais fácil, existe a possibilidade e fazer as injeções usando annotations e é isso que veremos a seguir.

Primeiramente você vai precisar da biblioteca do Spring. Segue a dependência para configurar no maven:

 org.springframework
 spring
 2.5.6            


No segundo passo vamos criar as classes da nossa aplicação. Repare nas annotations, elas servirão de referência para o Spring criar as instâncias e injetar as dependências:
  • @Component – indica que é uma classe componente, isto é, quando o Spring efetuar o scanning do código ele deve criar uma instância para a classe. Funciona exatamente como a tag na configuração do XML.
  • @Service – ele extende o @Component, funciona da mesma maneira só que indica que é uma classe específica de serviço.
  • @Autowired – busca a instância da classe criada pelo Spring e insere no atributo.

Printer.java
package com.springinjectionexample;

import org.springframework.stereotype.Component;

@Component
public class Printer {

    public void print(String text){
        System.out.println(text);
    }
    
}

AppServices.java
package com.springinjectionexample;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AppServices {
    
    @Autowired
    private Printer printer;
    
    public void print(String text){
        printer.print(text);
    }
    
    public void print(Integer number){
        if(number!=null)
            printer.print(number.toString());
    }
}

No XML de configuração do Spring vamos inserir a seguinte tag:


A tag indica ao Spring que ele deve efetuar o scan de componentes no pacote “com.springinjectionexample”, criar as instâncias e fazer as injeções.

applicationContext.xml

 
 
 


Pronto, agora é só colocar a aplicação abaixo para rodar:

App.java
package com.springinjectionexample;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App{
    
    public static void main( String[] args ){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        AppServices appServices = (AppServices)context.getBean("appServices");
        
        appServices.print("Me imprime!");
        appServices.print(99);        
    }
}

Só fazendo uma comparação, se fossemos utilizar a configuração apenas com o applicationContext.xml ele ficaria assim:


 
 
  
 
 
 
 



Referência: http://static.springsource.org/spring/docs/2.5.3/reference/beans.html

Código Fonte: http://depositfiles.com/files/dewske0wz

É isso ae, cambada. Aqui é Java!

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!

26 de out de 2012

Gerando classes de entidade a partir do banco de dados usando o Netbeans


Primeiramente um desabafo. Eu sofro muito bullying no meu trampo por utilizar o Netbeans. Quantas vezes eu tive que ouvir:
Nossa!(espanto)... Você usa o Netbeans?
SIM, animal! Não está vendo?!?!

Agora sim, prosseguindo.

Se você é preguiçoso como eu, vai curtir essa dica. Vamos usar o Netbeans para gerar automaticamente o mapeamento JPA de entidades a partir do banco de dados.

Vamos pegar um "case" simples, um sistema de gerenciamento de buteco. Para simplificar ainda mais, um buteco que só vende cerveja.

Aqui está nosso modelo de dados:



Feito isso e com as tabelas criadas no banco de dados os passos são os seguintes:

1. Crie um projeto no Netbeans. Pode ser um projeto padrão ou maven, tanto faz.
2. Clique com o botão direito no projeto > Novo > Outros...



3. Persistance > Classe de entidade do banco de dados > Próximo



4. Crie uma conexão com o banco de dados ou utilize uma já existente



5. Adicione as tabelas para gerar as entidades



6. Agora é só fazer como um desenvolvedor .NET e avançar até finalizar!



Vualá!(O blog é meu e eu escrevo do jeito que eu quiser). As entidades já estão mapeadas.



É isso ae, brow. Aqui é Java!

21 de out de 2012

Struts2 + Velocity


Nesse post vou mostrar uma action simples utilizando Struts2 e Velocity. No post anterior eu introduzi nos senhores, com todo o respeito, algumas noções sobre o VTL(Velocity Template Language). Agora vamos usar o Velocity como a camada de apresentação de uma aplicação web construída com Struts2.

Para aqueles que ainda nunca ouviram falar, o Struts2 é um framework para construção de aplicações web feito em Java. Originalmente o framework era chamado de WebWork 2. Depois de algum tempo as comunidades do Struts e WebWork uniram forças e criaram o Struts2.

Novamente vou utilizar o maven para construir o projeto. Vamos então as dependências necessárias:
        
            org.apache.struts
            struts2-core
            2.2.1
                
        
            org.apache.struts
            struts2-convention-plugin
            2.2.1
                
        
            org.apache.velocity
            velocity
            1.7
                
        
            org.apache.velocity
            velocity-tools
            2.0
        

A estrutura do projeto vai ficar assim:



Dentro do diretório /src/main/resources ficarão os arquivos de configuração do Struts2 e Velocity. Não entrarei em detalhes sobre cada linha de configuração, mas obviamente esses arquivos são essenciais para o funcionamento do framework.

No diretório /src/main/webapp ficarão os templates velocity. O arquivo VM_global_library.vm é o template de macros. Dentro dele você pode personalizar as macros que irá utilizar no seu projeto. As macros são armazenadas em memória portanto executas com maior rapidez.

Configuração do web.xml:


             
     Struts2+Velocity-AppExample
    
   
  index.html
   
        
 
  struts2
  org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
 

 
  struts2
  /*
 


Com o projeto configurado vamos agora criar uma action de teste usando annotations. Como é de costume a primeira implementação sempre é um HelloWorld, mas como aqui é Java, vamos criar um HelloMano!
package com.struts2velocityexemplo.action;

import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;

public class HelloManoAction {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @Action(value = "/hello-mano", results = {
        @Result(name = ActionSupport.SUCCESS, type = "velocity", location = "/hello-mano.vm")})
    public String helloMano(){
        return ActionSupport.SUCCESS;
    }
}

Para que a action utilize um template velocity é necessário informar no @Result o type=”velocity” e o location do template, no caso o hello-mano.vm.

hello-mano.vm:
#include('header.vm')

Hello Mano

#if($!name)

Eaeeee $name.

Firmeza, truta?

#else
#end #include('footer.vm')

Um template bem simples. Se existir o $name exibir a saudação, senão exibir um formulário para enviar o nome. Note que existe um include do header e do footer que são templates separados.

Agora é só botar o projeto para rodar e ver o resultado!





Código fonte: http://depositfiles.com/files/8nfdutgzo

É isso ae truta. Aqui é Java!

18 de out de 2012

Velocity Template Language (VTL)



Bom, decidi começar a escrever esse blog para compartilhar meus conhecimentos, experiências e mágoas que todos esses anos programando em Java me proporcionaram. Comecemos então pelas mágoas!

Se tem uma coisa que eu odeio em Java é JSP. Onde já se viu inserir código Java na camada de View? Ah, mas você pode usar as tag-libs... Aí eu te pergunto, você já fez um for, if ou criou uma variável usando tag-lib? Tem que concordar comigo que o negócio é difícil e nem um pouco intuitivo.

Deixando um pouco bronca de lado, para a minha alegria um certo dia fui apresentado ao Velocity, e desde então mandei o JSP pra PQP.

O Velocity é uma linguagem de template desenvolvida em Java. Ela pode ser usada tanto para aplicações standalone, que podem ser geradores de relatórios por exemplo, quanto para aplicações web sendo a camada de view do MVC.

Para começar vamos criar uma aplicação standalone simples usando velocity, só para ter uma noção de como a engine funciona e as suas principais tags de marcação.

Para construir o aplicativo vamos usar um projeto maven. Se você não tem a mínima idéia do que seja isso, chegou a hora de aprender. Tudo o que você precisa saber está nesse link: http://maven.apache.org/.

Dentro do nosso pom.xml você deve, portanto, inserir o velocity como dependencia.
    
      org.apache.velocity
      velocity
      1.7      
     
Aqui estão os passos para se criar a aplicação:
  1. Criar uma instância do VelocityEngine
  2. Criar um contexto onde serão inseridos as instâncias de objetos que o template vai utilizar
  3. Carregar um template
  4. Efetuar o merge do template com o contexto e obter o resultado, que é saída renderizada.
package com.velocityexemplo;

import java.io.StringWriter;
import java.io.Writer;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;

/**
 * Hello Velocity!
 *
 */
public class App {

    public static void main(String[] args) {
        VelocityEngine velocity = new VelocityEngine();
        velocity.init(ClassLoader.getSystemResource("velocity.properties").getFile());

        VelocityContext context = new VelocityContext();
        context.put("name", "Fulano");
        context.put("lista", new String[]{"Tomate","Cebola", "Macarrão", "Arroz", "Feijão"});

        Template template = velocity.getTemplate("hello-velocity.vm");    
        
        Writer writer = new StringWriter();
        template.merge(context, writer);
        
        System.out.println(writer);
    }
}

Na linha 3 você vai perceber que a engine foi inicializada utilizando um arquivo de configuração (velocity.properties). Não vou entrar em detalhes sobre a configuração, que você poderá obter no site oficial do projeto. A única linha relevante para entender o funcionamento do programa é essa aqui:
file.resource.loader.class = org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader

Isso significa que os templates serão carregados a partir do classpath do projeto. Mas existe a possibilidade de carregá-los através de um diretório externo no filesystem da máquina.
Enfim... nas linhas seguintes foram criadas uma variável e um array. E o merge feito com o template hello-velocity.vm.
Até agora nós apenas criamos o aplicativo. A parte interessante vem a seguir... o template!
#include('header.vm')

Olá $name!

Aqui está a lista de compras do supermercado.

Lista de compras:
#set($count = 1)
#foreach($item in $lista)
  #if($item == 'Arroz')
    $count - $item (não esquecer)
  #else
    $count - $item 
  #end
  #set($count = $count + 1)    
#end

#parse('footer.vm')

A instrução #include, na linha 1, faz a inclusão de outro template.
A linha 3 faz a impressão da variável $name, incluida no contexto.
A instrução #set cria uma variável, neste caso um contador.
O #foreach faz a iteração sobre uma lista de objetos.
A instrução condicional #if/#elseif/#else é trivial.
E no final o #parse faz a inclusão de um template, mas diferentemente do #include, o #parse interpreta as instruções VLT(Velocity Template Language).

Bom, para um primeito post acho que está de bom tamanho. Para conhecer a fundo as instruções do Velocity, seguem abaixo os links. E no próximo post, minha dupla favorita. Não é o "Victor & Leo", e sim "Struts2 & Velocity".

http://velocity.apache.org/
http://velocity.apache.org/engine/devel/vtl-reference-guide.html

Código fonte: http://depositfiles.com/files/9marhpe10

Tá tirando, mano? Aqui é Java!