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.