quarta-feira, dezembro 07, 2011

Persistência - JPA: DAO Genérico

Olá Seres Java!

Dando continuidade ao post anterior, demonstrarei o emprego do padrão DAO para realizar a persistência por meio da especificação JPA. O uso do pattern DAO, além de prover um melhor design para aplicação, agregar princípios de boas práticas, propicia um melhor reaproveitamento de implementação.

Segundo o Core J2EE Patterns, um Data Access Object:
Access to data varies depending on the source of the data. Access to persistent storage, such as to a database, varies greatly depending on the type of storage (relational databases, object-oriented databases, flat files, and so forth) and the vendor implementation.
Desta forma, entende-se que emprego de um DAO na aplicação propicia um ponto central, para acesso a dados, fazendo uso de um quantitativo de classes relativamente pequenos.

Tomando como base o projeto implementado no post anterior, será acrescida a estrutura de persistência por meio do DAO Genérico, assim, segue-se:

Criação da Interface DAO, esta deverá listar os métodos comuns a serem implementados por todos os DAOs:

Interface DAO:
package br.com.serjava.persistencia.dao;

import java.io.Serializable;
import java.util.List;

import javax.persistence.EntityManager;

public interface DAO<T, I extends Serializable> {

 public T save(T entity);
 
 public void remove(T entity);
 
 public T getById(Class<T> classe, I pk);
 
 public List<T> getAll(Class<T> classe);
 
 public EntityManager getEntityManager();
}


Uma vez concluído a interface DAO, criaremos uma classe abstrata (ou seja, só poderá ser extendida por outra, e não instanciada) denominada DAOImpl, esta conterá a implementação genérica dos métodos comuns:


DAOImpl:
package br.com.serjava.persistencia.dao.impl;

import java.io.Serializable;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;

import br.com.serjava.persistencia.dao.DAO;
import br.com.serjava.persistencia.util.Conexao;

public abstract class DAOImpl<T, I extends Serializable> implements DAO<T, I>{

 private Conexao conexao;
 
 @Override
 public T save(T entity) {
  
  T saved = null;
  
  getEntityManager().getTransaction().begin();
  saved = getEntityManager().merge(entity);
  getEntityManager().getTransaction().commit();
  
  return saved;
 }

 @Override
 public void remove(T entity) {
  getEntityManager().getTransaction().begin();
  getEntityManager().remove(entity);
  getEntityManager().getTransaction().commit();
  
 }

 @Override
 public T getById(Class<T> classe, I pk) {
  
  try {
   return getEntityManager().find(classe, pk);
  } catch (NoResultException e) {
   return null;
  }
  
 }

 @SuppressWarnings("unchecked")
 @Override
 public List<T> getAll(Class<T> classe) {
  
  return getEntityManager().createQuery("select o from " + classe.getSimpleName() + " o").getResultList();
 }

 @Override
 public EntityManager getEntityManager() {
  
  if (conexao == null) {
   conexao = new Conexao();
  }
  return conexao.getEntityManager();
 }

}


Uma vez criada a implementação base, resta-nos criar a interface que descreverá os métodos de um DAO referente a produto, que é a nossa entidade mapeada pelo JPA, assim temos que:


ProdutoDAO:
package br.com.serjava.persistencia.dao;

import br.com.serjava.persistencia.entity.Produto;

public interface ProdutoDAO extends DAO<Produto, Integer> {

}

Observem que a interface para Produto, é um DAO, como pode ser observado, esta extends a interface DAO padrão. Neste momento a estrutura genérica criada é tipada, quando informou-se: [...] extends DAO<Produto..., em outras palavras, estamos dizendo ao compilador da JVM que os métodos básicos herdados do DAO por ProdutoDAO, aceitarão exclusivamente objetos de Produto, desta forma, em tempo de compilação, se acidentalmente um desenvolvedor passar como parâmetro um objeto que não seja de Produto, será lançado um erro de compilação.

E, finalmente, tem-se a implementação de ProdutoDAO:


ProdutoDAOImpl:
package br.com.serjava.persistencia.dao.impl;

import br.com.serjava.persistencia.dao.ProdutoDAO;
import br.com.serjava.persistencia.entity.Produto;

public class ProdutoDAOImpl extends DAOImpl<Produto, Integer> implements ProdutoDAO {

}

Feito isto, temos nossa estrutura de persistência genérica, e sua implementação para persistirmos um objeto de Produto, na classe Main, criada no post anterior, demonstrarei o processo para se salvar e listar os objetos salvos:

public class Main {

 public static void main(String... args) {
  
  
  Produto produto = new Produto();
  produto.setNomeProduto("produto");
  produto.setQuantidade(22);
  produto.setValor(33.99);
  
  ProdutoDAO produtoDAO = new ProdutoDAOImpl();
  
  //salva um produto
  produtoDAO.save(produto);
  
  List<Produto> listaProdutosCadastrados = produtoDAO.getAll(Produto.class);
  
  for (Produto p : listaProdutosCadastrados) {
   System.out.println(p.getNomeProduto());
  }

 }
}


Aconselho, utilizando-se o mesmo princípio, testarem os demais métodos genéricos por meio de produto (getById, remove).

Para uma melhor compreensão da estrutura do projeto, segue sua estrutura e divisão de pacotes:

Bom, por este post é isto! Espero que tenham gostado e visualizado a flexibilidade que uma implementação genérica propicia!

terça-feira, dezembro 06, 2011

Persistência - JPA: Primeiros passos

Olá pessoAll!

Neste tópico abordarei a configuração e os primeiros passos para se usar a persistência de dados com um framework Objeto-Relacional (ORM).

Observo que muitas pessoas, principalmente iniciantes em desenvolvimento, têm grande interesse por tal aprendizado, porém, num primeiro momento encontram dificuldades que realmente tornam-se impactantes ao estudo e, consequentemente, ao aprendizado.

CONTEXTO
A grande motivação para o uso de um framework ORM em uma aplicação deu-se, mediante ao seguinte paradigma: de um lado encontra-se o banco de dados no SGBD (calcado suas bases na álgebra e o cálculo relacional) e de outro, o modelo da aplicação orientado a objetos, onde, ambos, representam, e uma forma ou de outra, a estrutura da aplicação. Neste sentido, deveria ser fácil realizar tal conversão: OO to Relational.

Embora, em tese, seria fácil tal conversão, verificou-se significativo trabalho e custo (tempo) para transformar um Modelo Orientado a Objetos, por meio e seu DAO (Data Access Object), utilizando-se JDBC.

Visando atender a esta necessidade, bem como, prover maior produtividade no desenvolvimento, surgiram-se várias propostas para a realização do mapeamento objeto-relacional, tais como: Hibernate, TopLink, EclipseLink, e outros. Neste cenário, cada proposta, evidentemente, trazia consigo suas especificidades no quesito implementação.

No intuito de se padronizar a implementação de tecnologias ORM, surgiu a JPA (Java Persistence API), que especificou o uso de ferramentas ORM. Em teoria, qualquer framework que implemente o padrão JPA deve funcionar igualmente.

MÃO NA MASSA
Será utilizado o SGBD PostgreSql para a a implementação.
Baseado no DER da tabela produto, exibido pela Figura 1:
Tem-se o script de criação da tabela, no SGBD:
CREATE TABLE produto
(
  id_produto serial NOT NULL,
  nm_produto character varying(45),
  quantidade integer,
  valor numeric,
  primary key produto_pkey PRIMARY KEY (id_produto)
)

Criaremos um projeto intitulado como Persistencia, do tipo Java Project no Eclipse. Posteriormente, devemos acrescer a característica de um projeto JPA, para tanto, clique com o botão direito sobre o projeto criado, e selecione a opção Properties.
Em seguida, seleciona na barra lateral, a opção Project Facets, e clique no link Convert do Faceted Form, e marque a opção JPA, conforme a Figura 2:

Observe que logo abaixo do quadro de opções, apareceu um alerta, "further configuration required", isto acontece pois o Eclipse não contém os artefatos necessários para serem adicionados ao classpath da aplicação. Para resolvermos isto, e colocarmos manualmente todos os artefados, clique sobre o link desta mensagem, e no combo Type, selecione Disable Library Configuration, conforme Figura 3:


Em seguida, clique em Ok, e o projeto ja deverá estar pronto para procedemos a configuração do JPA. Devemos, num primeiro momento, adicionarmos os artefatos necessários a isto, assim, na mesma hierarquia do diretório src do projeto, criaremos o diretório libs.

Tendo criado o diretório, adicionaremos os artefatos necessários, identifique-os na Figura 4:


Para a obtenção destes artefatos, acesse o sites: http://commons.apache.org/http://www.hibernate.org/ , http://www.slf4j.org/http://jdbc.postgresql.org/, ou então, como uma simples busca pela nomenclatura de cada arquivo.

Uma vez adicionados os artefatos necessários, resta referenciá-los aos classpath da aplicação, para isso, selecione todos eles, clique com o botão direito sobre, e siga as opções: Build Path --> Add to build path. Pronto, todas as dependências estão devidamente adicionadas e referenciadas.

O arquivo persistence.xml, contido em META-INF, dentro de src, deverá conter os dados necessários para conexão, devemos parametrizá-lo do seguinte modo:

 
 
  org.hibernate.ejb.HibernatePersistence
  
  
   
   
   
   
  
 
 


Observe que os dados de acesso ao banco foram parametrizados, tais como, url para acesso, usuário e senha (atenção, estes dados podem variar no seu ambiente).

CONEXÃO E MAPEAMENTO

A conexão com o banco de dados é gerida pelo EntityManager, da própria especificação Java Persistence API, este contém os métodos necessários para que o ORM realize suas operações de forma adequada.

Devemos criar um objeto Java que representará a estrutura da tabela produto que criamos no banco. Nesta classe, efetuaremos o mapeamento de modo que o JPA consiga entender o que o objeto e seus atributos representam no modelo relacional, assim segue-se:
package br.com.serjava.persistencia.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name="produto")
@SequenceGenerator(name="produto_id_produto_seq", sequenceName="produto_id_produto_seq", allocationSize=1)
public class Produto implements Serializable {

 @Id
 @GeneratedValue(generator="produto_id_produto_seq", strategy=GenerationType.SEQUENCE)
 @Column(name="id_produto")
 private Integer idProduto;
 
 @Column(name="nm_produto")
 private String nomeProduto;
 
 @Column(name="quantidade")
 private Integer quantidade;
 
 @Column(name="valor")
 private Double valor;
        //getters and setters



Criaremos agora a classe de conexão, que deverá gerar o EntityManager, portanto:
public class Conexao {

 //nome da unidade de persistencia definia no persistence.xml
 private static final String UNIT_NAME = "PersistenciaPU";
 
 private EntityManagerFactory emf = null;
 
 private EntityManager em = null;
 
 public EntityManager getEntityManager() {
  
  if (emf == null) {
   emf = Persistence.createEntityManagerFactory(UNIT_NAME);
  }
  
  if (em == null) {
   em = emf.createEntityManager();
  }
  
  return em;
 }

Demonstrarei, como persistir um objeto de produto gerido pelo contexto de persistência do JPA, em posts futuros, abordarei as demais possibilidades e operações do JPA. Assim, necessitamos obter o EntityManager, e por ele, persistir o objeto Produto, que foi devidamente mapeado:
public class Main {

 public static void main(String... args) {
  
  Produto produto = new Produto();
  produto.setNomeProduto("produto");
  produto.setQuantidade(22);
  produto.setValor(33.99);
  
  EntityManager em = new Conexao().getEntityManager();
  
  em.getTransaction().begin();
  em.persist(produto);
  em.getTransaction().commit();
 }
}

Execute a classe Main, e verifique no banco que deverá haver um registro com as informações atribuidas ao objeto Produto.

Espero que tenham gostado, tentei resumir um vasto e detalhado processo da forma mais simples e objetiva possível, espero ter atendido as expectativas.
Até breve!

sexta-feira, novembro 18, 2011

Spring Framework: primeiros passos

Olá pessoal!

Demonstrarei neste post, como seu próprio título diz, os primeiros passos para se trabalhar com o popular e usual SpringFramework.

Segundo o Guia de Referência do Spring, este é definido como: "Spring Framework is a Java platform that provides comprehensive infrastructure support for developing Java applications. Spring handles the infrastructure so you can focus on your application.".

De modo geral, o uso do Spring permite a construção de aplicações a pártir de POJOs, seus recursos aplicam-se totalmente ao JSE e parcialmente ao JEE; seu uso permite a construção ágil de aplicações, de modo a garantir uma melhor coesão e baixo acoplamento.

Apesar de ser possível o uso de anotações para sua manipulação, neste primeiro post, demonstrarei seu uso somente a partir das configurações nativas em XML.

Para tanto, como nos demais posts, usarei a IDE Eclipse. Criaremos um projeto JSE convencional, onde simularemos a chamada a um componente de negócio, e este, chamará um objeto de acesso a dados hipotético, de modo a demonstrar a injeção de dependência entre os beans gerenciados pelo Spring.

CONSTRUÇÃO DO PROJETO
Assumindo que o projeto já tenha sido devidamente criado, criaremos uma interface denominada de TesteComponent, a qual representa um componente de negócio hipotético, e uma classe que a implementa, sendo TesteComponentImpl; tal componente, deverá chamar uma ação hipotética de um DAO, que será injetado pelo contexto do spring. Seguem as implementações: (atentem-se aos pacotes criados nos quais cada implementação está contida):

TesteDAO:
package br.com.serjava.dao;

public interface TesteDAO {

 public void metodoDao();
}

TesteDAOImpl:
package br.com.serjava.dao.impl;

import br.com.serjava.dao.TesteDAO;

public class TesteDAOImpl implements TesteDAO {

 @Override
 public void metodoDao() {
  System.out.println("método de acesso a dados executado");
  
 }

}

TesteComponent:
package br.com.serjava.component;


public interface TesteComponent {
 
 public void metodoTeste();
}


TesteComponentImpl
package br.com.serjava.component.impl;

import br.com.serjava.component.TesteComponent;
import br.com.serjava.dao.TesteDAO;

public class TesteComponentImpl implements TesteComponent {

 private TesteDAO testeDAO;
 
 public TesteComponentImpl(TesteDAO testeDAO) {
  this.testeDAO = testeDAO;
 }
 
 
 @Override
 public void metodoTeste() {
  System.out.println("Método teste executado!");
  
  testeDAO.metodoDao();
  
 }

}

Para uma melhor compreensão da arquitetura utilizada pelo projeto, segue um print da estrutura da pacotes da IDE:
Figura 1 - Estrutura projeto
Inclusão do Spring
Para adicionarmos as funcionalidades do Spring necessitamos fazer download de seus artefatos, este podem ser obtidos em: http://www.springsource.com/download/community, neste post utilizei a versão 3.1.0M2.

Para a adição das dependências, criaremos um diretório denominado de lib, na mesma hierarquia do diretório src. Dentro de lib, colocaremos os jars do Spring e suas dependências que se fizerem necessárias, para este exemplo, apenas: commons-logging, que pode ser obtido em http://commons.apache.org/logging/. Observe os arquivos que devem ser adicionados:
Uma vez adicionados os arquivos listados acima, devemos adicioná-los aos classpath da aplicação, basta clicar sobre cada um com o botão direito --> BuildPath --> Add to BuildPah. Pronto, as dependências do Spring estão devidamente configuradas.

Para configurarmos as classes que criamos para serem gerenciadas pelo Spring, criaremos o arquivo applicationContext.xml, dentro de src (deverá ficar como mostrado na Figura 1), segue o conteúdo do arquivo:


 
 
 
  
  
  







Execução
Por fim, para executarmos o projeto e testarmos o Spring, criaremos uma classe denominada por Main, para fazer a chamada inicial:
package br.com.serjava.view;

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

import br.com.serjava.component.TesteComponent;

public class Main {

 public static void main(String... args) {
  
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  
  TesteComponent testeComponent = (TesteComponent) context.getBean("testeComponent");
  
  testeComponent.metodoTeste();
 }
}

Observe que em nenhum momento, na implementação, instanciou-se algum objeto usando-se new, as instâncias deverão serem geradas e gerenciadas pelo Spring, baseadas na injeção de dependência.

Executado o projeto, o resultado deverá ser, no console da ide:


Método teste executado!
método de acesso a dados executado


Espero que tenham gostado do Spring, em breve novos posts com demais funcionalidades e sua configuração e uso em projetos Web.

segunda-feira, novembro 14, 2011

DWR: Trabalhando com objetos

Olá pessoal! 
Em primeiro momento, agradeço aqueles que têm acompanhado o blog e ao feedback positivo.

Dando continuidade do estudo do DWR Direct Web Remoting, demonstrarei o uso de objetos Java no código JavaScript. Para ilustrar o exemplo, utilizarei a estrutura do projeto iniciado no primeiro post de DWR (http://serjava.blogspot.com/2011/10/dwr-primeio-projeto.html), simulando o cadastro de Funcionários.

O primeiro passo é criarmos um objeto que contenha as características do funcionário, para tanto, utilizarei o padrão DTO – Data Transfer Object, criando então FuncionarioDTO:


Esta classe deverá conter os seguintes atributos:
package br.com.serjava.dto;

public class FuncionarioDTO {

 private Integer codigo;
 
 private String nome;
 
 private String cargo;
 
 private Double salario;

//getters and setters


O próximo passo, é mapear esta classe no arquivo dwr.xml, para isso basta adicionarmos a sequinte linha no referido arquivo:
<convert converter="bean" match="br.com.serjava.dto.FuncionarioDTO" javascript="Funcionario"/>


Uma vez tendo mapeado tal classe, permitimos que esta seja reconhecida dentro do context do DWR, no atributo javascript, informamos o nome de Funcionario, este será o nome para o acesso via JavaScript.

Criaremos a classe para tratar as chamadas Ajax referentes ao funcionário, chamaremos de FuncionarioAjax, conforme imagem:
Criaremos dois métodos nesta classe, um que será responsável pelo cadastro dos funcionários, e outro que deverá obter os funcionários cadastrados. Observe que foi criada uma lista de funcionários estática, para armazenar os funcionários. Evidentemente que esta, num ambiente real, deverá ser substituída pelo repositório de dados.

package br.com.serjava.dwr;

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

import br.com.serjava.dto.FuncionarioDTO;

public class FuncionarioAjax {

 private static List<FuncionarioDTO> listaFuncionarios = new ArrayList<FuncionarioDTO>();
 
 public void cadastrarFuncionario(FuncionarioDTO funcionarioDTO) {
  
  System.out.println("funcionariod: " + funcionarioDTO.toString());
  listaFuncionarios.add(funcionarioDTO);
 }
 
 public List<FuncionarioDTO> obterFuncionarios() {
    
  return listaFuncionarios;
 }
}



Devemos mapear a classe FuncionarioAjax no arquivo dwr.xml, de modo a poder ser acessada via função JavaScript, para tanto:
<create creator="new" javascript="FuncionarioAjax">
    <param name="class" value="br.com.serjava.dwr.FuncionarioAjax"/>
</create>
Criaremos uma página jsp para conter o cadastro destes funcionários, esta ficará na raiz de WebContent. 
Depois de criada a página, antes de mais nada, devemos adicionar os imports para uso posterior, o que inclui, as funções do DWR e a classe mapeada para receber as solicitações ajax, então deve-se adicionar, dentro da tag head:



Criaremos agora o esboço para o formulário de cadastro, dentro da tag body:


Código
Nome
Cargo
Salário
Observe que o botão cadastrar chama uma função javascript, esta será responsável por criar o objeto JavaScript que representa nosso objeto FuncionarioDTO, esta função foi implementada do seguinte modo, dentro da tag head:
function cadastrarFuncionario() {
   
   var funcionario = {
    codigo: dwr.util.getValue('idCodigo'),
    nome: dwr.util.getValue('idNome'),
    cargo: dwr.util.getValue('idCargo'),
    salario: dwr.util.getValue('idSalario')
   };
   
   FuncionarioAjax.cadastrarFuncionario(funcionario, {
    callback:function() {
     alert('funcionário cadastrado');
    }
   });
  }
Observe que a variável criada como funciona'rio, tem seus atributos nomeado de forma idêntica aqueles da classe FuncionarioDTO, usamos a função dwr.util.getValue, para obter o value de um elemento informado seu id, observe que os valores informados correspondem com os ids denominados para cada input; ela é similar a função document.getElementById.

Como pode ser observado, atribuímos os valores correspondentes a cada atributo do objeto funcionario, em seguida chamamos a função cadastrarFuncionario;

Para melhorar nosso modelo, a cada funcionário cadastrado, será exibido numa tabela abaixo do formulário de cadastro, para isso criaremos uma tabela do seguinte modo, abaixo do referido formulários:
Observe que não foi feita nenhuma implementação para esta tabela.

Criaremos uma função javaScript responsável por obter os dados para popular a tabela:
function carregarTabela() {
   
   var cellsFuncionario = [
                  function(funcionario) {return funcionario.codigo;},
                  function(funcionario) {return funcionario.nome;},
                  function(funcionario) {return funcionario.cargo;},
                  function(funcionario) {return funcionario.salario;},
                  ];
   
   FuncionarioAjax.obterFuncionarios({
    callback:function(listaFuncionarios) {
     dwr.util.removeAllRows('tableFuncionarios');
     
     dwr.util.addRows( "tableFuncionarios", listaFuncionarios, cellsFuncionario, {escapeHtml:false});
    }
   });
  }

Para que depois de cadastrado um funcionário a tabela seja atualizada, na função de cadastro, onde verifica-se o alert, remova-o e adicione uma chamada a esta função, devendo ficar do seguinte modo:
function cadastrarFuncionario() {
   
   var funcionario = {
    codigo: dwr.util.getValue('idCodigo'),
    nome: dwr.util.getValue('idNome'),
    cargo: dwr.util.getValue('idCargo'),
    salario: dwr.util.getValue('idSalario')
   };
   
   FuncionarioAjax.cadastrarFuncionario(funcionario, {
    callback:function() {
     carregarTabela();
    }
   });
  }

Por fim, o resultado esperado, depois de uma inclusão deverá ser similar a:
Espero que tenham gostado! Em breve postarei mais especificidade e recursos sobre o DWR.

quarta-feira, outubro 26, 2011

PostgreSql: PgScript - Criando massa de dados

Este post, embora não seja especificamente de Java, como o nome do blog sugere, mas por certo será de grande utilidade para todos, haja vista que o uso de SGBDs está implicito na tarefa de desenvolvimento, seja com Java (espero que seja sempre com Java) ou em qualquer outra linguagem.

A geração de massa de dados é muito importante para que testemos o sistema num quantitativo de registros significante, e assim, mensurar o desempenho aproximado do ambiente de produção. Muitas são as formas de gerar tal massa de dados, mas manter o relacionamento em tal geração geralmente requer certo trabalho.

Para usuários do PostgreSql, este dispõe em sua ferramenta de administração, o pgAdminIII, o recurso chamado de pgScript. Utilizando-se deste recurso, a geração de tal massa de dados é feita dentro do ambiente do SGBD, o que otimiza a manutenção dos relacionamentos e tempo demandado para a elaboração da rotina.

Vamos considerar a seguinte modelagem para o exemplo de geração:
 Tem-se o script de criação:
create table autor(
id_autor serial,
nome  varchar(50),
sexo  varchar(1),
primary key (id_autor));


create table livro (
id_livro serial,
id_autor integer,
titulo  varchar(45),
editora  varchar(45),
isbn  varchar(45),
edicao  varchar(45),
data_publicacao date,
preco_venda numeric,
primary key (id_livro),
foreign key (id_autor) references autor (id_autor));

CONCEITOS pgSCRIPT

Atribuição:
set @varName = value;
Printar valor:
print @varName;
Controladores de fluxo:
if, while
Geração aleatória de dados: 
Exemplos:
  • gerar inteiros aleatórios entre 1 e 999:
set @inteiro = integer(1,999);
  • gerar um valor textual com 3 "palavras" entre 5 e 10 caracteres:
set @texto = string(5,10,3);

Tomando a modelagem exposta acima, entende-se que um autor pode ter vários livros. Simularemos a inserção de 200 autores relacionando cada um com 100 livros, para tanto, no console do pgAdmin, criamos:
set @idAutor = 1;
set @idAutor = 1;
set @nome = string(5,11,3); -- 3 palavras entre 5 e 11 caracteres;
set @sexo = string(1,1);

--variáveis para inserção em livro
set @titulo = string(3,10,3);
set @editora = string(6,15,2);
set @isbn = string(20,20,1);
set @edicao = string(1,8,2);
set @dataPublicacao = date('01/01/1990', '26/10/2011');
set @preco = real(9,200,2);

while @idAutor <= 200
begin
 insert into autor (id_autor, nome, sexo)
 values ('@idAutor', '@nome', '@sexo');

 set @contLivros = 0;

 while @contLivros < 100
 begin
  insert into livro (id_autor, titulo, editora, isbn, edicao, data_publicacao, preco_venda)
  values('@idAutor', '@titulo', '@editora', '@isbn', '@edicao', '@dataPublicacao', '@preco');

  set @contLivros = @contLivros + 1;
 end

 set @idAutor = @idAutor + 1;
end


Neste momento nossa massa de dados para autores e livros está pronta, repare que a inserção é realizada de modo a fazer uso da relação 1:N entre autor e livro. Constituído o script, pressione o botão "Execute pgScript" ou tecle <<F6>>. Você verificará o console executar os scripts:
Observe que com o uso do pgScript, integrado nativamente ao pgAdminIII, este proporciona grande agilidade no desenvolvimento para a geração de massa de dados. Outras alternativas para tal geração, por certo demandam maior trabalho e tempo de configuração. A grande vantagem do se usar o pgScript, é poder manter o relacionamento na tarefa de inserção.

Espero que tenham gostado!

quinta-feira, outubro 20, 2011

DWR: Primeiro Projeto

DWR – Direct Web Remoting

DWR é um framework para se trabalhar com chamadas Ajax em implementações Java. Uma chamada Ajax é uma solicitação assíncrona de um recurso do sistema, ou seja, enquanto a solicitação é processada, o usuário pode interagir com outras partes do sistema até sua resposta.

É inerente a uma chamada Ajax: HTML, XHTML, CSS, DOM, XML, XMLHttpRequest, JavaScript. O grande benefício do uso do Ajax, certamente, é a possibilidade de maior interação do usuário com a aplicação, construção de aplicações ricas para a web, além de, melhor tempo resposta perceptível.
Diagrama de uma chamada Ajax:
 
No intuito de otimizar o desenvolvimento de aplicações Java que façam uso de Ajax, o uso do DWR é bastante aceito, por ser uma ferramenta Open Source, por propiciar chamadas seguras a códigos Java a pártir de um browser, integrável com os principais frameworks de mercado, encapsula detalhes e complexidades da implementação do XMLHttpRequest, realiza a conversão de classes Java para implementações JavaScript, permitindo seu uso dentro de um browser.
O diagrama abaixo demonstra o uso do DWR em uma solicitação Ajax a uma implementação Java:
 
O PROJETO
Utilizando a IDE Eclipse, crie um novo Dynamic Web Project, conforme imagem abaixo:

 
Finalize a criação.
Para obter o arquivo dwr.jar, faça o download do mesmo em: http://directwebremoting.org/dwr/downloads/index.html
O DWR usa o artefato commons-logging.jar, portanto, este arquivo será necessário, pode ser obtido a partir de: http://commons.apache.org/logging/
Copie ambos arquivos para o diretório WEB-INF\lib do seu projeto.
Devemos configurar o servlet do DWR em nosso projeto, abra o arquivo web.xml de seu projeto e adicione:


  DWR Servlet
  dwr-invoker  
  org.directwebremoting.servlet.DwrServlet
  
     debugtrue



  dwr-invoker
  /dwr/*



É necessário, também, a criação de um arquivo de configuração do DWR, crie o arquivo como abaixo descrito, este deve constar no diretório WEB-INF de seu projeto, com o nome de dwr.xml:

  
    
          
  

Feito estas configurações, o DWR deverá estar pronto para uso. Inicie seu servidor, neste exemplo utiliza-se Tomcat 7, e acesse sua aplicação do seguinte modo:
 
Observe que o projeto lista o JavaScript JDate, que contém a classa java.util.Date em sua versão para JavaScript, convertida pelo DWR. Se você clicar sobre o link JDate, verá listados todos os métodos relativos a classe java.util.Date.
Nosso projeto apresentará o calculo do IMC (índice de massa córporea), onde a chamada e a apresentação do resultado serão via Ajax.
Para tanto, criaremos uma classe, como mostra a figura a seguir:
 
Implementamos a lógica como:
package br.com.serjava.dwr;

public class CalculoIMCAjax {

 public String calcularImc(Double peso, Double altura) {

  Double imc = (peso / Math.pow(altura, 2));

  if (imc < 18.5) {
   return "Seu imc é: " + imc + " Abaixo de 18,5 Você está abaixo do peso ideal";
  } else if (imc >= 18.5 && imc < 24.9) {
   return "Seu imc é: " + imc + " Entre 18,5 e 24,9 Parabéns — você está em seu peso normal!";
  } else if (imc >= 24.9 && imc < 29.9) {
   return "Seu imc é: " + imc + " Entre 25,0 e 29,9 Você está acima de seu peso (sobrepeso)";
  } else if (imc >= 29.9 && imc < 34.9) {
   return "Seu imc é: " + imc + " Entre 30,0 e 34,9 Obesidade grau I";
  } else if (imc >= 34.9 && imc <= 39.9) {
   return "Seu imc é: " + imc + " Entre 35,0 e 39,9 Obesidade grau II";
  } else {
   return "40,0 e acima Obesidade grau III";
  }

 }
 
}

Devemos mapear a classe acima como um objeto do DWR, para isso deve-se editar o arquivo dwr.xml incluindo o seguinte:

       

Criaremos a página que apresentará o conteúdo, crie, caso já não exista, a página index.jsp, dentro do diretório WebContent, segue a implementação:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>




Insert title here
   
     
   
 
 






Altura (m)
Peso (kg)
O resultado final deverá ser:
 
Aguarde próximos posts sobre DWR.

domingo, outubro 16, 2011

Maven: Configurar o proxy

Olá pessoal!

Como já devem ter acompanhado no post anterior, o uso do maven implica no download constante de artefatos e depedências, que serão utilizados pelo próprio maven na construção do projeto, bem como, pelo projeto a ser construído.

Comumente nos ambientes empresariais e educacionais verifica-se a existência de proxy. Se este não for devidamente configurado o maven, por certo, não fará a gerência completa de seu projeto, o que o deixará bastante nervoso!
Felizmente a configuração do proxy é bastante simples:
  1. Localize o diretório conf dentro da pasta de instação do maven em sua máquina;
  2. Edite o arquivo settings.xml, que deverá estar contido dentro do diretório acima especificado.
  3. Encontre a tag <proxies>, verifique as alterações abaixo:

    
      optional
      true
      http
      proxyuser
      proxypass
      proxy.host.net
      80
      local.net|some.host.com
       
  

As tags referem-se:
  • id: informe qualquer nome para identificar esta configuração de proxy;
  • active: true ou false, indica se esta configuração de proxy está ativa, portante deixaremos true;
  • protocol: indica qual protocolo estará submetido as configuração do proxy, deixemos http;
  • username: nome de usuário da rede, caso o proxy exija autenticação de usuário, do contrário a tag pode ser removida;
  • password: senha para autenticação junto ao proxy, se requerida, do contrário remova a tag;
  • host: informe o nome do host ou ip do servidor de proxy;
  • port: porta que o proxy utiliza;
  • nonProxyHosts: endereços que nao requeiram a passagem pelo proxy, geralmente: localhost
Realizadas as configurações descritas, salve o arquivo e seu proxy deverá estar devidamente configurado junto ao maven.

Maven: Primeiro Projeto

No post anterior abordei a configuração do Maven junto ao sistema operacional, declarando-se a variável de ambiente M2_HOME.

Demonstrarei o uso do Maven para a criação de um projeto simples, JSE, a fim de demonstrar a estrutura que o Maven adota como padrão bem como seu build.

Para a criação do projeto, basta acessar o prompt de comando. Assumiremos o diretório padrão como sendo c:\projetos-maven.


A partir da seguinte linha de comando, é possível  a criação do projeto, acesse pelo prompt o diretório acima discriminado ou aquele de sua preferência:

mvn archetype:generate -DgroupId=br.com.serjava.projetomaven -DartifactId=projeto-
maven -DarchetypeArtifactId=maven-archetype-quickstart 

Nesta linha informamos a estrutura de pacotes base do projeto, pelo atributo: -DgroupId=br.com.serjava.projetomaven, como pode-se observar, será criada a estrutura 
de pacotes br.com.serjava.projetomaven; -DartifactId define o nome do projeto a ser criado; 
-DarchetypeArtifactId contém o parâmetro com a estrutura do projeto a ser criado, neste caso, 
é um projeto quickstart, ou seja, um projeto simples sem inclusões de frameworks ou qualquer recurso 
adicional.

Você perceberá que depois de digitado o comando, vários downloads serão feitos do repositório central do 
maven. O maven, automaticamente, cria um repositório local em sua máquina, e a cada construção e 
criação de um novo projeto, ele verifica se as dependências necessárias para este projeto estão contidas 
em seu repositório local, caso não se encontrem, automaticamente será feito o download das mesmas. 
Ressalta-se que para uma segunda utilização, não mais será necessário o download.

Em um ambiente de desenvolvimento multi-usuários, a criação de repositórios locais é muito útil, pois 
evita-se a busca por dependências por cada membro da equipe.

Depois de realizados os downloads, você será questionado sobre a versão de seu projeto, conforme
imagem abaixo:
Informaremos a versão: 1.0
Em seguida, será mostrado os dados informados para a criação do projeto, confirme digitando Y;

O sucesso da criação deverá ser confirmado pela mensagem: BUILD SUCESS.

Dentro da diretório que utilizamos para a criação do projeto, deverá constar o projeto. 
Observe que dentro do projeto há um diretório src e um arquivo pom.xml.

O arquivo pom.xml pode ser entendido como um descritor de um projeto maven. nele podemos adicionar 
dependências ao projeto, plugins e configurações específicas, a estrutura deste arquivo no projeto criado 
deverá ser a seguinte:


  4.0.0

  br.com.serjava.projetomaven
  projeto-maven
  1.0
  jar

  projeto-maven
  http://maven.apache.org

  
    UTF-8
  

  
    
      junit
      junit
      3.8.1
      test
    
  


CONSTRUINDO O PROJETO

Uma vez criado o projeto, para que possamos fazer seu build basta acessar o diretório do projeto, no
nosso caso: C:\Projetos-Maven\projeto-maven; feito isto, digite o seguinte comando:
mvn package
Ao executar o comando package o Maven está executando uma fase (para maiores detalhes consul-
te o material de referência do Maven), em suma, o Maven tem um ciclo de fases (Life cycle), qualquer uma
que seja solicitada, todas as anteriores serão executadas até aquela que foi indicada. Estas são as fases per-
corridas:
1.  validate
2.  generate-sources
3.  process-sources
4.  generate-resources
5.  process-resources
6.  compile
Para a execução do comando package, todas as fases foram executadas, garantindo assim que ne-
nhum erro possa comprometer o projeto. Tendo-se todas as fases “aprovadas”, o projeto foi construído e
poderá ser executado.

Finalmente, para rodar o projeto, digite:
java –cp target\projeto-maven-1.0.jar br.com.serjava.projetomaven.App 

O resultado deverá ser:
Espero que tenham gostado, em breve mais posts sobre a utilização do Maven. Este foi uma pequena amosta do que este poderoso gerenciador é capaz de fazer, logo demonstrarei o uso de plugins para deploy da aplicação quando se usar um projeto web, além de prover independência de ides!

sábado, outubro 15, 2011

Instalação do Maven

O Maven surgiu como uma ferramenta para acumular conhecimento utilizado no projeto Jakarta da Apache para auxiliar no build da aplicação.
                O Maven tem como objetivo:
  • Facilitar o build de aplicações; 
  • Prover um sistema de build uniforme; 
  • Fornecer informações sobre o projeto; 
  • Criação de diretrizes para o emprego de melhores práticas; 
  • Migração transparente para novas funcionalidades.
DOWNLOAD
O primeiro passo é fazer o download do Maven, este é um projeto livre da Fundação Apache. O download pode ser feito acessando a seguinte url: http://maven.apache.org/download.html

Feito o download, descompacte o conteúdo num diretório de sua preferência; este tutorial assumirá que o diretório do Maven será c:\mvn.

Para o funcionamento do Maven, é necessário que o ambiente Java (jdk) esteja configurado, bem como a variável de ambiente JAVA_HOME. 

Variável de ambiente: M2_HOME
Considerando-se que o Maven já tenha sido descompactado, conforme indicado no item 1.1, deveremos configurar sua variável de ambiente. Assumimos que o diretório do Maven é: C:\mvn\apache-maven-3.0.

Veja a sequência de imagens para a declaração da variável de ambiente:


Na categoria Variáveis de Sistema (System variables), clique no botão New (Novo) e, preencha conforme imagem abaixo:
Neste momento a variável de ambiente M2_HOME está sendo criada, e apontando para o diretório que o Maven foi descompactado.

Localize a variável PATH, clique sobre ela e, em seguida em Editar; depois do último caractere insira um ponto e virgula (;), e em seguida, adicione: %M2_HOME%\bin. Confirme.

Pronto! O Maven já deverá ter sido configurado, para testar, abra o prompt do Windows e digite: mvn –version, o resultado deverá ser similar a:


O maven já esta pronto para ser usado em seus projetos de agora em diante. Novos posts tratarão de sua utilização, verifique!



Teste Postagem

Postagem de setup do blog


private String valor;


public String getShowContent() {
    String viewId = FacesContext.getCurrentInstance().getViewRoot().getViewId();
    if ("/pages/login.xhtml".equals(viewId)
     || ("/pages/showSource.xhtml").equals(viewId)
     || ("/pages/places.xhtml".equals(viewId) && 
       places != null && places.size() > 0)) {
      return "display";
    }
    
    else return "none";
  }