Edson Gonçalves

O que estou fazendo no momento

Edson Gonçalves — Fri, 23 Sep 2011 00:46:49 +0000

Olá Pessoal, tudo bom? Como vão vocês?

Sei que estou sumido do blog. Muitos leitores estão, nestes meses, me mandando comentários pedindo a continuação de alguns artigos, de séries, que comecei e ainda não terminei. Quero informar a todos que, neste momento, estou renovando meus livros, por isso parei um pouco de postar no blog.

Muitas pessoas já sabem, outras nem fazem muita ideia, mas escrever toma muito tempo. Quem possui pouco tempo livre, como eu, no caso, é deixar os finais de semana com a família e o descanso das noites, para nos dedicar a escrita.

Os escritores que sempre apoio em meu blog, até mesmo outros que desejarem aparecer no mural, só entrar em contato comigo. Sei o quanto é difícil divulgar um livro e ter um pouco de reconhecimento. Muita gente acha que ganhamos dinheiro com livros, que ficamos ricos, mas estou aqui para desmentir. Na área de informática, quem escreve é para ter o prazer de ajudar aqueles que estão com as mesmas dificuldades que, com certeza, passamos um dia.

Quero deixar aqui os meus sinceros agradecimentos a todos aqueles que postam comentários elogiando, criticando e pedindo mais tutoriais no blog. Para aqueles que não liberei os comentários, fiquem tranquilos que eu os li. Só não os liberei, muitas vezes, porque não tive tempo ou, por serem pedidos e perguntas relacionadas diretamente a mim, sobre o assunto, não me permiti o tempo necessário para responde-los.

Assim que terminar o meu primeiro objetivo, que é a completa reformulação e atualização, do livro “Desenvolvendo Aplicações Web com JSP, SERVLETS, JAVASERVER FACES, HIBERNATE, EJB 3 PERSISTENCE E AJAX”, voltarei a postar os diversos tutoriais, que já os tenho quase prontos, no blog.

Deixo aqui o espaço aberto, neste tópico, para que comentem o que acham interessante de estar neste livro que estou trabalhando. Já garanto que muitas criticas e pedidos, vindos de algumas centenas de leitores, não serão ignorados. Professores de universidades, faculdades e escolas técnicas do Brasil e alguns países de língua portuguesa, que também me procuraram para deixar seus pedidos e criticas, quero manter meu compromisso de que todos serão levados em consideração.

Agradeço a compreensão de todos.

Bons códigos!

Novo Livro do Camilo Lopes

Edson Gonçalves — Fri, 05 Aug 2011 05:01:46 +0000

Pessoal,

Sei que estou sumido do meu blog e prometo que estou preparando surpresas. Mas isto não significa que eu deixaria de prestigiar o lançamento do novo livro do Camilo Lopes.

Sem mais delongas, vejam o que ele fala a respeito em seu blog:

http://blog.camilolopes.com.br/livrojeeframeworks/

Gerando relatórios JasperReports na Web com Fontes embebidas

Edson Gonçalves — Fri, 28 Jan 2011 07:43:00 +0000

Olá Pessoal, tudo bom? Como vão vocês?

Em 2011 quero começar com um artigo ensinando uma dúvida muito frequente aos usuários de hospedagem da Integrator Host: embeber as fontes desktop no relatório JasperReports para serem usadas no aplicativo Web.

No geral, relatórios são criados no desktop, onde usamos uma ferramenta visual, arrastando, modificando e, claro, gerando uma aparência agradável. Se a aparência então for feita por um Designer, este pouco se importa onde vai ser gerado tal relatório, o importante é o VISUAL. É neste momento que começa o problema.

Um relatório pode usar fontes desktop que não estão disponíveis no servidor online. Pior, se o seu aplicativo roda em um servidor compartilhado, raramente uma empresa de hospedagem vai ficar instalando suas fontes desktop na máquina servidora, toda vez que você estiver com um relatório “enfeitadinho”. Se instalar, também não será na hora. O que fazer neste caso então? Como obter independência?

Pensando nesta questão, a equipe de desenvolvimento do JasperReports incluiu a capacidade de adicionar as fontes desktop em seu aplicativo, para que estejam disponíveis quando aquele seu belo relatório for gerado para o cliente.

O que veremos neste artigo é como executar tal tarefa, partindo de um relatório já gerado no iReport.

Para acompanhar este artigo

Criei um banco de dados simples, com uma tabela chamada produtos, contendo os campos selecionados como mostra a Figura 1.

Figura 1 – A tabela usada

O relatório foi criado usando o assistente do iReport 4, onde o resultado final, após minhas pequenas alterações, é o que mostra a Figura 2.

Figura 2 – Relatório gerado pelo assistente com pequenas modificações

Tenham em mente que este artigo não vai ensiná-los a criar relatórios e sim como contornar um problema comum entre os desenvolvedores Java. Caso queiram dominar a arte de desenvolver relatórios JasperReports com o iReport, vejam a minha seção de livros clicando aqui.

Trabalhando com fontes personalizadas no relatório

Após desenhar o relatório, chega o momento de finalizar a “arte” com alguns toques e, em meio as mudanças, eis que surge a ideia de personalizar a fonte também do texto contido no relatório.

No exemplo que fiz, os textos fixos foram todos personalizados com uma fonte que possuo em minha máquina, chamada Impact.

Figura 3 – A fonte escolhida para o texto estático Produtos do relatório

Embora esta fonte seja importante para o design do meu relatório, não tenho garantias que ela exista no servidor onde hospedo meus aplicativos. Logo, o que parece simples, pode se tornar um pesadelo se não for eu o responsável pela administração do sistema operacional.

Adicionando a fonte ao aplicativo

Graças ao problema de ausência de fontes em servidores de hospedagem, muitos desenvolvedores não podiam depender da empresa ou administrador que fornece a máquina onde disponibilizam se encontram aplicativos, principalmente quando se trata de uma hospedagem compartilhada. É nisto que o JasperReports inclui a possibilidade de ter todas as fontes que usou em seu relatório em produção.

Adicionando e exportando a fonte no iReport

Vá no menu Tools >Options (menu iReport>Preferences no Mac OS X) e, na janela Options, em iReport, selecionem a aba Fonts.

Através do botão Install Font selecionamos as fontes que desejamos importar no iReport. Depois de importadas, podemos selecionar todas elas e exportá-las através do botão Export as extension.

Figura 4 – A fonte escolhida e usada no relatório pronta para ser exportada

No exemplo que explico, chamei o arquivo que exportei de font.jar. É justamente este arquivo que vou adicionar em meu projeto.

A fonte como uma biblioteca no seu aplicativo Web pelo Eclipse IDE

No Eclipse, basta clicar com o direito do mouse sobre o projeto, selecionar o item Properties. Na caixa de diálogo Properties, vamos em Java Build Path, na aba Libraries. Para adicionarmos a biblioteca font.jar, vamos no botão Add External JARs.

Figura 5 – O JAR font.jar adicionado nas bibliotecas do meu projeto

Claro que eu não poderia deixar de comentar uma particularidade do Eclipse IDE na versão Helios. Para projetos Java EE. Nesta versão, temos um item de nome diferente para adicionarmos as bibliotecas do projeto no aplicativo Web. Este item está na janela Properties, em Deployment Assembly. É neste local que determinamos quais bibliotecas serão exportadas ao executarmos o servidor Java.

Figura 6 – Adicionando os arquivos JARs do projeto no aplicativo Web

Ao clicarmos no botão Add, a caixa de diálogo New Assembly Directive surge. Esta caixa de diálogo é a responsável por selecionarmos as bibliotecas do projeto em Java Build Path Entries.

Figura 7 – Obtendo os arquivos JARs de Java Build Path

Ao clicarmos em Next, veremos todas as bibliotecas que dispomos em Java Build Path. Selecionem todas – as bibliotecas para executar o relatório JasperReports devem estar presentes – finalizando no botão Finish.

Figura 8 – Arquivos JARs selecionados

Retornando ao diálogo Properties, no item Deployment Assembly, temos todas as bibliotecas que serão adicionadas ao diretório lib do projeto, incluindo font.jar.

Figura 9 – As bibliotecas que serão exportadas para o diretório /lib do projeto Web

A fonte como uma biblioteca no seu aplicativo Web pelo NetBeans IDE

No NetBeans IDE, basta adicionar em Libraries, clicando com o direito do mouse e selecionando, no menu de contexto, o item Add JAR / Folder.

Figura 10 – As bibliotecas que serão exportadas para o diretório /lib do projeto Web

Antes e depois da fonte adicionada ao projeto

Para satisfazer a curiosidade do que será visto, temos a Figura 11 que mostra um relatório gerado, em formato PDF, sem a fonte no diretório lib do projeto. Note a diferença com a Figura 12 em relação ao formato da fonte, principalmente do título “Produtos”.

Figura 11 – Arquivo PDF gerado como relatório sem a fonte no diretório lib do projeto

Figura 12 – Arquivo PDF gerado como relatório com a fonte no diretório lib do projeto

O projeto para download

Clique aqui para baixar o projeto e alterá-lo como desejar.

Spring MVC 3 na Prática com Bean Validation

Edson Gonçalves — Sun, 24 Oct 2010 22:56:13 +0000

Olá Pessoal, tudo bom? Como vão vocês?

Este é o terceiro artigo da série Spring MVC 3.0. Se vocês não tiveram um contato inicial com o framework, recomendo ver este artigo primeiro.

Para acompanhar esta terceira parte, recomendo ter criado o projeto do segundo artigo.

Como sempre, dúvidas e críticas são bem vindas.

Alterando o CRUD criado com o Spring MVC

O projeto neste artigo é o mesmo do segundo artigo da série. Entretanto, faremos algumas alterações para que passe a utilizar validações do Bean Validation.

Adicionando as bibliotecas ao projeto utilizando o Maven

Mais uma vez, recorreremos ao Maven para adicionar as bibliotecas que necessitamos. Neste caso, teremos que baixar o Hibernate Validator. Para utilizar o Bean Validation, utilizaremos dois JARs: hibernate-validator-4.0.2.GA.jar e validation-api-1.0.0.GA.jar.

Abram o arquivo pom.xml , encontrado na view Package Explorer para que possamos adicionar as configurações que necessitamos.

Criando a propriedade

Na aba Overview, em Properties, cliquem no botão Create. Na caixa de diálogo Add property, preencham como na Figura 1.

Figura 1 - Criação da property da versão do hibernate validator

Criando a dependência

Com a propriedade definida para informar qual versão desejamos utilizar, no qual o Maven deverá baixar, resta configurar as dependências.

Na aba Dependencies, cliquem no botão Create e preencham conforme a Figura 2 ilustra.

Figura 2 - A dependência do Hibernate Validator

Alterando a entidade Contato

A entidade do artigo, chamada de Contato, será a primeira coisa que iremos modificar no projeto.

Graças a JSR 303, chamada de Bean Validation, podemos anotar as entidades com validações. Com as anotações de Bean Validation na entidade, concentramos a validação em um único local, de forma padronizada, tornando possível portar estas validações para as classes controladoras do Spring MVC.

A Listagem 1 exibe a entidade Contato modificada. Note as anotações de validação onde colocamos as mensagens de erro embutidas. Mais adiante iremos capturá-las para exibir o problema ao usuário.

Listagem 1. A entidade Contato com anotações Bean Validation.

package br.com.integrator;

import javax.persistence.*;
import javax.validation.constraints.*;

@Entity
@Table(name = "contato")
public class Contato {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "id")
	private Long id;
	@NotNull
	@Size(min=5, message="O nome não pode ter menos que 5 caracteres!")
	private String nome;
	@NotNull
	@Pattern(regexp = "^[\\w\\-]+(\\.[\\w\\-]+)*@([A-Za-z0-9-]+\\.)+[A-Za-z]{2,4}$", message="E-mail com formato incorreto.")
	private String email;
	@Pattern(regexp = "\\(?\\b([0-9]{2})\\)?[-. ]?([0-9]{4})[-. ]?([0-9]{4})\\b", message="Telefone em formato incorreto")
	private String telefone; 

     //getters e setters
 }

A infra-estrutura definida pela JSR 303 nos permite descrever as restrições, usando anotações no modelo de classes de persistência, como definir se um campo aceitará uma quantidade mínima de caracteres ou se não aceitará nulo, por exemplo.

Cada anotação é associada a uma validação, verificando se a instância da entidade anotada obedece à regra ou não.

A Tabela 1 apresenta todas as anotações possíveis de serem usadas e suas funcionalidades.

Annotation	O que faz?
@AssertFalse	Checa se a propriedade anotada é falsa.
@AssertTrue	Checa se a propriedade anotada é verdadeira.
@DecimalMax(value=)	A propriedade anotada precisa ser um número, cujo valor deve estar menor ou igual ao valor máximo previsto. O parâmetro value é a representação em string do valor máximo aceito de acordo com o formato representado em BigDecimal. Suporta tipos como BigDecimal, BigInteger, String, byte, short, int, long e os respectivos wrappers de tipos primitivos.
@DecimalMin(value=)	A propriedade anotada precisa ser um número, cujo valor deve estar maior ou igual ao valor mínimo previsto. O parâmetro value é a representação em string do valor mínimo de acordo com a representação de sequência de BigDecimal. Suporta tipos como BigDecimal, BigInteger, String, byte, short, int, long e os respectivos wrappers de tipos primitivos.
@Digits(integer=, fraction=)	Verifica se a propriedade possui a quantidade de dígitos antes e depois do separador de casa decimal. Por exemplo: @Digits(integer=9, fraction=2) significa que espera-se 9 dígitos inteiros e 2 dígitos fracionários. Suporta os tipos: BigDecimal, BigInteger, String, byte, short, int, long e os respectivos wrappers de tipos primitivos.
@Future	Checa se a data está no futuro. Suporta os tipos java.util.Date e java.util.Calendar.
@Max(value=)	Verifica se o valor é menor ou igual ao valor anotado. Suporta os tipos: BigDecimal, BigInteger, String, byte, short, int, long e os respectivos wrappers de tipos primitivos.
@Min(value=)	Verifica se o valor é maior ou igual ao valor anotado. Suporta os tipos: BigDecimal, BigInteger, String, byte, short, int, long e os respectivos wrappers de tipos primitivos.
@NotNull	Checa se o valor anotado não é nulo (null). Uma String cujo valor seja vazio (“”) vai passar.
@Null	Checa se o valor anotado é nulo (null).
@Past	Checa se uma data está no passado. Suporta os tipos java.util.Date e java.util.Calendar.
@Pattern(regex=, flag=)	Checa se a propriedade obedece à expressão regular.
@Size(min=, max=)	Confere se a quantidade de elementos está entre o mínimo e o máximo, suportando tipos como: Strings, Collections, Maps e arrays.
@Valid	Impõe uma validação recursiva aos objetos associados. Digamos que, no bean Post, houvesse a anotação @Valid no atributo comments. Já na classe Comment, temos um atributo de validação anotado. Se um valor transmitido a comments, de Post, não estiver de acordo com a validação existente na classe Comment, de acordo com o atributo anotado, um erro será gerado em tempo de execução. A notação @Valid está sendo usada no PostController para validar os erros existentes em Post ou Comment.

Tabela 1. Anotações e regras para criar restrições (Constraints).

Alterando o controlador

Alteraremos a classe ContatoController, criada no pacote br.com.integrator.web, de acordo com o mostrado na Listagem 2.

Listagem 2. A classe ContatoController alterada.

package br.com.integrator.web;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import br.com.integrator.dao.ContatoDAO;
import br.com.integrator.Contato;

@Controller
@RequestMapping("/contato/**")
public class ContatoController {
@Autowired
private ContatoDAO contatoDao;

@RequestMapping(value = "/contato/{id}", method = RequestMethod.GET)
public String show(@PathVariable("id") Long id, ModelMap modelMap) {
modelMap.addAttribute("contato", contatoDao.find(id));
return "contato/show";
}

@RequestMapping(value = "/contato", method = RequestMethod.GET)
public String list(ModelMap modelMap) {
modelMap.addAttribute("contatos", contatoDao.findAll());
return "contato/list";
}

@RequestMapping(value = "/contato/{id}", method = RequestMethod.DELETE)
public String delete(@PathVariable("id") Long id) {
contatoDao.remove(contatoDao.find(id));
return "redirect:/contato";
}

@RequestMapping(value = "/contato/form", method = RequestMethod.GET)
public String form(ModelMap modelMap) {
modelMap.addAttribute("contato", new Contato());
return "contato/create";
}

@RequestMapping(value = "/contato", method = RequestMethod.POST)
public String create(@Valid Contato contato, BindingResult result) {
if (result.hasErrors())
return "contato/create";

contatoDao.persist(contato);
return "redirect:/contato";
}

@RequestMapping(value = "/contato/{id}/form", method = RequestMethod.GET)
public String updateForm(@PathVariable("id") Long id, ModelMap modelMap) {
modelMap.addAttribute("contato", contatoDao.find(id));
return "contato/update";
}

@RequestMapping(method = RequestMethod.PUT)
public String update(@Valid Contato contato, BindingResult result) {
if (result.hasErrors())
return "contato/update";

contatoDao.merge(contato);
return "redirect:/contato";
}

}

Como visto na Listagem 1, as anotações @Size e @Pattern possuem o atributo message, que capturamos pelo Spring MVC na classe ContatoController (Listagem 2) - através da classe javax.validation.Valid (anotação @Valid). Assim como a anotação @Controller, as anotações pertencentes a Bean Validation são obtidas graças a adição do elemento . Isto permite que as informações anotadas sejam injetadas onde a validação é necessária na sua aplicação.Caso haja um erro, o método hasErrors(), de org.springframework.validation.BindingResult, retorna true, nos possibilitando conduzir a navegação da página, com seus respectivos erros, inclusive paralisando a ação ao qual se encontra. A utilização de hasErrors() ocorre em ContatoController, nos métodos create() e update() com o seguinte if:

if (result.hasErrors())

//executa uma ação para conduzir a página com os erros ao usuário

As informações recebidas da validação pela classe Controller são transmitidas para o formulário e capturadas. Veja como isto ocorre na descrição da Listagem 3.

Alterando as views

Temos três páginas que representam nosso CRUD feitas. Estas páginas foram criadas dentro do diretório chamado WEB-INF/jsp/contato(fisicamente na ferramenta: src/main/webapp/WEB-INF/jsp/contato). Teremos que alterá-las para permitir que os erros sejam exibidos.

O formulário de cadastro

Abra o arquivo create.jsp e altere como na Listagem 3, adicionando as tags .

Listagem 3. A página create.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>





 
Cadastrar



 

 
 <%@ include file="/menu.jsp" %>
 
 
 
 
 
 
 Nome:
 

 

 
 

 
 Email:
 

 

 
 

 
 Telefone:

A tag foi utilizada na Listagem 3 com dois parâmetros: path e cssClass. No parâmetro path transmitimos o atributo da classe Contato, validada pelas anotações de Bean Validation, onde receberá a mensagem.

Figura 3 – Processo de validação partindo da anotação no JavaBean Contato

Podemos ter uma idéia de como ficará a página create.jsp depois das alterações visualizando a Figura 4.

Figura 4 – Validação transmitida para a página de JSP

Alterando a página de atualização de dados

Como feito na página create.jsp, a página update.jsp também receberá as tags . A Listagem 4 exibe a página com as mudanças, na íntegra.

Listagem 4. A página update.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>





 
Atualizar


 
 
 <%@ include file="/menu.jsp" %>
 
 
 
 
 
 
 Nome:
 

 
 
 

 
 Email:
 

 
 
 

 
 Telefone:

O projeto para download

Clique aqui para baixar o projeto e alterá-lo como desejar.

Considerações finais

Com as validações, boa parte dos problemas iniciais de um desenvolvimento usando o Spring MVC foram resolvidos. Mas vejam só: é o começo. Caso haja interesse do leitor em aprender um exemplo mais complexo, a revista JavaMagazine #78 publicou, um artigo meu com o Spring MVC 3 na criação de um blog, do começo ao fim. É um bom início para se desenvolver um projeto mais completo e complexo.
Para os que acompanham o blog, o assunto Spring MVC não para por aqui. Veremos em breve um site completo, feito com o framework, unindo várias características do Spring, de seu framework MVC e a parte de segurança com Spring Security.

Spring MVC 3 na Prática com JPA 2

Edson Gonçalves — Mon, 16 Aug 2010 03:49:28 +0000

Olá Pessoal, tudo bom? Como vão vocês?

Este é o segundo artigo da série Spring MVC 3.0. Desta vez iremos trabalhar com a JPA em conjunto com o framework Spring MVC. Se vocês não tiveram um contato inicial com o framework, recomendo ver este artigo primeiro.

Como sempre, dúvidas e críticas são bem vindas.

O Servidor Java

Para este artigo, vamos utilizar o Tomcat 7.0, ainda em beta. Para baixar o binário do Tomcat 7, vá até o endereço http://tomcat.apache.org/.

A versão que vamos baixar é a compactada. Por exemplo, se o seu Windows for de uma versão 64bits, baixe o arquivo apache-tomcat-7.0.0-windows-x64.zip.

Atenção: O Tomcat 7.0 roda somente na JDK 6 ou superior.

O banco de dados

O banco de dados utilizado será o MySQL. Você pode baixar a versão 5.1, utilizada no artigo, aqui.

Preparando o banco de dados do exemplo

Abra o terminal do MySQL com seu usuário e senha ROOT (aquela que você configurou na instalação).

Crie o banco de dados executando o seguinte comando:

create database springmvc;

O ambiente de trabalho

A própria empresa responsável pelo Spring Source, divisão da VMware, possui uma ferramenta completa, criada sobre a plataforma Eclipse, chamada de SpringSource Tools Suite.

Para baixar o SpringSource Tools Suite, clique aqui, preencha o formulário e faça o Download. Como a ferramenta possui uma opção de instalador, usem-na como facilitador se desejar. Na própria página onde baixar o arquivo, haverá a explicação da instalação em cada plataforma, em Installation Instructions.

Criando o projeto

Na view Package Explorer, com o direito do mouse, selecionem New>Spring Template Project no menu de contexto.

Figura 1 – Iniciando a criação de um projeto modelo utilizando Spring MVC

Na caixa de diálogo New Template Project, selecione Spring MVC Project e clique no botão Next.

Figura 2 – Opção Spring MVC Project

Ao aparecer a caixa de diálogo Import, cliquem no botão Yes para permitir que o projeto faça o download das bibliotecas do Spring MVC. No segundo projeto que criar, não haverá necessidade deste download. Falaremos mais adiante sobre este download e como ele ocorre.

Figura 3 – Confirmação para o download das bibliotecas do projeto

Após o download das bibliotecas, prosseguiremos na criação do projeto. Coloque o nome do seu projeto em Project name e o pacote principal abaixo. Confirmem no botão Finish.

Figura 4 – Definição do nome do projeto e pacote principal

O assistente criará, em sua conclusão, um projeto com uma estrutura básica, contendo uma classe, página e arquivos de configurações do framework Spring MVC, como mostra na Figura 5.

Figura 5 – Estrutura inicial do projeto gerado

Alterando o projeto base gerado pelo assistente

Além dos arquivos contidos para a execução do projeto, temos o pom.xml, o que denota que o projeto é gerado sobre a estrutura do Maven.

Na view Package Explorer, se expandirmos Maven Dependencies, veremos as bibliotecas que o projeto necessita para ser executado. Neste momento, o projeto está funcionando tal como foi gerado pelo assistente.

Figura 6 – Página inicial gerada pelo assistente utilizando o framework Spring MVC

Para compreendermos o que foi gerado, vejam o primeiro artigo que escrevi sobre o Spring MVC, ao qual explico a base do framework.

Entretanto, não vamos utilizar alguns dos arquivos criados. Selecione os seguintes diretórios e arquivos do projeto e os remova:

WelcomeController.java
WelcomeControllerTests.java
spring/
views/
urlrewrite.xml

Adicionando outras bibliotecas ao projeto utilizando o Maven

Embora boa parte das bibliotecas que precisamos no projeto já estejam disponíveis, precisamos adicionar a biblioteca JDBC do MySQL e as do Hibernate para trabalharmos com a JPA 2.

Abram o arquivo pom.xml , encontrado na view Package Explorer. No canto superior do lado direito, temos o ícone Show Advanced Tabs. Vamos exibir, ao clicar neste ícone, novas tabs que permitirão configurar novos repositórios.

Figura 7 – Exibindo tabs avançadas do editor visual para o arquivo pom.xml

Adicionando um repositório

Na aba Repositories, cliquem no botão Create. Preencham com JBoss Repo em Id e http://repository.jboss.com/maven2. Este repositório será necessário para obtermos a última versão do Hibernate, importante para nosso projeto.

Figura 8 – O repositório JBoss configurado

Criando propriedades

Caso o leitor não conheça o Maven ainda, já deve ter desconfiado que informamos um endereço para baixarmos as bibliotecas. Entretanto, quais desejamos?

Na aba Overview, em Properties, cliquem no botão Create. Na caixa de diálogo Add property, preencham como na Figura 9.

Figura 9 – Criação da property da versão do Hibernate

Adicione outra property preenchendo o diálogo como na Figura 10.

Figura 10 – Criação da property da versão da JPA

Por fim, adicionem mais uma property e preencham como a Figura 11.

Figura 11 – Criação da property da versão da biblioteca JDBC do MySQL

Criando as dependências

As propriedades foram definidas para informar qual versão desejamos utilizar das bibliotecas que o Maven deverá baixar. Entretanto, precisamos configurar as dependências.

Na aba Dependencies, cliquem no botão Create e preencham conforme a Figura 12 ilustra.

Figura 12 – A dependência do Hibernate

Criem uma nova dependência e configurem conforme a Figura 13 demonstra.

Figura 13 - A dependência da API JPA 2.0

Façam o mesmo processo preenchendo conforme a Figura 14 exibe.

Figura 14 – A dependência da biblioteca JDBC do MySQL

E para a parte de transações do Spring, configure a dependência conforme a Figura 15.

Figura 15 – A dependência da biblioteca para transações do Spring Framework

Para trabalhar com banco de dados no Spring, configure a dependência conforme a Figura 16.

Figura 16 – A dependência da biblioteca jdbc do Spring Framework

Como estamos trabalhando com a JPA, o Spring precisa da dependência que configuramos no Maven conforme a Figura 17.

Figura 17 – A dependência da biblioteca orm do Spring Framework

Ao salvar o arquivo, automaticamente o Maven entrará em ação trazendo as bibliotecas faltantes para o seu projeto. Vemos isto na view Console.

Nota: Detalhes de como o Maven funciona não serão mostrados neste artigo. É importante lembramos que o objetivo deste artigo não é ensinar a trabalhar com Maven, seja através do arquivo pom.xml ou pelo Eclipse IDE.

Um CRUD com Spring MVC utilizando JPA 2.0

O projeto neste artigo será baseado em apenas uma entidade, suficiente mostrar a vocês a integração entre as duas tecnologias no desenvolvimento.

Iremos agora modificar o projeto criado automaticamente pelo assistente.

A entidade Contato

Teremos para o exemplo apenas uma entidade, chamada de Contato. Esta entidade, trabalhará com uma tabela contato, no qual possui quatro atributos, sendo o atributo id o único que será gerado automaticamente. A Listagem 1 exibe a entidade que será usada no exemplo.

Listagem 1. A entidade Contato.

package br.com.integrator;

import javax.persistence.*;

@Entity

@Table(name = "contato")

public class Contato {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name = "id")

private Long id;

private String nome;

private String email;

private String telefone;

//getters and setters

}

Para fazê-la, cliquem com o direito do mouse sobre o pacote br.com.integrator e selecionem, no menu de contexto, o item New>Class.

Figura 18 – Criação da classe Contato

Acessando os dados

O acesso aos dados é feito pelo padrão DAO (Listagem 2), com a adição de anotações do Spring Framework. No princípio, adicionamos a anotação @Repository(“contatoDao”), ao qual indica ao Spring Framework que se trata de um DAO. Veremos mais a respeito adiante, na configuração final do Spring.

Utilizamos a anotação @Transactional, para fazer o controle transacional e a anotação @PersistenceContext, permitindo assim com que o Spring injete um EntityManager no serviço quando instanciado. Esta anotação pode ser colocada no atributo ou método setter. Com a esta injeção, temos um comportamento similar ao oferecido pelo EJB 3, incluindo transações, só que sem a necessidade de um contêiner EJB para isso.

Para criar a classe da Listagem 2, criem uma nova classe e coloquem o pacote br.com.integrator.dao e preencham o nome da classe como ContatoDAO.

Figura 19 – Criação da classe ContatoDAO

Listagem 2. A classe ContatoDAO.

package br.com.integrator.dao;

import java.util.List;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

import br.com.integrator.Contato;

@Repository("contatoDao")

public class ContatoDAO{

protected EntityManager entityManager;

public ContatoDAO() {

}

@PersistenceContext

public void setEntityManager(EntityManager entityManager) {

this.entityManager = entityManager;

}

public Contato find(Long id) {

return entityManager.find(Contato.class, id);

}

@Transactional

public void persist(Contato contato) {

entityManager.persist(contato);

}

@Transactional

public void merge(Contato contato) {

entityManager.merge(contato);

}

@Transactional

public void remove(Contato contato) {

entityManager.remove(contato);

}

@SuppressWarnings("unchecked")

public List findAll() {

return entityManager.createQuery("SELECT c FROM Contato c").getResultList();

}

}

Controlando como o aplicativo funciona

A classe ContatoController, que será criada no pacote br.com.integrator.web, exibida na Listagem 3, lida com as requisições do cliente, controlando o rumo que será dado na chamada a uma determinada view.

Listagem 3. A classe ContatoController.

package br.com.integrator.web;

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

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.*;

import br.com.integrator.dao.ContatoDAO;

import br.com.integrator.Contato;

@Controller

@RequestMapping("/contato/**")

public class ContatoController {

@Autowired

private ContatoDAO contatoDao;

@RequestMapping(value = "/contato/{id}", method = RequestMethod.GET)

public String show(@PathVariable("id") Long id, ModelMap modelMap) {

modelMap.addAttribute("contato", contatoDao.find(id));

return "contato/show";

}

@RequestMapping(value = "/contato", method = RequestMethod.GET)

public String list(ModelMap modelMap) {

modelMap.addAttribute("contatos", contatoDao.findAll());

return "contato/list";

}

@RequestMapping(value = "/contato/{id}", method = RequestMethod.DELETE)

public String delete(@PathVariable("id") Long id) {

contatoDao.remove(contatoDao.find(id));

return "redirect:/contato";

}

@RequestMapping(value = "/contato/form", method = RequestMethod.GET)

public String form(ModelMap modelMap) {

modelMap.addAttribute("contato", new Contato());

return "contato/create";

}

@RequestMapping(value = "/contato", method = RequestMethod.POST)

public String create(@ModelAttribute("contato") Contato contato) {

contatoDao.persist(contato);

return "redirect:/contato";

}

@RequestMapping(value = "/contato/{id}/form", method = RequestMethod.GET)

public String updateForm(@PathVariable("id") Long id, ModelMap modelMap) {

modelMap.addAttribute("contato", contatoDao.find(id));

return "contato/update";

}

@RequestMapping(method = RequestMethod.PUT)

public String update(@ModelAttribute("contato") Contato contato) {

contatoDao.merge(contato);

return "redirect:/contato";

}

}

Introduzida na versão do Spring MVC 2.5, podemos declarar uma classe como sendo a controller do framework simplesmente utilizando a anotação @Controller, de org.springframework.stereotype.Controller. Esta anotação permite que o Spring faça seu “scan” automaticamente através do elemento .

Com a anotação @RequestMapping, encontrada após @Controller, definimos o caminho HTTP que será utilizado na aplicação, sendo mapeada pela classe. Na prática, todas as chamadas na aplicação contendo o “/contato/*” serão analisadas pela classe controller.

O suporte a RESTful foi completamente adicionado no Spring MVC 3, onde determinamos o seu comportamento através também da anotação @ResquestMapping. Agora, o servlet Spring Dispatcher suporta os seguintes métodos HTTP: GET, HEAD, POST, PUT e DELETE.

Para efeitos comparativos, se colocarmos cada um dos métodos HTTP ao lado de um simples aplicativo que executa as quatro operações básicas (CRUD), teríamos o GET como sendo o READ, o POST como CREATE, o PUT como UPDATE e o DELETE como por ele mesmo.

Infelizmente, os navegadores não compreendem nada além de GET e POST em formulários HTML. Ao declarar no formulário do Spring MVC que o método de submissão é o DELETE, por exemplo, este se transformará em um método POST, para que o navegador entenda, só que contendo um campo oculto com o valor DELETE. Infelizmente este feito não é mágico e no Spring MVC esta característica só é possível porque configuramos o filtro org.springframework.web.filter.HiddenHttpMethodFilter no arquivo web.xml(veja a Listagem 4).

Ao submeter o formulário, a anotação @ResquestMapping verifica o caminho e o método submetido. Imagine que @ResquestMapping recebe uma chamada HTTP com o caminho “/contato/1”, seria apenas uma visualização do contato número 1 se RequestMethod.DELETE não fosse acionado, disparando automaticamente o método delete(), que tem como objetivo remover o contato. Esta remoção é feita pelo remove() do DAO.

Através de templates URI, a anotação @PathVariable determina à variável que será recebida e transmitida para o método em questão. Se quisermos excluir um determinado contato, enviamos ao navegador o caminho “/contato/1”, mas que será traduzido como “contato?id=1”. Como parâmetro, a variável pode ser convertida para um determinado tipo em sua captura, assim como renomeada.

A conclusão de cada operação no controller pode ser feita através de um redirecionamento, enviando a string “redirect:/caminho” ou simplesmente retornando o caminho que deseja exibir.

A configuração do web.xml

O arquivo web.xml precisa de alguns ajustes, uma vez que este já possui configurações iniciais para trabalhar com o Spring MVC. A Listagem 4 exibe o arquivo web.xml na íntegra.

Listagem 4. O web.xml.





SpringMVC



org.springframework.web.context.ContextLoaderListener





ContatoManager

org.springframework.web.servlet.DispatcherServlet





ContatoManager

/





default

/static/*







httpMethodFilter

org.springframework.web.filter.HiddenHttpMethodFilter







httpMethodFilter

ContatoManager





OpenEntityManagerInViewFilter



org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter







OpenEntityManagerInViewFilter

/*





10





index.jsp

Para o Spring MVC funcionar, utilizamos o servlet org.springframework.web.servlet.DispatcherServlet, configurado no arquivo web.xml da aplicação. Por padrão, o Spring olha beans em arquivos cujo começo possui o mesmo nome do Servlet configurado, seguido de -servlet.xml. Para melhor entendimento, o nome ContatoManager, dado no elemento , fará com que o Spring procure por um arquivo chamado ContatoManager-servlet.xml.

Evidentemente ele não é o único item que deve ser configurado no arquivo, já que, se pretendemos trabalhar com REST, como já foi citado anteriormente, precisamos adicionar o filtro pela classe org.springframework.web.filter.HiddenHttpMethodFilter.

Para trabalhar com a JPA, utilizamos o filtro org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter, do Spring. Entretanto, deixarei para falar sobre este filtro em outra ocasião.

O arquivo persistence.xml

A Listagem 5 mostra o arquivo persistence.xml, que configura como provider o Hibernate. Este arquivo deve ser criado dentro do diretório META-INF. Este diretório será criado em src/main/Java. Veja como ficará em seu projeto através da Figura 20.

Figura 20 – Localização do arquivo persistence.xml dentro de META-INF

Listagem 5. Configuração do arquivo persistence.xml.







br.com.integrator.Contato

Configurando o Spring

Revisando até o momento o que criamos, temos um DAO simples que se comunica com o banco de dados através da JPA, utilizando o Hibernate como provider.

Este DAO será executado pelo Controller do Spring MVC, também já configurado.

Para trabalhar com todas estas informações, dividiremos as configurações em dois arquivos, separando suas responsabilidades.

O primeiro arquivo, chamado de applicationContext.xml (Listagem 6), será o utilizado para a trabalhar com a injeção de dependências na classe DAO, lidando com as características da JPA. Este arquivo deve ser criado dentro do diretório WEB-INF.

Para criá-lo, cliquem com o direito do mouse em src/main/webapp/WEB-INF e selecionem New>Spring Bean Configuration File no menu de contexto.

Na caixa de diálogo Create a new Spring Bean Definition file coloque o nome do arquivo de applicationContext (Figura 21) e clique no botão Next.

Figura 21 – Criação do arquivo applicationContext.xml pelo assistente

Na segunda etapa, mantenha o beans – http://www.springframework.org/schema/beans e mantenha selecionado o item XSD como mostrado na Figura 22.

Figura 22 – Seleção do namespace beans

Ainda na segunda etapa, mantenha o context – http://www.springframework.org/schema/context e mantenha selecionado o item XSD como mostrado na Figura 23.

Figura 23 – Seleção do namespace context

A última opção que selecionaremos na segunda etapa será o tx – http://www.springframework.org/schema/tx e mantenha selecionado o item XSD como mostrado na Figura 24. Confirmem no botão Finish.

Figura 24 – Seleção do namespace tx

Caso tenhamos esquecido de selecionar algum namespace, não tem importância, pois ao finalizar o assistente, o editor do arquivo de configuração do Spring se abre. Neste caso, vamos adicionar um último namespace. Cliquem na aba Namespaces e marquem o namespace mvc – http://www.springframework.org/schema/mvc e selecionem o XSD como mostrado na Figura 25.

Figura 25 – Seleção do namespace mvc

O conteúdo completo do arquivo applicationContext.xml está na Listagem 6.

Listagem 6. Configuração do arquivo applicationContext.xml.

No Spring MVC, para determinar a classe controladora, utilizamos a anotação @Controller. Entretanto, para que seja possível detectar esta anotação, o Spring utiliza o elemento , onde indicamos o pacote em que ele pode verificar. Este recurso é chamado de Classpath scanning, que permite ao Spring ler as classes encontradas no pacote indicado da aplicação em busca das que estão anotadas. Isso evita que tenhamos de declarar estas classes no XML. Ao fazer este “scanning”, as classes são passadas por um filtro e então a definição de um bean é criada para cada uma delas. Evidentemente que este filtro é determinado pelas anotações, onde não existem apenas as anotações que utilizamos neste exemplo, mas de outras mais que temos como referencia para o framework: @Component, @Service, @Controller e @Repository (que foi introduzida no Spring 2.0). Você pode também criar suas próprias anotações e filtros para declarar os componentes.

Para o Spring trabalhar com a JPA, onde a execução ocorre em ambientes Java EE, utilizamos a factory org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean:

Com a propriedade de LocalContainerEntityManagerFactoryBean especificamos o nome da persistence unit do arquivo persistence.xml. É neste arquivo que temos as configurações de acesso ao banco de dados pela JPA para realizar as operações de persistência.

Para a configuração do controle transacional em uma aplicação baseada no Spring, é necessário declarar um gerenciador que, neste caso, será a classe org.springframework.orm.jpa.JpaTransactionManager. Esta classe é utilizada para trabalhar com a JPA, independente de provedor ORM. A declaração da classe é ilustrada no trecho a seguir:

JpaTransactionManager precisa de qualquer implementação de javax.persistence.EntityManagerFactory para colaborar com EntityManager produzido pela fabrica, para conduzir transações. A classe JpaTransactionManager é recomendada para aplicações que utilizam apenas uma EntityManager.

Para que não tenhamos que fazer injeção de dependência do EntityManager em todos os nossos DAOs, utilizamos o elemento , que procura todas as classes anotadas com @PersistenceContext, @Autowired (que veremos mais adiante), entre outros, e faz a injeção de dependência automaticamente.

Por termos configurado as transações no DAO, por meio da utilização da anotação @Transactional, o elemento foi utilizado.

Como se não bastasse, temos também a parte do Spring MVC, que utiliza o elemento mvc:annotation-driven />, permitindo enviar as requisições das classes que possuem a anotação @Controller.

Configurando o Spring MVC

O segundo arquivo, com o nome de ContatoManager-servlet.xml (Listagem 7), será o responsável por configurar o caminho das views e a tecnologia empregada no projeto do Spring MVC.

Para criá-lo, cliquem com o direito do mouse sobre o diretório src/main/webapp/WEB-INF e selecionem New>Spring Bean Configuration File no menu de contexto.

Na caixa de diálogo Create a new Spring Bean Definition file coloquem o nome do arquivo de ContatoManager-servlet (Figura 26) e clique no botão Next.

Figura 26 – Criação do arquivo ContatoManager-servlet.xml pelo assistente

Na segunda etapa, mantenham apenas o item beans – http://www.springframework.org/schema/beans selecionado como mostrado na Figura 27. Finalizem o assistente pelo botão Finish.

Figura 27 – Seleção do namespace beans

A Listagem 7 exibe, na íntegra, o conteúdo do arquivo ContatoManager-servlet.xml.

Listagem 7. Configuração do arquivo ContatoManager-servlet.xml.

O Spring MVC possui um suporte a inúmeros tipos de views, utilizando diversos tipos de tecnologias, como JSP, FreeMarker, JasperReports, Velocity, XML, XSLT e outros. Quando vamos criar um projeto Spring MVC, podemos utilizar uma ou diversas ao mesmo tempo, o que significa que é possível apresentar uma página em HTML gerada pelo JSP contendo os dados vindos do banco de dados através do uso do Spring MVC e também um XML contendo os mesmos dados, com uma pequena alteração de extensão no navegador.

Com a classe org.springframework.web.servlet.view.InternalResourceViewResolver pré-fixamos o caminho das páginas em “/WEB-INF/jsp/” e damos o sufixo, sendo “.jsp”. Para o conteúdo das páginas, temos InternalResourceViewResolver, uma subclasse de UrlBasedViewResolver, que suporta JSTL, onde utilizaremos em nossas views.

Atenção: Como boa prática recomendada pelo Spring, coloquem as páginas JSP dentro do diretório WEB-INF, impedindo assim seu acesso direto através da URL.

As views

Criaremos agora três páginas que representarão nosso CRUD. Estas páginas serão criadas dentro de um diretório chamado contato, que ficará dentro de jsp em WEB-INF. Os diretórios jsp e contato ainda não foram criados. Para criá-los, clique com o direito do mouse sobre src/main/webapp/WEB-INF e selecione New>Folder no menu de contexto.

Figura 28 - Os diretórios jsp e contato criados dentro de WEB-INF do projeto

O formulário de cadastro

Se preferir, mude a perspectiva do Eclipse para Java EE, assim será possível clicar com o direito do mouse sobre o diretório e selecionar, no menu de contexto, o item New>JSP File. O assistente de criação de páginas JSP pode lhe ajudar com um template Basico. Por fim, dê o nome de create.jsp no arquivo e coloque o conteúdo similar ao mostrado na Listagem 8.

Listagem 8. A página create.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>











Cadastrar









<%@ include file="/menu.jsp" %>













Nome:










Email:










Telefone:

Podemos ter uma idéia de como ficará a página create.jsp através da Figura 29.

Figura 29 – A página create.jsp

Analisando o web.xml, veremos o elemento , que define onde a aplicação encontrará os conteúdos estáticos do aplicativo. O Servlet default, utilizando neste caso, pertence as configurações padrão do Tomcat, responsável por servir conteúdos estáticos de aplicações web. Mesmo que seus arquivos não estejam em um diretório com este nome, é necessário acrescentá-lo como parte do caminho. Isso inclui imagens e folhas de estilo [1].

Para criar estas páginas, utilizamos tags da biblioteca JSTL e tags do próprio Spring. No caso do Spring, as tags

possibilitam que tenhamos um formulário ligado ao controller. Para utilizar estas tags, devemos acrescentar a seguinte taglib:

<%@ taglib prefix=”form” uri=”http://www.springframework.org/tags/form” %>

Na construção dos formulários para inserir e atualizar, utilizamos a tag que possui um atributo modelAttribute, ligando o formulário ao parâmetro do método que executa sua ação. O atributo method indica qual o tipo de ação será feita no controller.

A tag possui o atributo path com o valor correspondente aos atributos existentes no bean Contato.

A página que lista todos os cadastros e permite a exclusão

Para a listagem de todos os cadastros efetuados, criaremos uma página chamada list.jsp, contendo as mesmas informações existentes na Listagem 9.

Junto a listagem, teremos a possibilidade de excluir o cadastro diretamente por esta página.

Figura 30 – A página list.jsp

Listagem 9. A página list.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>











Listar









<%@ include file="/menu.jsp" %>



















Id

Nome

E-mail

Telefone

Atualizar

Excluir







${contato.id}

${contato.nome}

${contato.email}

${contato.telefone}





" title="Atualizar Contato" value="Atualizar Contato"/>









" title="Excluir Contato" value="Excluir Contato"/>













Não há contatos cadastrados.

Id	Nome	E-mail	Telefone	Atualizar	Excluir
${contato.id}	${contato.nome}	${contato.email}	${contato.telefone}	" title="Atualizar Contato" value="Atualizar Contato"/>	" title="Excluir Contato" value="Excluir Contato"/>

O Spring MVC gera um Map através de sua classe org.springframework.ui.ModelMap, onde capturamos os valores retornados pelo método findAll(), de ContatoDAO. Este Map é capturado pela view, no clássico esquema definido pelo MVC.

No caso da listagem de contatos, este Map, definido como contatos no método list(), de ContatoController, é varrido por um loop criado pela tag JSTL no seguinte trecho:

Na listagem dos contatos, em uma das tags , vemos em um de seus atributos method o valor DELETE, definido como a ação de exclusão de contatos.

Como os navegadores não reconhecem o envio de formulários além dos métodos POST e GET, precisamos de uma ajuda do Spring Framework para fazer a operação DELETE. O que o Spring MVC fará é traduzir o valor do atributo desta tag, na geração do HTML, da seguinte forma:

Observe que ele criou uma tag oculta HTML na renderização da página com um nome _method e com o valor DELETE. Esta simples adição permitirá a ação de excluir pela classe PostController.

A página de atualização de dados

A última página que teremos no CRUD é a de atualizar (update.jsp), similar ao de adicionar dados, exceto pelo fato de receber os dados vindos do banco de dados para serem exibidos.

Listagem 10. A página update.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>











Atualizar









<%@ include file="/menu.jsp" %>













Nome:










Email:










Telefone:

Similar ao que ocorre com a listagem de contatos, temos no formulário da página de atualização o valor PUT para o atributo method. Novamente, o Spring Framework irá gerar um campo oculto, em HTML, contendo esta informação e transmitindo ao navegador o HTML como ele já o conhece.

Figura 31 - A página update.jsp

As páginas que não fazem parte do CRUD

O menu e a página inicial não fazem parte do CRUD e, portanto, serão apenas apresentadas aqui com seus códigos para completar o exemplo.

A página index.jsp deverá ser criada em webapps:

Listagem 11. A página index.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>









" rel="stylesheet" />

Principal









<%@ include file="/menu.jsp" %>







Aplicação CRUD criada utilizando o Spring MVC 3.0 com suporte a REST.

Assim como index.jsp, crie o menu.jsp em webapps.

Listagem 12. A página menu.jsp.





Contato



">Ver todos

">Novo Contato

Figura 32 – Visão geral de todos os arquivos utilizados na geração do projeto

O projeto para download

Clique aqui para baixar o projeto completo como feito até o momento.

Considerações finais

Agora que aprendemos a fazer um CRUD com o Spring MVC, podemos criar projetos mais complexos. Caso estejam com pressa em aprender algo mais complexo, a revista JavaMagazine #78 publicou, alguns meses atrás, um artigo meu com o Spring MVC 3 na criação de um blog, passo a passo.

No próximo artigo

Faremos alterações neste projeto, criando as verificações utilizando Bean Validation e depois trabalhando com testes.

Até o próximo artigo pessoALL.

[1] Imagens e folhas de estilo foram omitidos neste artigo, mas podem ser obtidos no projeto completo encontrado no final para download

Guia de Certificação SCJP

Edson Gonçalves — Thu, 12 Aug 2010 04:07:23 +0000

Olá Pessoal, tudo bom? Como estão vocês?

O artigo que veremos a seguir foi escrito pelo jovem autor Camilo Lopes, falando a respeito de seu livro Guia do Exame SCJP e também de seu simulado para o exame SCJP.
Dúvidas e críticas são sempre bem vindas.

A Certificação SCJP

É muito comum que os candidatos para SCJP tenham dúvidas referentes a qual material devam adquirir para ser um SCJP 5/6.

Neste post vou falar um pouco sobre o livro Guia do Exame SCJP(não à nível comercial) e como o candidato deve se preparar para o exame. O objetivo maior do post é deixar o futuro SCJP ciente de quais referências ele deve ter em mãos, mantendo o custo x benefício.

Antes de comprar qualquer material de estudo ou até fazer uma matricula na escola mais próxima de sua casa, o candidato deve ter um objetivo: por que ele quer ser certificado? Qual ou quais o(s) objetivo(s) que este tem para sua carreira à curto/médio prazo? Não queira pensar à longo prazo, algo em torno de 10 anos, mas em um tempo mais próximo e que consiga realizar. Por exemplo:

Há pessoas que tiram certificações para encantar os headhunters (nem sempre funciona).
Outros obtém a certificação para testar o próprio conhecimento na tecnologia ou área especifica.
Alguns para buscar um diferencial em uma vaga de emprego; porém este tem sólidos conhecimentos tanto práticos quanto teóricos. Enquadrados nesta opção estão muitos estudantes recém-formados sem experiência, que conseguiram a primeira oportunidade de trabalhar na área devido à uma certificação.

Olha o que a Kathy, fala a respeito do porque de obter uma certificação:

“Passar no exame provará três itens importantes para o empregador atual ou futuro: Que você sabe das coisas; que sabe como estudar e se preparar para um teste desafiador; e acima de tudo, que conhece a tecnologia e está de acordo com os objetivo cobrados para tal exame. Se um empregador tiver que optar entre um candidato que passou no exame e outro que não tenha passado, ele saberá que o programador certificado não demorará no aprendizado.”

Aonde eu quero chegar?

Quero chegar que não importa se você tem um livro que foi escrito por um dos desenvolvedores do exame, fabricante da tecnologia ou qualquer outro. Se você não tem um objetivo, não adianta ter a melhor ferramenta.

E o livro Guia SCJP? Para o que, de fato, ele apóia o candidato? Acho tão parecido com o livro oficial da Kathy.

Essa é uma pergunta bem comum de alguns futuros candidatos a certificados SCJP. O livro pode parecer que é mais um que foi publicado para concorrer com o livro oficial, mas não é verdade, ele veio para completar os seus estudos após a leitura do oficial, uma vez que o candidato já fez os exercícios e está cansado daquele material, precisando de um novo que lhe ajude revisar os pontos chaves do exame, mostrando as possíveis pegadinhas, com explicações dentro do código Java ajudando a fixar e compreender a teoria com a pratica, apresentando exemplos de todo tipo: compila, não compila, com exceções especificas, genéricas e etc. Enfim, o guia trabalha em cima dos detalhes que você, futuro SCJP, não pode pensar em esquecer no dia do exame.

Mas, para qual versão do exame o livro é mais adequado?

Para os dois: SCJP 5 e 6. Entretanto, o livro não aborda as particularidades que foram adicionadas no exame 6, pois essas não correspondem nem a 20% do total das questões. O objetivo do Guia é literalmente guia-lo para os pontos críticos e que tem mais “peso” na certificação, que são os assuntos como: Threads, Orientação à objetos, Exceções, fundamentos Java, etc. E todos esses assuntos estão presentes nos dois exames.

O Guia

Guia do Exame SCJP

O guia foi criado baseado em algumas dificuldades que o autor encontrou na época em que se preparava para certificação. Uma delas era ter um material que pudesse ler nas pequenas horas livres, tais como:

intervalo da faculdade;
Sala de espera;
Metrô, ônibus;
esperando a namorada trocar de roupa;
não estava com paciência de ler os capítulos longos do livro oficial;
etc.

Foi a partir dessas necessidades que nasceu o Guia. Este guia não tem o objetivo de ensinar a tecnologia Java de modo prático. Não espere aprender à criar aplicações Java, criar conexões com o Banco de dados ou algo semelhante. Este livro é focado no exame, querendo deixar o candidato mais seguro e atento as armadilhas que estão na SCJP. Foram meses de pesquisas com mais de 400 classes compiladas e inúmeros testes. A “fecundação” do Guia iniciou em 2007, porém somente em meados de 2009 que a “criança” começou a criar seu formato para ser publicado em 2010. Antes disso, foram horas e meses de trabalho para que se pudesse ter de fato um guia focado no exame e não apenas mais um livro repetindo levemente o que há em outros.

O Guia acompanha um simulado(beta) exclusivo para os leitores testarem o conhecimento. E uma das vantagens do simulado é que há questões em português e inglês, sem falar nas questões que possuem um temporizador para responder, o que ajuda o candidato a obter a disciplina em saber que ele não tem todo o tempo do mundo para responder uma questão. No exame, o candidato precisa ser rápido e eficiente, ou seja, ter conteúdo suficiente para “matar” uma questão no menor tempo possível.

Simulado Gratuito

O autor lançou um simulado inteiramente grátis para a comunidade, o chamado SimSCJP Beta, que possui algumas questões para que o interessado possa conhecer o seu trabalho e “brincar” um pouco com o seu conhecimento. Para aqueles que desejam uma versão completa, o autor oferece o Premium Beta, com mais simulados. Os interessados na versão Premium Beta, podem obter estes simulados por um valor simbólico R$ 19,90 (boleto/ cartão crédito).

Nota do Edson Gonçalves: Em se tratando de simulados para exame, é talvez o mais barato e bem elaborado já lançado até o momento para o preparo da certificação SCJP.

Onde adquirir o livro?

Você pode adquirir o livro no site da editora www.lcm.com.br, com 30% de desconto, bastando informar o código V00014, através de qualquer uma das grandes livrarias espalhadas pelo Brasil ou em lojas virtuais como Fnac, Saraiva e etc.

Quanto custa?

O autor teve uma grande preocupação neste quesito, onde queria um livro que todos pudessem comprar sem apertar o orçamento. Em parceria com a editora, isso foi possível e o valor sem desconto é de R$ 49,00. Existem livrarias que parcelam em até 2x, outras que oferecem com frete grátis.

Vou ficando por aqui, espero que tenham gostado do post e qualquer dúvida é só perguntar.

O Autor

Camilo Lopes profissional trabalha com Tecnologia de Informação desde 2003, possui experiência em desenvolvimento de sistemas Web. Conhecimento em servidores de aplicações, banco de dados e linguagens de programação. Programador certificado pela Sun Microsystems - SCJP 5. Possui Experiência em treinamento corporativos na área de TI aos usuários. Bacharelado em Análise de Sistemas, Pós-Graduando em Gestão Estratégia de Negócios. Atualmente trabalha na IBM/Brazil onde atua como Analista Programador/Specialist IT em projetos Internacionais. Vem atuando como Consultor TI orientando pequenas e médias empresas como aprimorar e ampliar seus negócios usando TI. Nas horas livres gosta de escrever livros e artigos técnicos para editora Ciência Moderna e Revista Java Magazine.

Alguns trabalhos:

Atua como articulista Java UOL Imasters e na revista Java Magazine.

Autor do Simulado para SCJP – SimSCJP Premium
Autor do livro “Guia do Exame SCJP”

Colunista Java desde 2008, tem uma série de artigos Java, BD, JEE, Certificação etc.

Revista Java Magazine JM 72 – Artigo sobre Certificações Java

Hibernate com Hibernate Tools

Edson Gonçalves — Sun, 27 Jun 2010 04:30:05 +0000

Olá Pessoal, tudo bom? Como vão vocês?

O artigo que veremos fala sobre a utilização do Hibernate Tools, um excelente plugin para o Eclipse IDE, oficial da Red Hat, feito para trabalhar com o Hibernate.

Dúvidas e críticas são sempre bem vindas.

Obtendo e instalando o Eclipse IDE

Para desenvolver este exemplo, utilizei a versão do Eclipse IDE 3.6, em um ambiente voltado para o trabalho com Java EE. Para obter o Eclipse IDE, já configurado com o ambiente Web, vá ao endereço http://www.eclipse.org/downloads/ e clique em Eclipse IDE for Java EE Developers. Lembre-se de selecionar o seu sistema operacional.

Ao baixar, descompacte em um local desejado de sua máquina.

O plugin JBoss Tools

Para a versão do Eclipse 3.6, o atual enquanto escrevo este artigo, temos uma versão em desenvolvimento compatível do plugin JBoss Tools. Para obtê-lo, basta baixar a versão de desenvolvimento atual, encontrada em um dos diretórios existentes dentro deste endereço:

http://download.jboss.org/jbosstools/builds/nightly/trunk/

Podemos baixar o Hibernate Tools separadamente ou, como fiz, baixando o JBoss Tools completo. O arquivo que obtive, no momento em que escrevo é o JBossTools-Update-3.2.0.v201006240331N-H369-M1.zip. Com o Eclipse IDE fechado, ao baixar o plugin, descompacte e mova seu conteúdo sobre o diretório eclipse. Isto fará a instalação do plugin JBoss Tools. Depois de adicionarmos o plugin, inicie o Eclipse.

Atenção: Por se tratar de uma versão em desenvolvimento, o endereço passado neste artigo poderá sofrer alterações. Portanto, sempre verifique a última versão no endereço http://download.jboss.org/jbosstools/builds/. As versões de desenvolvimento costumam causar instabilidade no Eclipse, portanto, façam seu uso em um ambiente de testes.

O banco de dados

Utilizaremos o banco de dados MySQL, que pode ser adquirido clicando aqui. O banco de dados que utilizaremos para executar o exemplo se chamará hibernatenapratica.

Criando o projeto

Iniciem alterando a perspectiva. No ícone Open Perspective, cliquem em Other.

Figura 1 – Alterando a Perspectiva

Selecionem em seguida a Perspectiva Hibernate.

Figura 2 – Seleção da perspectiva Hibernate

Na view Package Explorer, cliquem com o direito do mouse e selecionem, no menu de contexto, o item Project.

Figura 3 – Criando um novo projeto pela view Package Explorer através do menu de contexto

Na caixa de dialogo New Project, selecionem Java>Java Project e cliquem no botão Next.

Figura 4 – Seleção da opção Java Project

Em New Java Project, digitem o nome do seu projeto. Irei utilizar o nome ProjUtilizandoHibernateTools. Em seguida, cliquem no botão Finish.

Figura 5 – Criação de um projeto Java

Ao surgir a caixa de dialogo Open Associated Perspective, cliquem no botão No. Nós não precisaremos da perspectiva Java apenas para editar o projeto, uma vez que nossa intenção é trabalhar única e exclusivamente com o Hibernate.

Figura 6 – Pergunta automática de alteração de perspectiva feita dependendo do tipo de projeto criado

As bibliotecas

Para trabalhar com o Hibernate 3.5, primeiramente será preciso configurar os arquivos no projeto. Para adicionar as bibliotecas que necessitamos ao projeto, cliquem com o direito do mouse sobre o mesmo, na view Package Explorer e, no menu de contexto, selecionem Properties.

Figura 7 – Bibliotecas do projeto

Vocês podem baixar as bibliotecas do Hibernate clicando aqui. No site, em Download, no menu lateral esquerdo, encontramos as bibliotecas para serem baixadas. A versão, no momento em que escrevo, é a 3.5.1.

Os arquivos que utilizaremos no projeto serão os encontrados em:

Hibernate Core

Ao baixar os arquivos, descompacte-os. Vocês precisarão das seguintes bibliotecas:

hibernate3.jar
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.9.0.GA.jar
jta-1.1.jar
slf4j-api-1.5.8.jar
hibernate-jpa-2.0-api-1.0.0-CR-1.jar

Além destes arquivos, será necessário utilizar as bibliotecas da Simple Logging Facade for Java, SLF4J. Baixem os arquivos com todas as bibliotecas da SLF4J aqui.

Ao descompactar o arquivo, vocês encontrarão a seguinte biblioteca:

slf4j-jdk14-1.5.11.jar

Por fim, também necessitaremos da biblioteca JDBC do MySQL, que pode ser obtida clicando aqui. A versão 5.1.10 era, no momento em que este artigo começa a ser escrito, a versão mais atual. Entretanto, é possível que, com o tempo, isto esteja alterado.

Para o projeto, precisaremos do seguinte JAR:

mysql-connector-java-5.1.10-bin.jar

Criando o JavaBean Categoria

Com o direito do mouse em seu projeto, vamos até o item New>Other. Na caixa de diálogo New, selecionem Java>Class. Na caixa de diálogo New Java Class, preencham o pacote (br.com.integrator) e o nome da classe, no caso Categoria, em Name. Confirmem a criação no botão Finish.

Figura 8 – Criando a classe Categoria

Alterem a classe Categoria conforme mostrado na Listagem 1.

Listagem 1 – O JavaBean Categoria

package br.com.integrator;

import java.io.Serializable;

import java.lang.Long;

import java.lang.String;

public class Categoria implements Serializable {

private Long id;

private String categoria;

private String descricao;

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getCategoria() {

return categoria;

}

public void setCategoria(String categoria) {

this.categoria = categoria;

}

public String getDescricao() {

return descricao;

}

public void setDescricao(String descricao) {

this.descricao = descricao;

}

}

Mapeando a tabela no Hibernate utilizando a forma tradicional

Para mapear a tabela correspondente no banco de dados a classe Categoria, através do Hibernate, temos que criar um XML como forma tradicional de utilização do framework.

Selecionem o pacote e a classe na view Package Explorer e, com o direito do mouse, selecionem o item New>Hibernate XML Mapping file (hbm.xml).

Figura 9 – Seleção do item Hibernate XML Mapping file (hbm.xml) no menu de contexto

Na caixa de diálogo New Hibernate XML Mapping Files (hbm.xml), teremos os dois itens selecionados: o pacote e a classe. Caso tenhamos esquecido de selecionar um ou ambos, podemos clicar nos botões que estão na lateral direita (Add Class e Add Package). Continuem no botão Next.

Figura 10 – Criação do arquivo XML de mapeamento do Hibernate

Na etapa seguinte o assistente exibirá o arquivo Categoria.hbm.xml que será criado. Continuem no botão Next.

Figura 11 – Apresentação do arquivo XML de mapeamento do Hibernate que será criado

A última etapa apresentará o XML do mapeamento criado para o Hibernate, onde a base foi a classe Categoria. Confirmem a criação no botão Finish.

Figura 12 – Arquivo XML do mapeamento que será criado

Com a finalização do assistente, temos o XML gerado aberto pelo editor do Hibernate Tools. Neste editor podemos mudar as características que desejamos no XML gerado, colocando mais informações em cada propriedade.

Figura 13 – Editor do XML gerado para Hibernate

O resultado final será como o mostrado na Listagem 2 a seguir:

Listagem 2 – O arquivo Categoria.hbm.xml

O resultado final será como o mostrado na Listagem 2 a seguir:

Listagem 2 – O arquivo Categoria.hbm.xml

Configurando o Hibernate

Com o direito do mouse sobre src, na view Package Explorer, selecionem Hibernate Configuration File (cfg.xml).

Figura 14 – Criação do arquivo hibernate.cfg.xml

Ao surgir o assistente, deixem o nome do arquivo como hibernate.cfg.xml e prossigam no botão Next.

Figura 15 – Assistente de criação do arquivo de configuração do Hibernate

Como vamos utilizar o banco de dados MySQL, preencham os campos como mostrado na Figura 16, alterando de acordo com as configurações que possuem em seu banco de dados.

Por fim, marquem a opção Create a console configuration. Cliquem no botão Next.

Figura 16 – Configuração do banco de dados no hibernate.cfg.xml

Na última etapa, temos as configurações do console do Hibernate. Este console, quando configurado e funcional, nos permite executar queries HQL ou trabalhar com Criteria.

Figura 17 – Configuração do console Hibernate

Cliquem na aba Mappings e removam o caminho configurado automaticamente para o arquivo Categoria.hbm.xml. Este caminho não será preciso porque iremos configurá-lo diretamente no arquivo hibernate.cfg.xml, ao qual o console fará uso também. Confirmem o assistente clicando no botão Finish.

Figura 18 – A abra Mappings da configuração do console

Na finalização do assistente, abrirá o editor do arquivo de configuração do Hibernate.

Figura 19 – O editor do arquivo de configuração do Hibernate

Como muitas das informações que desejávamos, foram colocadas no assistente, resta apenas adicionar o caminho para Categoria.hbm.xml. Para fazermos isso, basta ir no botão Add e digitar o caminho em Resource.

Figura 20 – Detalhe de Mappings com o arquivo Categoria.hbm.xml adicionado

Para executarmos o exemplo, tornando possível a criação da tabela no banco de dados pelo Hibernate, assim como sua recriação a cada nova execução, expandindo Session Factory>Properties>Hibernate, em Hibernate Configuration 3.0 XML Editor, alterem Hbm2ddl Auto para create-drop.

Neste mesmo local, onde temos as propriedades, podemos alterar para true em Show SQL, Use SQL Comments e Format SQL.

Figura 21 – Adicionando novas propriedades ao arquivo hibernate.cfg.xml

O resultado final das configurações, no arquivo hibernate.cfg.xml, são mostrados na Listagem 3 a seguir:

Listagem 3 – O arquivo hibernate.cfg.xml









org.gjt.mm.mysql.Driver

integrator

jdbc:mysql://localhost/hibernatenapratica

edson

org.hibernate.dialect.MySQL5InnoDBDialect

true

true

true

create-drop

Algumas características do Hibernate Tools

Como Hibernate está devidamente configurado, podemos já utilizar algumas de suas características.

Figura 22 – A view Hibernate Configurations após as configurações do arquivo hibernate.cfg.xml

Na view Hibernate Configurations, cliquem com o direito do mouse e selecionem Mapping Diagram.

Figura 23 – Acessando Mapping Diagram no menu de contexto

O Hibernate Tools possui uma ferramenta visual que nos permite visualizar as classes mapeadas em suas tabelas correspondentes encontradas no banco de dados. Isto não significa que a tabela já exista no banco de dados. Trata-se da forma como a configuração “enxerga” a tabela em que irá trabalhar no banco de dados.

Figura 24 – Visualizando a classe Categoria mapeada para a tabela correspondente no banco de dados

Colocando o Hibernate para trabalhar

Iremos criar duas pequenas classes que juntas irão gerar a tabela e seus dados dela no banco de dados.

Com o direito do mouse sobre src, na view Package Explorer, selecionem o item New>Other. Na caixa de dialogo New, selecionem Java>Class.

Coloquem o pacote br.com.integrator.util e deem o nome da classe de HIbernateUtil, confirmando o assistente, em seguida, no botão Finish.

Figura 25 – Criação da classe HibernateUtil

O conteúdo da classe HibernateUtil será similar ao mostrado na Listagem 4 a seguir:

Listagem 4 – A classe HibernateUtil

package br.com.integrator.util;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class HibernateUtil {

private  static final SessionFactory sessionFactory;

static {

try {

sessionFactory = new Configuration().configure()

.buildSessionFactory();

} catch (Throwable ex) {

System.err.println("Initial SessionFactory creation failed." + ex);

throw new ExceptionInInitializerError(ex);

}

}

public static SessionFactory getSessionFactory() {

return sessionFactory;

}

}

A segunda classe que criaremos irá se chamar Main e será colocada no pacote br.com.integrator.

Figura 26 – Criação da classe Main

O conteúdo da classe Main é mostrado na Listagem 5 a seguir:

Listagem 5 – A classe Main

package br.com.integrator;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.Transaction;

import br.com.integrator.util.HibernateUtil;

public class Main {

public static void main(String[] args) {

Session session = HibernateUtil.getSessionFactory().openSession();

Transaction transaction = null;

try {

transaction = session.beginTransaction();

Categoria categoria1 = new Categoria();

categoria1.setCategoria("Informática");

categoria1.setDescricao("Produtos de Informática");

session.save(categoria1);

Categoria categoria2 = new Categoria();

categoria2.setCategoria("Eletrodomésticos");

categoria2.setDescricao("Eletrodomésticos em Geral");

session.save(categoria2);

Categoria categoria3 = new Categoria();

categoria3.setCategoria("Livraria");

categoria3.setDescricao("Livros para todos os gostos");

session.save(categoria3);

transaction.commit();

} catch (HibernateException e) {

transaction.rollback();

e.printStackTrace();

} finally {

session.close();

}

}

}

Executem a classe Main para que o Hibernate crie a tabela categoria e adicionem o conteúdo. Graças as configurações criadas no arquivo hibernate.cfg.xml, temos a saída na view Console como mostra a Figura 27.

Figura 27 – A saída no console criada na execução do exemplo

O Editor HQL e Criteria

Para acessar o editor HQL do Hibernate Tools, cliquem com o direito do mouse em qualquer parte da view Hibernate Configurations e selecionem, no menu de contexto, o item HQL Editor.

Figura 28 – Chamando o editor HQL pelo menu de contexto na view Hibernate Configurations

No editor HQL, se digitarmos uma query HQL, veremos também na view Hibernate Dynamic SQL Preview a instrução SQL gerada automaticamente pelo Hibernate.

Figura 29 – Editor HQL em ação e a view Hibernate Dynamic SQL Preview exibindo a SQL gerada

Ao mandarmos executar a query HQL, em Run HQL, vemos o resultado surgir na view Hibernate Query Result. Quando selecionamos este resultado, vemos os dados na view Properties.

Figura 30 – Resultados encontrados na query HQL executada nas views Hibernate Query Result e Properties

A parte de Criteria também é bem fácil de se criar. Cliquem com o direito do mouse sobre Session Factory>br.com.integrator.Categoria e selecionem, no menu de contexto, o item Hibernate Criteria Editor.

Figura 31 – Abrindo o editor de criteria

Ao surgir o editor de Criteria, basta completarmos a instrução que desejamos executar. Em seguida, clicamos no botão Run criteria (o mesmo botão que no editor HQL se chama Run HQL).

Figura 32 – Criação do Hibernate Criteria no editor e seu resultado apos clicar em Run criteria

Engenharia Reversa

A engenharia reversa no Hibernate Tools também é de fácil utilização.

Para trabalhar com a engenharia reversa, é necessário termos o arquivo de configuração do Hibernate, configurado para conectar-se ao banco de dados pré-existente.

A engenharia reversa está preparada para gerar as classes, os arquivos .hbm.xml ou então anotações. Também é possível termos anotações JPA, relacionamentos e outros.

Para criar a engenharia reversa em nosso exemplo, cliquem com o direito do mouse na view Package Explorer. No menu de contexto selecionem New>Hibernate Reverse Engineering File (reveng.xml).

Figura 33 – Opção Hibernate Reverse Engineering File (reveng.xml) do menu de contexto

Na caixa de diálogo, selecionem o diretório src e mantenham o nome do arquivo padrão solicitado. Cliquem no botão Next.

Figura 34 – Iniciando a criação do arquivo de configuração de engenharia reversa

Na etapa seguinte, selecionem a configuração do console previamente criada em Console configuration. Cliquem no botão Refresh e selecionem no banco de dados a(s) tabela(s) que desejam trabalhar na engenharia reversa para utilizar com o Hibernate e confirmem no botão Include. Concluam o assistente no botão Finish.

Figura 35 – Seleção da tabela categoria para a engenharia reversa

O assistente irá gerar o arquivo de engenharia reversa. Agora iremos configurá-lo para que, na geração dos arquivos baseados na(s) tabela(s) do banco de dados, a conversão seja exatamente como desejamos.

Comecem indo na aba Type Mappings e cliquem no botão Refresh.

Figura 36 – Exibindo o banco de dados através do botão Refresh

Na caixa de diálogo Select a console configuration, selecionem o console criado e confirmem no botão OK.

Figura 37 – Seleção da configuração de console

Retornando para o editor, temos o banco de dados, tabela(s) e campo(s). Para que ocorra a engenharia reversa de forma correta, devemos Add cada um deles, editando o Hibernate Type, Length e também Not-Null.

Vejam como é mostrado na Figura 38.

Figura 38 – Configurando os tipos JDBC e Hibernate da tabela para executar a engenharia reversa

O resultado do arquivo configurado, visto na aba Source, em formato XML, é como o mostrado na Listagem 6.

Listagem 6 – O arquivo hibernate.revenge.xml

Retornando a view Package Explorer, vamos configurar um console Hibernate para executar o arquivo de engenharia reversa criado. Cliquem com o direito do mouse sobre o arquivo hibernate.revenge.xml e selecionem, no menu de contexto, o item Hibernate Console Configuration.

Atenção: Esta etapa não é realmente necessária quando já existe um console configurado. Entretanto, na primeira vez que configuramos um, o acesso não havia sido feito desta maneira.

Figura 39 – Seleção do item Hibernate Console Configuration no menu de contexto

Na caixa de dialogo, alterem o campo Name para ProjUtilizandoHibernateToolsAnnotations. Verifiquem se Configuration file está corretamente apresentando o arquivo hibernate.cfg.xml.

Figura 40 – Diálogo de criação da configuração do console Hibernate para a engenharia reversa

Através do botão Run As , clicando no pequeno triângulo que aponta para baixo, encontramos um menu onde temos o item Hibernate Code Generation Configurations.

Figura 41 – Menu Run As com a opção Hibernate Code Generation Configurations

Na caixa de diálogo Hibernate Code Generation Configurations, em Hibernate Code Generation, cliquem com o direito do mouse e selecionem, no menu de contexto, o item New.

Figura 42 – Acionando o menu de contexto em Hibernate Code Generation

Na lateral direita, tenham ProjUtilizandoHibernateToolsAnnotations em Console configuration selecionado. Em Output directory, cliquem em Browse e selecionem o local onde será(ão) gerada(s) a(s) classe(s), neste caso.

Digitem o pacote em Package e, em reveng.xml, cliquem em Setup.

Figura 43 – Configuração inicial da aba Main em Hibernate Code Generation Configurations

Ao surgir o diálogo Setup reverse engineering, cliquem em Use existing.

Figura 44 – Selecionando o botão Use existing

Selecionem o item hibernate.reveng.xml e confirmem no botão OK.

Figura 45 – Seleção do arquivo hibernate.reveng.xml

Retornando ao diálogo Hibernate Code Generation Configurations, ainda na aba Main, temos todas as informações que desejamos preenchidas, como na Figura 46.

Figura 46 – Aba Main do diálogo Hibernate Code Generation Configurations preenchido

Agora iremos na aba Exporters, ao qual iremos marcar Generate EJB 3 annotations e Domain code (.java).

Figura 47 – Opções de exportação da caixa de diálogo Hibernate Code Generation Configurations

Por fim, vamos clicar no botão Run para executar a engenharia reversa.

Figura 48 – Executando a engenharia reversa através do botão Run

Neste último exemplo, o resultado é a classe Categoria sendo criada com anotações.

Considerações finais

Como vocês puderam ver, o Hibernate Tools é uma ferramenta bem interessante para aqueles que trabalham com o framework Hibernate. Seja para criar suas configurações através dos assistentes, para executar as queries HQL ou Criteria em seus editores, vale a pena instalar e conhecer este plugin do Eclipse IDE.

Até o próximo artigo pessoALL.

Ajax com JSF 2.0

Edson Gonçalves — Fri, 04 Jun 2010 11:28:29 +0000

Olá Pessoal, tudo bom? Como vão vocês?

Depois que fiz a publicação do artigo Ajax com JSF 1.2 utilizando JBoss RichFaces, alguns leitores me enviaram e-mail pedindo um exemplo com o JSF 2.0.

Então, atendendo aos pedidos, este artigo ensina como fazer o exemplo com JSF 1.2 utilizando o AJAX da biblioteca RichFaces, mas em JSF 2.0, sem adição de biblioteca AJAX.

Obtendo e instalando o Eclipse IDE

Para desenvolver este exemplo, utilizei a versão do Eclipse IDE 3.6, ainda em desenvolvimento, em um ambiente voltado para o trabalho com Java EE. Para obter o Eclipse IDE, já configurado com o ambiente Web, vá ao endereço http://www.eclipse.org/downloads/ e selecione a aba Developer Builds e clique em Eclipse IDE for Java EE Developers. Lembre-se de selecionar o seu sistema operacional.

Ao baixar, descompacte em um local desejado de sua máquina.

O Servidor Java

Para este artigo, vamos utilizar o Tomcat 7.0, ainda em desenvolvimento. Para baixar o binário do Tomcat 7, vá até o endereço http://people.apache.org/~markt/dev/tomcat-7/v7.0.0-RC3/bin/. Antes de continuarmos, vale lembrá-los que este endereço pode mudar até a versão final e que, por ser uma versão de desenvolvimento, não deve ser utilizada em produção.

A versão que vamos baixar é a compactada. Por exemplo, se o seu Windows for de uma versão 64bits, baixe o arquivo apache-tomcat-7.0.0-RC3-windows-x64.zip.

Atenção: O Tomcat 7.0 roda somente na JDK 6 ou superior.

As bibliotecas

Para trabalhar com o JavaServer Faces 2.0, primeiramente será preciso configurar os arquivos e a estrutura necessária.

O contêiner Servlet Tomcat 7, por padrão, não possue suporte direto ao JavaServer Faces, ou seja, não contém as bibliotecas necessárias para o desenvolvimento com o mesmo.

Para baixar o JSF, faça download no endereço https://javaserverfaces.dev.java.net/. Ao baixar o arquivo, simplesmente descompacte em um diretório de sua escolha.

JavaServer Faces rodando em seu aplicativo Web

Para ter o JavaServer Faces 2.0 em sua aplicação, você possui dois arquivos do tipo JAR:

jsf-api.jar
jsf-impl.jar

As bibliotecas JSTL

Os arquivos JSTL estão no endereço http://www.apache.org/dist/jakarta/taglibs/standard/binaries/, onde utilizaremos dois arquivos JARs:

jstl.jar
standard.jar

Criando o projeto

Clique no menu File>New>Dynamic Web Project. Na caixa de diálogo New Dynamic Web Project, digite ProjAjaxComJSF2 (ou o nome que desejar dar) em Project name. Clique no botão New Runtime e, na caixa de diálogo New Server Runtime Environment, expanda Apache e selecione Apache Tomcat v7.0. Clique no botão Next.

Figura 1 – Selecionando o Apache Tomcat 7

Na próxima etapa, selecione o diretório onde está localizado o seu Tomcat 7, clicando em Browse. Lembre-se da versão do JDK 6 para trabalhar com o Tomcat. Confirme no botão Finish.

Figura 2 – Definindo o local onde foi instalado o Tomcat 7

Retornando a primeira etapa da criação do projeto, em Configuration, selecione JavaServer Faces v2.0 Project. Com suas definições completas, podemos prosseguir em Next.

Figura 3 – Definição inicial do projeto completa

Iremos executar o botão Next até a última etapa, ao qual definiremos as bibliotecas do projeto.

Na última etapa do assistente, deixe Type como User Library, caso não esteja.

Figura 4 – Definindo em biblioteca de usuário

Logo abaixo, na lateral direita, você encontra o ícone Manage libraries. Dê um clique nele.

Figura 5 – Seleção de Manage libraries

Ao abrir a caixa de diálogo Preferences, verá que está filtrado direto no item User Libraries. Clique no botão New e, na caixa de diálogo New User Library digite JSF2 e confirme.

Figura 6 – Criando a biblioteca de usuário JSF2

Retornando para Preferences, selecione JSF2 e clique no botão Add JARs. Selecione os JARs do JSF 2.0 que necessitamos para o projeto e confirme.

Faça o mesmo processo para criar uma nova biblioteca de usuário, mas a chame desta vez de JSTL. Adicione as bibliotecas JSTL a esta biblioteca de usuário. Confirme por fim a caixa de diálogo Preferences no botão OK.

Figura 7 – Bibliotecas de usuário JSF2 e JSTL criadas

Por fim, selecione as bibliotecas de usuário criadas, pois elas serão adicionadas ao projeto automaticamente. Confirme a criação do projeto no botão Finish.

Figura 8 – Finalizando a criação do projeto com a seleção das bibliotecas de usuário criadas

Na finalização do projeto, o Eclipse lançará uma mensagem perguntando se desejamos mudar de perspectiva. Diga que sim, clicando em Yes. O Eclipse alterará de perspectiva, colocando na Java EE.

O deployment descriptor

O assistente do projeto criou automaticamente o web.xml com suas respectivas configurações.

Criando o JavaBean Texto

Com o direito do mouse sobre o projeto, selecione New>Class no menu de contexto.

Na caixa de diálogo New Java Class, preencha o pacote (br.com.integrator) e o nome da classe, no caso Texto, em Name. Confirme no botão Finish.

Figura 9 – A classe Texto

Altere a classe Texto conforme mostrado na Listagem 1.

Listagem 1 – O JavaBean Texto

package br.com.integrator;

@ManagedBean(name="textoBean")

@RequestScoped

public class Texto {

private String texto;

public String getTexto() {

return texto;

}

public void setTexto(String texto) {

this.texto = texto;

}

}

Sem utilizar o arquivo faces-config.xml

Caso o leitor ainda não teve a oportunidade, recomendo ler o meu artigo JavaServer Faces 2.0 na Prática – Parte 2, que explica como funciona atualmente o JSF na versão 2.0.

Criando a página JSF com suporte ao AJAX

Com o direito do mouse sobre WebContent, vá no menu de contexto em New>HTML File. No diálogo New HTML File, dê o nome no arquivo de ajaxjsf.xhtml e prossiga no assistente clicando em Next

Figura 10 – Criando uma página JSF 2

Na última etapa de criação da página, como não temos definido um Template que se encaixe na nossa necessidade de desenvolvimento da página, selecione o primeiro item da lista, no caso New Facelet Composition Page. Finalize no botão Finish.

Figura 11 – Seleção do template New Facelet Composition Page

Com a página ajaxjsf.xhtml criada e aberta no editor, altere-a deixando exatamente como mostrado na Listagem 2 a seguir: Listagem 2 – A página ajaxjsf.xhtml completa





Ajax com JSF 2.0
















Resultado:

Figura 12 – Página ajaxjsf.xhtml no editor visual Web Page Editor

Por fim, execute a página, já que o cursor e o foco estão nela, indo ao meu Run> Run As>Run on Server. Na caixa de diálogo, deixe o Tomcat como escolha para executar o projeto e clique no botão Next.

Figura 13 – Selecionando o servidor Java para executar o projeto

Adicione em Configured o projeto e clique no botão Finish. Neste momento o Apache Tomcat iniciará, executando a página JSF contendo o AJAX.

O aplicativo é de simples compreensão, como o criado no exemplo com JSF 1.2 e RichFaces. O texto digitado no campo de texto, é enviado ao servidor sem que seja submetido por um botão. Transportado ao Managed Bean textoBean, representado pela classe Texto, o valor enviado é retornado ao label abaixo, em Resultado. Como estamos usando AJAX, o texto vai sendo digitado e enviado a cada nova letra para o servidor e retornada à página sem um reload no browser.

Figura 14 – A página executada

Este envio ao servidor, sem reload na página, e o retorno é feito graças ao suporte ao AJAX do JSF 2.0, pela tag :

“texto” value=“#{textoBean.texto}”>

“keyup” execute=“form1:texto” render=“form1:resultado”/>

Esta tag trabalha com o evento JavaScript onkeyup (que no caso deve ser keyup), que chama o servidor e renderiza o resultado onde o atributo render estiver apontando. Observe que esta tag está dentro da tag JSF , que é exatamente onde ela trabalhará para receber o evento e se comunicar com o servidor, transmitindo as informações nela contidas.

No próximo artigo

No próximo artigo veremos uma biblioteca AJAX compatível com JSF 2.0 e alguns recursos interessantes que ela pode nos oferecer.

Até o próximo artigo pessoALL.

Ajax com JSF 1.2 utilizando JBoss RichFaces

Edson Gonçalves — Sat, 22 May 2010 04:49:57 +0000

Olá Pessoal, tudo bom? Como vão vocês?

Muitos leitores perguntam como usar o RichFaces para trabalhar com o framework JavaServer Faces 1.2.

Este artigo ensina como configurar o RichFaces em sua aplicação JSF, criando um pequeno exemplo, já conhecido na Internet, para demonstrar seu funcionamento.

O RichFaces

O RichFaces é um conjunto de componentes JSF ricos que estendem ou adicionam novos ao JSF padrão.

Sem necessitar de uma linha sequer de JavaScript, o RichFaces fornece componentes que possibilitam utilizar suas páginas sem que haja um reload padrão (quando submetemos uma página ou formulário ao servidor), o que chamamos de AJAX (Asynchronous JavaScript And XML).

Os componentes RichFaces são divididos em duas bibliotecas de tags: a RichFaces, que fornece temas (skin) e Ajax4jsf Component Development Kit (CDK).

Obtendo e instalando o Eclipse IDE

Para desenvolver aplicações Web usando a plataforma Eclipse, primeiramente você deverá ter o Eclipse em um ambiente voltado para o desenvolvimento Java EE. Para obter o Eclipse IDE, já configurado com o ambiente Web, vá ao endereço http://www.eclipse.org/downloads/ e selecione o link Eclipse IDE for Java EE Developers.

Ao baixar, descompacte em um local desejado de sua máquina.

O plug-in JBoss Tools

Após a descompactação do Eclipse, execute-o para que possamos baixar o plug-in JBoss Tools, que auxiliará no desenvolvimento da aplicação. No Eclipse, vá ao menu Help>Install New Software. Digite o endereço http://download.jboss.org/jbosstools/updates/stable/galileo/ em Work with e clique no botão Add. Digite JBoss Tools em Name, no diálogo que surgiu e confirme no botão OK.

Prossiga no assistente até baixar e instalar o plugin. Reinicie o Eclipse IDE no final da instalação.

Baixando o RichFaces

Todas as bibliotecas serão utilizadas como no projeto original, menos a do Apache Trinidad que será substituída.

Para baixar as bibliotecas do RichFaces, clique aqui.

A versão utilizada neste tutorial é a RichFaces 3.3.3. Entretanto, versões mais recentes poderão ser usadas, desde que compatíveis com o framework JSF 1.2.

Baixe a versão Stable Builds, por ser considerada a estável para produção.

Figura 1 – Página de download do RichFaces

O Servidor Java

Para este artigo, vamos utilizar o Tomcat 6.0.x.

As bibliotecas

Para trabalhar com o JavaServer Faces, primeiramente será preciso configurar os arquivos e a estrutura necessária.

Alguns servidores, assim como o contêiner Servlet Tomcat 6, por padrão, não possuem suporte direto ao JavaServer Faces, ou seja, não contém as bibliotecas necessárias para o desenvolvimento com o mesmo.

Caso queira

Para baixar o JSF, faça download no endereço https://javaserverfaces.dev.java.net/, ou diretamente, clicando aqui. Ao baixar o arquivo, simplesmente desempacote em um diretório de sua escolha.

JavaServer Faces rodando em seu aplicativo Web

Para ter o JavaServer Faces 1.2 em sua aplicação, você possui dois arquivos do tipo JAR:

jsf-api.jar
jsf-impl.jar

As bibliotecas JSTL

Adicionadas por padrão pelo JBoss Tools, quando criado um projeto, com dois arquivos JARs:

jstl.jar
standard.jar

Os arquivos JSTL estão no endereço http://www.apache.org/dist/jakarta/taglibs/standard/binaries/, caso tenha interesse em saber onde encontrar.

Para torná-los disponíveis em sua aplicação é simples, basta colocar esses arquivos listados no diretório lib, encontrado em WEB-INF de sua aplicação Web.

Porém, como vamos utilizar um ambiente de trabalho baseado no Eclipse IDE, será mais fácil essa configuração.

As bibliotecas RichFaces

Ao baixar e descompactar, dentro do diretório lib, encontrado na descompactação, temos estes três arquivos:

richfaces-api-3.3.3.Final.jar
richfaces-impl-3.3.3.Final.jar
richfaces-ui-3.3.3.Final.jar

Criando o projeto

Crie um novo projeto indo ao menu File>New>Project. Na caixa de diálogo New, selecione JBoss Tools Web>JSF>JSF Project. Clique no botão Next.

Figura 2 – Diálogo New Project com JSF Project selecionado

Na segunda etapa, digite o nome do projeto, em Project Name e continue com Next.

Figura 3 – Segunda etapa com o nome do projeto

Na terceira etapa, selecione em New o servidor de aplicações Java que vamos utilizar. No caso, selecionaremos o Tomcat.

Figura 4 – Selecionando um novo servidor para rodar a aplicação

Figura 5 – Seleção do Apache Tomcat 6.0

Na configuração do servidor de aplicativos Apache Tomcat, caso você não tenha ainda baixado e instalado, pode clicar no botão Download and Install. Termine o diálogo clicando no botão Finish.

Figura 6 – Local da instalação do Apache Tomcat

Termine o projeto, agora que já possuímos o Tomcat configurado, clicando no botão Finish.

Figura 7 – Servidor Tomcat configurado no projeto

Como estamos usando o JBoss Tools, na finalização do projeto, o Eclipse lançará uma mensagem perguntando se desejamos mudar de perspectiva. Diga que sim, clicando em Yes.

Figura 8 – Pedido de alteração de perspectiva

O Eclipse alterará de perspectiva, colocando na Web Development, onde temos outras views na lateral esquerda.

Observe na view Package Explorer o projeto com seus arquivos e bibliotecas adicionadas.

Figura 9 – Projeto criado

Observação: Um detalhe importante neste formato de projeto é que, diferente de uma aplicação Web criada pelo plugin WTP do Eclipse, é que as bibliotecas no plugin JBoss Tools ficarão em lib.

Importando as bibliotecas

Vamos agora importar as bibliotecas do projeto. Clique com o direito do mouse sobre o diretório lib, na view Package Explorer e selecione, no menu de contexto, o item Import.

Figura 10 – Seleção do Import no menu de contexto

Na caixa de diálogo Import, selecione General>File System e clique no botão Next.

File System selecionado" width="300" height="220" />

Figura 11 – Caixa de diálogo Import com General>File System selecionado

Na segunda etapa da importação, selecione no botão Browse o local onde se encontram os arquivos do RichFaces (as bibliotecas). Selecione somente as listadas anteriormente neste artigo e confirme no botão Finish.

Figura 12 – Selecionando as bibliotecas do RichFaces para importação no diretório lib

Repita o mesmo processo, importando novos arquivos para o diretório lib do projeto, só que desta vez, adicionando as bibliotecas do JavaServer Faces 1.2.

Figura 13 – Seleção das bibliotecas JSF para importação no diretório lib

No final, veremos as bibliotecas importadas no projeto, junto as existentes desde sua criação, como mostra a Figura 14.

Figura 14 – Bibliotecas existentes no projeto

Configurando o RichFaces no deployment descriptor

No arquivo web.xml adicione as configurações necessárias para termos o JBoss RichFaces, como mostra a Listagem 1 a seguir:

Listagem 1 – O arquivo web.xml com o RichFaces configurado





ProjUtilizandoRichFaces





org.richfaces.SKIN

blueSky





RichFaces Filter

richfaces

org.ajax4jsf.Filter





richfaces

Faces Servlet

REQUEST

FORWARD

INCLUDE





com.sun.faces.config.ConfigureListener







Faces Servlet

javax.faces.webapp.FacesServlet

1







Faces Servlet

*.jsf





BASIC

O RichFaces possui um template padrão para seus componentes. A configuração deste template é feita no web.xml, através dos seguintes elementos:


org.richfaces.SKIN
blueSky

Os temas existentes até o momento são:

DEFAULT
plain
emeraldTown
blueSky
wine
japanCherry
ruby
classic
deepMarine
NULL
laguna
darkX
glassX

Para funcionar os componentes RichFaces e Ajax4fjsf, incluímos o filtro org.ajax4jsf.Filter, com os seguintes elementos:


RichFaces Filter
richfaces
org.ajax4jsf.Filter


richfaces
Faces Servlet
REQUEST
FORWARD
INCLUDE

Criando o JavaBean Texto

Com o direito do mouse sobre o projeto, selecione New>Class no menu de contexto.

Na caixa de diálogo New Java Class, preencha o pacote (br.com.integrator) e o nome da classe, no caso Texto, em Name. Confirme no botão Finish.

Figura 15 – A classe Texto

Altere a classe Texto conforme mostrado na Listagem 2.

Listagem 2 – O JavaBean Texto

package br.com.integrator;

public class Texto {

private String texto;

public String getTexto() {
return texto;
}

public void setTexto(String texto) {
this.texto = texto;
}
}

Configurando o Managed Bean

Abra o arquivo faces-config.xml, e clique na aba inferior Tree. Em Faces Config Editor, clique no item Managed Beans. Na lateral direita, clique em Add, como mostra a Figura 16.

Figura 16 – Configurando um Managed Bean no arquivo faces-config.xml

Na caixa de diálogo New Managed Bean, mantenha Scope como request. Em Class, clique em Browse e selecione a classe br.com.integrator.Texto. Digite o nome, em Name, do Managed Bean de textoBean. Confirme em Finish.

Figura 17 – Configurando o Managed Bean textoBean

Se clicarmos em Source, veremos que a ferramenta configurou visualmente o XML de faces-config.xml como na Listagem 3.

Listagem 3 – O managed bean textoBean adicionado ao faces-config.xml





textoBean
br.com.integrator.Texto
request

Figura 18 – O arquivo faces-config.xml com o managed bean textoBean configurado

Criando a página JSF com suporte ao RichFaces

Mude agora para a view Web Projects, que está ao lado de Package Explorer.

Figura 19 – A view Web Projects

Com o direito do mouse sobre WebContent, vá no menu de contexto em New>File>JSP. No diálogo New File JSP, dê o nome no arquivo de richfaces, selecione JSFBasePage em Template e prossiga no assistente, clicando em Next.

Figura 20 – Criando uma página JSF

Na última etapa de criação da página, marque as tag libraries: JBoss Ajax4jsf, JBoss RichFaces, JSF Core e JSF HTML. Finalize no botão Finish.

Figura 21 – Seleção das taglibs da página

Com a página richfaces.jsp criada e aberta no editor, altere-a deixando exatamente como mostrado na Listagem 4 a seguir:

Listagem 4 – A página richfaces.jsp completa

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich" %>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j" %>


Minha Primeira Página com JBoss RichFaces





Digite seu texto aqui:





Resultado:

Figura 22 – Página richfaces.jsp no editor visual e de códigos do JBoss Tools

Observe que o editor de códigos do JBoss Tools deverá reconhecer o Managed Bean.

Figura 23 – Reconhecimento do Managed Bean pelo editor de códigos

Por fim, execute a página indo ao meu Run> Run As>Run on Server. Na caixa de diálogo, deixe o Tomcat como escolha para executar o projeto e clique no botão Next.

Figura 24 – Selecionando o servidor Java para executar o projeto

Adicione em Configured o projeto e clique no botão Finish. Neste momento o Apache Tomcat iniciará, executando a página JSF contendo o AJAX do RichFaces.

Figura 25 – Finalizando o assistente para executar o projeto no Apache Tomcat

O aplicativo é de simples compreensão. Simplesmente o texto digitado no campo de texto é enviado ao servidor, levado ao Managed Bean textoBean, representado pela classe Texto, cujo é retornado ao label abaixo, em Resultado. Em uma página JSF comum, teríamos que submeter a página para termos tal resultado. Como estamos usando AJAX, o texto vai sendo digitado e enviado a cada nova letra para o servidor e retornada a página sem um reload no browser.

Figura 26 – A página executada

Este envio ao servidor sem reload na página e o retorno é feito graças ao Ajax4jsf, pela tag :

“texto” value=”#{textoBean.texto}”>

Esta tag trabalha com o evento JavaScript onkeyup, que chama o servidor e renderiza o resultado onde o atributo reRender estiver apontando. Observe que esta tag está dentro da tag JSF , que é exatamente onde ela trabalhará para receber o evento e se comunicar com o servidor, transmitindo as informações nela contidas.

No próximo artigo

No próximo artigo sobre RichFaces, vamos ver como trabalhar com Upload de arquivos, cuja dúvida é muito comum nesta biblioteca.

Até o próximo artigo pessoALL.

OFF-TOPIC: Livro do Camilo Lopes sobre Certificação Java

Edson Gonçalves — Wed, 05 May 2010 19:02:42 +0000

Pessoal, embora eu queira manter o blog com assuntos técnicos pertinentes ao ensino de desenvolvimento de aplicativos, não poderia deixar de postar sobre o lançamento do primeiro livro de um grande amigo.

O Camilo Lopes, nesta terça-feira, teve seu livro Guia do Exame SCJP – Sun Certified Java Programmer lançado. Sei o quanto ele se esforçou para trazer um guia, fácil e rápido, com questões e respostas sobre a Certificação Java considerada a base para as demais.

Guia do Exame SCJP - Sun Certified Java Programmer

O lançamento é pela Editora Ciência Moderna, que publicou a maioria dos meus livros até o momento.

Aqueles que estiverem interessados na certificação, agora podem adquirir mais um livro que os auxilie nesta jornada.

Para detalhes do livro, preço e desconto, aqui vai o link para o livro na Editora Ciência Moderna:

http://www.lcm.com.br/index.php?Escolha=20&Livro=L00852

Bons Estudos!

Edson Gonçalves

O que estou fazendo no momento

Novo Livro do Camilo Lopes

Gerando relatórios JasperReports na Web com Fontes embebidas

Para acompanhar este artigo

Trabalhando com fontes personalizadas no relatório

Adicionando a fonte ao aplicativo

Adicionando e exportando a fonte no iReport

A fonte como uma biblioteca no seu aplicativo Web pelo Eclipse IDE

A fonte como uma biblioteca no seu aplicativo Web pelo NetBeans IDE

Antes e depois da fonte adicionada ao projeto

O projeto para download

Spring MVC 3 na Prática com Bean Validation

Alterando o CRUD criado com o Spring MVC

Adicionando as bibliotecas ao projeto utilizando o Maven

Criando a propriedade

Criando a dependência

Alterando a entidade Contato

Alterando o controlador

Alterando as views

O formulário de cadastro

Alterando a página de atualização de dados

O projeto para download

Considerações finais

Spring MVC 3 na Prática com JPA 2

O Servidor Java

O banco de dados

Preparando o banco de dados do exemplo

O ambiente de trabalho

Criando o projeto

Alterando o projeto base gerado pelo assistente

Adicionando outras bibliotecas ao projeto utilizando o Maven

Adicionando um repositório

Criando propriedades

Criando as dependências

Um CRUD com Spring MVC utilizando JPA 2.0

A entidade Contato

Acessando os dados

Controlando como o aplicativo funciona

A configuração do web.xml

O arquivo persistence.xml

Configurando o Spring

Configurando o Spring MVC

As views

O formulário de cadastro

A página que lista todos os cadastros e permite a exclusão

A página de atualização de dados

As páginas que não fazem parte do CRUD

Contato

O projeto para download

Considerações finais

No próximo artigo

Guia de Certificação SCJP

﻿A Certificação SCJP

Aonde eu quero chegar?

O Guia

Simulado Gratuito

Onde adquirir o livro?

O Autor

Hibernate com Hibernate Tools

Obtendo e instalando o Eclipse IDE

O plugin JBoss Tools

O banco de dados

Criando o projeto

As bibliotecas

Criando o JavaBean Categoria

Mapeando a tabela no Hibernate utilizando a forma tradicional

Configurando o Hibernate

Algumas características do Hibernate Tools

Colocando o Hibernate para trabalhar

O Editor HQL e Criteria

Engenharia Reversa

Ajax com JSF 2.0

Obtendo e instalando o Eclipse IDE

O Servidor Java

As bibliotecas

JavaServer Faces rodando em seu aplicativo Web

As bibliotecas JSTL

Criando o projeto

O deployment descriptor

A Certificação SCJP