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!