out 24 2010

Spring MVC 3 na Prática com Bean Validation

Category: Spring,Spring MVC 3.0Edson Gonçalves @ 20:56

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 <mvc:annotation-driven />. 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  <form:errors />.

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" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <style type="text/css" media="screen">
 @import url("<c:url value="/static/styles/style.css"/>");
 </style>
<title>Cadastrar</title>

</head>
<body>
 <div id="wrap">

 <div id="menu">
 <%@ include file="/menu.jsp" %>
 </div>
 <div id="main">
 <div id="body">
 <c:url var="url" value="/contato" />
 <form:form action="${url}" method="POST" modelAttribute="contato">
 <div>
 <label for="nome">Nome:</label>
 <form:errors path="nome" cssClass="errors"/><br />
 <form:input cssStyle="width:250px" maxlength="30" path="nome" size="30"/>

 </div>
 <br/>
 <div>
 <label for="email">Email:</label>
 <form:errors path="email" cssClass="errors"/><br />
 <form:input cssStyle="width:250px" maxlength="30" path="email" size="30"/>

 </div>
 <br/>
 <div>
 <label for="telefone">Telefone:</label>
 <form:errors path="telefone" cssClass="errors"/><br />
 <form:input cssStyle="width:250px" maxlength="30" path="telefone" size="20"/>
</div>
 <br/><div>
 <input id="criar" type="submit" value="Criar Contato"/>
 </div>
 </form:form>
 </div>
 </div>
 </div>
</body>
</html>
A tag  <form:errors /> 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

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 <form:errors />. 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" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <style type="text/css" media="screen">
 @import url("<c:url value="/static/styles/style.css"/>");
 </style>
<title>Atualizar</title>
</head>
<body>
 <div id="wrap">
 <div id="menu">
 <%@ include file="/menu.jsp" %>
 </div>
 <div id="main">
 <div id="body">
 <c:url var="url" value="/contato/${contato.id}" />
 <form:form action="${url}" method="PUT" modelAttribute="contato">
 <div>
 <label for="nome">Nome:</label>
 <form:errors path="nome" cssClass="errors"/><br />
 <form:input cssStyle="width:250px" maxlength="30" path="nome" size="30"/>
 </div>
 <br/>
 <div>
 <label for="email">Email:</label>
 <form:errors path="email" cssClass="errors"/><br />
 <form:input cssStyle="width:250px" maxlength="30" path="email" size="30"/>
 </div>
 <br/>
 <div>
 <label for="telefone">Telefone:</label>
 <form:errors path="telefone" cssClass="errors"/><br />
 <form:input cssStyle="width:250px" maxlength="30" path="telefone" size="20"/>
 </div>
 <br/>
 <div>
 <input id="atualizar" type="submit" value="Atualizar Contato"/>
 </div>
 <form:hidden path="id"/>
 </form:form>
 </div>
 </div>
 </div>
</body>
</html>

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.

Tags: , , , , , , , ,


jun 27 2010

Hibernate com Hibernate Tools

Category: HibernateEdson Gonçalves @ 1:30

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.

Figure 1 – Alterando a Perspectiva

Figura 1 – Alterando a Perspectiva

Selecionem em seguida a Perspectiva Hibernate.

Figure 2 – Seleção da 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.

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

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.

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

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.

Figure 5 – Criação de um projeto Java

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.

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

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.

Figure 7 – Bibliotecas do projeto

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.

Figure 8 – Criando a classe Categoria

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).

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

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.

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

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.

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

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.

Figure 12 – Arquivo XML do mapeamento que será criado

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.

Figure 13 – Editor do XML gerado para Hibernate

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

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!-- Generated 24/06/2010 05:07:14 by Hibernate Tools 3.3.0.GA -->

<hibernate-mapping>

<class name="br.com.integrator.Categoria" table="categoria">

<id name="id" type="java.lang.Long">

<column name="id"/>

<generator class="increment"/>

</id>

<property generated="never" lazy="false" name="categoria" type="java.lang.String">

<column name="categoria" length="50"/>

</property>

<property generated="never" lazy="false" name="descricao" type="java.lang.String">

<column name="descricao"/>

</property>

</class>

</hibernate-mapping>

Configurando o Hibernate

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

Figure 14 – Criação do arquivo hibernate.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.

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

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.

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

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.

Figure 17 – Configuração do console Hibernate

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.

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

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.

Figure 19 – 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

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

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

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>

<property name="hibernate.connection.password">integrator</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernatenapratica</property>

<property name="hibernate.connection.username">edson</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

<property name="hibernate.show_sql">true</property>

<property name="hibernate.use_sql_comments">true</property>

<property name="hibernate.format_sql">true</property>

<property name="hibernate.hbm2ddl.auto">create-drop</property>

<mapping resource="br/com/integrator/Categoria.hbm.xml"/>

</session-factory>

</hibernate-configuration>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-reverse-engineering PUBLIC "-//Hibernate/Hibernate Reverse Engineering DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-reverse-engineering-3.0.dtd" >

<hibernate-reverse-engineering>

<type-mapping>

<sql-type jdbc-type="BIGINT" hibernate-type="long"

not-null="true">

</sql-type>

<sql-type jdbc-type="VARCHAR" hibernate-type="string" length="50"

not-null="false">

</sql-type>

<sql-type jdbc-type="VARCHAR" hibernate-type="string"

not-null="false">

</sql-type>

</type-mapping>

<table-filter match-catalog="hibernatenapratica" match-name="categoria"/>

</hibernate-reverse-engineering>

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

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

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

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

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

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

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

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

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

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

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.

Tags: , , , ,


abr 25 2010

Segurança passo a passo com Spring Security 3.0

Category: SpringEdson Gonçalves @ 6:48

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

Este artigo é o primeiro de uma série que falaremos sobre segurança em aplicações Java, começando com a primeira parte do artigo sobre Spring Security.  Dúvidas e críticas são bem vindas.

Segurança de dados através do Spring Security

A segurança de áreas restritas em aplicações Web escritas em Java não é uma tarefa das mais triviais.

Sabendo que não era simples criar áreas de segurança, em 2003 surge o Acegi Security System for Spring, um framework extremamente configurável  e complexo. Comum na época, suas configurações eram baseadas em XML e demorava um tempo para que o desenvolvedor o dominasse completamente.

O projeto Acegi evoluiu e, em 2007, foi incorporado aos projetos do Spring Framework, sendo renomeado para Spring Security.

A versão 2.0 foi lançada em 2008 e em 2010 a versão 3.0, a que iremos utilizar neste artigo.

Download do Framework

Para trabalhar com o Spring Security, você deve realizar o download no endereço http://www.springsource.org/download. No momento em que este artigo é escrito, a versão utilizada é a Spring Security 3.0.2. Clique em Download.

Figura 1 – Local de download do Spring Security 3.0.2

Figura 1 – Local de download do Spring Security 3.0.2

Baixe a versão spring-security-3.0.2.RELEASE.zip. Ao baixar, descompacte o arquivo extraindo todos os JARs existentes no diretório lib.

Figura 2 – Download do Spring Security

Figura 2 – Download do Spring Security

Também será preciso baixar o Spring Framework. No momento em que este artigo é escrito, a versão utilizada é a Spring Framework 3.0.2.

Figura 3 – Download do Spring Framework

Figura 3 – Download do Spring Framework

Como o Spring Security trabalha

Da mesma forma que faríamos se estivéssemos utilizando JAAS, o Spring Security trabalha a segurança através de declarações baseadas em papéis (roles). Seja em XML ou Anotações, o Spring Security  não necessita chamar método algum para realizar uma autenticação ou autorização.

Através dos roles definidos, podemos informar ao aplicativo em questão, ao qual está sendo assegurada  uma área, quais recursos podem ser acessados ou restringidos a uma determinada pessoa que acessou a área restrita.

Preparando o ambiente de trabalho

Para este artigo, iremos utilizar a IDE da Spring Source, divisão da VMware,  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, use-a 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 um projeto

No SpringSource Tools Suite, clique no menu File>New>Dynamic Web Project. Na caixa de diálogo New Dynamic Web Project, digite ProjSpringSecurity (ou o nome que desejar) em Project name.

O SpringSource Tools Suite possui embutido um servidor de aplicações Java Web baseado no Apache Tomcat 6, só que com algumas modificações. Entretanto, vamos utilizar o Tomcat, que pode ser adicionado como mostro neste artigo.

Confirme a criação do projeto no botão Finish.

Adicionando as bibliotecas ao Projeto

Com o direito do mouse sobre o projeto, na view Project Explorer, vá até Properties. Na  caixa de diálogo das propriedades do projeto, vá até Java EE Module Dependencies. Clique em Add External JARs e adicione os seguintes arquivos:

  1. org.springframework.aop-3.0.2.RELEASE.jar
  2. org.springframework.asm-3.0.2.RELEASE.jar
  3. org.springframework.beans-3.0.2.RELEASE.jar
  4. org.springframework.context-3.0.2.RELEASE.jar
  5. org.springframework.core-3.0.2.RELEASE.jar
  6. org.springframework.expression-3.0.2.RELEASE.jar
  7. org.springframework.transaction-3.0.2.RELEASE.jar
  8. org.springframework.web-3.0.2.RELEASE.jar
  9. spring-security-config-3.0.2.RELEASE.jar
  10. spring-security-core-3.0.2.RELEASE.jar
  11. spring-security-taglibs-3.0.2.RELEASE.jar
  12. spring-security-web-3.0.2.RELEASE.jar
  13. commons-logging-1.1.1.jar

Note que o 13º item é um JAR que não pertence a família do Spring Framework. Você pode baixar o arquivo compactado, contendo a biblioteca commons-logging-1.1.1.jar, clicando aqui.

Figura 4 – Arquivos JARs adicionados ao projeto

Figura 4 – Arquivos JARs adicionados ao projeto

Uma aplicação simples com Spring Security

Para exemplificar como funciona o Spring Security, vamos criar uma aplicação simples com apenas uma área segura. Esta área segura será representada dentro de um diretório, chamado admin.

Teremos duas páginas index.jsp: uma na raiz do aplicativo e outra dentro do diretório admin, como mostra a Figura 5.

Figura 5 – As páginas do Projeto

Figura 5 – As páginas do Projeto

As páginas JSP

A página index.jsp, existente dentro do diretório admin exibe apenas uma mensagem simples, como mostra a Figura 6, com apenas HTML.

O conteúdo é mostrado na Listagem 1.

Figura 6 – Página index.jsp exibida após logar na área admin

Figura 6 – Página index.jsp exibida após logar na área admin

Listagem 1 – O conteúdo HTML da página /admin/index.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01

Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Usuário Logado</title>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

</head>

<body>

<h2>Parabéns, você está logado!</h2>

</body>

</html>

A página index.jsp encontrada na raiz exibe apenas um link que o leva até a área administrativa. Sua aparência é idêntica a Figura 7.

O conteúdo da página index.jsp encontrada na raiz da aplicação é mostrado na Listagem 2.

Figura 7 – Página index.jsp exibida quando acessada a aplicação

Figura 7 – Página index.jsp exibida quando acessada a aplicação

Listagem 2 – O conteúdo HTML da página /index.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Página Inicial</title>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

</head>

<body>

<h2>Uma aplicação simples com Spring Security</h2>

<hr />

<a href="admin">Clique aqui para acessar a área administrativa</a>

</body>

</html>

Configurando o web.xml

Para que o Spring Security, assim como o Spring, precisamos configurar o web.xml. O Spring Security utiliza um filtro HTTP para interceptar as URLs acessadas e verificar as permissões de acesso.

A Listagem 3 exibe a configuração do arquivo web.xml.

Listagem 3 – O arquivo web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

id="WebApp_ID" version="2.5">

<display-name>ProjSpringSecurity</display-name>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<filter>

<filter-name>springSecurityFilterChain</filter-name>

<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

</filter>

<filter-mapping>

<filter-name>springSecurityFilterChain</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

Para configurar o Spring Security, utilizamos o filtro org.springframework.web.filter.DelegatingFilterProxy, devidamente configurado na Listagem 3. O filtro está sendo aplicado em todo o aplicativo, podendo ser visto no elemento <url-pattern />.

Atenção: Um detalhe importante que precisa ser notado é o nome do filtro, colocado no elemento <filter-name/>.  Não o altere, pois o Spring já espera pelo nome springSecurityFilterChain.

Configurando o applicationContext.xml

O Spring Security será configurado no arquivo applicationContext.xml. Este arquivo deverá ser criado dentro do diretório WEB-INF, com o conteúdo mostrado na Listagem 4.

Listagem 4 – O arquivo applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans:beans xmlns="http://www.springframework.org/schema/security"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:beans="http://www.springframework.org/schema/beans"

xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.0.xsd">

<http auto-config="true">

<intercept-url pattern="/admin/**" access="ROLE_ADMIN" />

</http>

<authentication-manager>

<authentication-provider>

<user-service>

<user name="edson" password="integrator" authorities="ROLE_ADMIN" />

</user-service>

</authentication-provider>

</authentication-manager>

</beans:beans>

No Spring Security, as configurações de autenticação e autorização estão sendo feitas no arquivo de contexto padrão do Spring (applicationContext.xml). Para que este arquivo seja lido, adicionamos no web.xml o elemento <listener />, contendo o listener org.springframework.web.context.ContextLoaderListener.

O listener do Spring faz com que as configurações sejam carregadas na inicialização da aplicação Web.

Ao ser carregado pelo listener, o arquivo da Listagem 4 declara os usuários e suas regras de acesso ao aplicativo.

O controle de acesso é feito pelo elemento <http />, do applicationContext.xml. Este controle é definido no sub-elemento <intercept-url />. O atributo pattern, de <intercept-url />, informa, através de uma expressão, em qual local o filtro deve agir, bem como define a sua regra de acesso, através do atributo access.

Para que possamos definir que qualquer elemento dentro do diretório admin fique acessível somente para os usuários do role ROLE_ADMIN, adicionamos uma expressão comum no Apache Ant.

Caso tenhamos mais de um sub-elemento <intercept-url />, teremos sua interpretação sendo feita por ordem de definição, sendo que, a primeira que atender a regra, será chamada. Na prática, isto significa que, se houver /admin/relatorios/** e /admin/**, o primeiro caso deverá ser lido primeiro, portanto será o primeiro a ser adicionado na ordem em  applicationContext.xml.

O atributo auto-config, com o valor true, indica a configuração automática da aplicação para utilizar um formulário de login. O JSP do formulário é gerado automaticamente pelo Spring Security neste caso. A Figura 8 exibe o formulário gerado pelo Spring Security.

Figura 8 – Formulário de login gerado automaticamente pelo Spring Security

Figura 8 – Formulário de login gerado automaticamente pelo Spring Security

Com o atributo <authentication-manager>, gerenciamos os usuários e seus respectivos roles  que darão permissão ao diretório especificado anteriormente, em <intercept-url />, pelo filtro.

Para facilitar a compreensão do exemplo, adicionamos apenas um usuário, através de <user/>, informando o nome de usuário, a senha e o seu papel de acesso.

Ao logar no aplicativo, o Spring analisará qual role é permitido no diretório e quem possui  tal permissão.

Personalizando o formulário de acesso a área restrita

É interessante ter uma geração automática de formulário no Spring Security, ajuda a testar a codificação, com certeza. Mas não é agradável ao aplicativo como um todo, pois sempre precisamos criar o formulário com as características gerais desenvolvidas no layout das páginas.

Criando a página personalizada de login

Para isso, o Spring Security nos fornece a personalização do formulário.  A Listagem 5 exibe o conteúdo da página /login.jsp que ficará na raiz do seu aplicativo, junto com index.jsp.

Listagem 5 – A página login.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

<title>Área Restrita</title>

</head>

<body>

<h2>Área Restrita</h2>

<hr />

<%

if(request.getParameter("error") != null){

if (request.getParameter("error").equals("invalido")){

%>

<p>

<span style="color:red">

Usuário ou Senha inválidos

</span>

</p>

<%

} //fim do if equals

}//fim do if null

%>

<form action="j_spring_security_check" method="post">

Usuário: <input name="j_username" type="text" value="${not empty login_error ? SPRING_SECURITY_LAST_USERNAME : ''}" />

<br />

Senha: <input type="password" name="j_password"><br />

<input type="submit" value="Efetuar Login"><br />

<a href="index.jsp">Retornar para a Página Inicial</a>

</form>

</body>

</html>

Para que o formulário funcione com o Spring Security, as regras mais básicas são:

  • O atributo action deve apontar para j_spring_security_check;
  • O atributo name da caixa de entrada de  texto, do nome de usuário, deve ser j_username;
  • O atributo name da caixa de entrada de senha deve ser j_ password.

Estes princípios básicos farão com que seu formulário funcione com o Spring Security. Entretanto, precisamos mostrar uma mensagem de erro, caso o usuário não tenha colocado as informações necessárias ou, as mesmas não sejam compatíveis com o registrado no sistema para permitir a entrada na área restrita.

É exatamente o papel do if(request.getParameter(“error”) e if (request.getParameter(“error”).equals(“invalido”)),  na página login.jsp, personalizado, com um parâmetro que iremos transmitir, através do Spring Security, caso ocorra um erro na permissão.

A página personalizada pode ser vista na Figura 9.

Figura 9 – Formulário de acesso a área restrita personalizado

Figura 9 – Formulário de acesso a área restrita personalizado

Alterando o arquivo applicationContext.xml

Por fim, mas não menos importante, precisamos alterar o arquivo applicationContext.xml para que o Spring Security passe a trabalhar com a página de login personalizada que criamos. A seguir você tem o trecho, contendo o elemento <form-login/>, que deve ser inserido por entre o elemento <http />:

<form-login login-page=“/login.jsp” authentication-failure-url=“/login.jsp?error=invalido”/>

O elemento <form-login/> é de simples compreensão, pois temos atributos que descrevem bem sua função:

login-page: A página personalizada com o formulário de substituição do padrão existente no framework

authentication-failure-url: URL de retorno caso ocorra um erro. Note que adicionamos,  após “?” , error=invalido. Isto demonstra, claramente, que não é uma regra fixa o que pode ser transmitido, caso ocorra um erro, na entrada de uma determinada área restrita.

Figura 10 – Resultado final do projeto com todos os arquivos criados

Figura 10 – Resultado final do projeto com todos os arquivos criados

No próximo artigo sobre Spring Security

Embora tenhamos conhecido os elementos básicos de utilização do Spring Security, restou colocar o acesso ao banco de dados para fazer uma autenticação verdadeira, como ocorre em sistemas.

No próximo artigo veremos como fazer para trabalhar com Spring Security e o acesso ao banco de dados, com um exemplo completo, passo a passo.

Até o próximo artigo pessoALL.

Tags: , , , , , , ,


abr 10 2010

JPA 2.0 na Prática – Parte 3

Category: JPA 2.0Edson Gonçalves @ 6:48

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

Este artigo é o terceiro de uma série ao qual vou ensiná-los a trabalhar com a Java Persistence API 2.0 (JPA 2.0).  Dúvidas e críticas são bem vindas.

Conhecendo as anotações básicas em uma Entidade

Como pudemos perceber no artigo  JPA 2.0 na Prática – Parte 2, as entidades representam as tabelas encontradas no banco de dados. Entretanto, nem sempre refletirão exatamente o modelo da entidade relacional encontrado no banco de dados mas, com certeza, são suas representações, só que em formato de objetos – o que chamamos de O/R (Object-to-Relational).

Anotando uma classe simples

Entidades são classes Java Simples (POJOs) na JPA.  Ao fazer a Entidade Bean Categoria, em JPA 2.0 na Prática – Parte 2, adicionamos anotações que representavam certas características que deveriam ser refletidas na entidade relacional, como nome da tabela e o campo de chave primária.

A entidade Categoria é simples e possui atributos privados que  são refletidos, tais como escritos na entidade, em seu equivalente, na tabela da entidade relacional.

A classe Categoria também é formada por métodos públicos getters e setters, tais como são os JavaBeans comuns.

Para que uma classe, como no caso da Categoria criada, não seja considerada um simples JavaBean e sim uma Entidade Bean da Java Persistence, precisamos de duas anotações básicas:

javax.persistence.Entity Informa que classe é uma Entidade;

javax.persistence.Id – Informa o atributo na classe que será utilizado como chave primária;

Na ausência das demais anotações, o nome da tabela e das colunas existentes na entidade relacional, do banco de dados, são tidos pelo provedor de persistência como sendo exatamente iguais aos encontrados na Entidade Bean.

Desta forma, se mapearmos uma entidade bean como na Listagem 1, teremos uma tabela no banco de dados, procurada ou criada pelo provedor de persistência similar ao da Listagem 2.

Listagem 1 – Entidade Bean Categoria



package br.com.integrator;

import java.io.Serializable;

import java.lang.*;

import javax.persistence.*;

@Entity

public class Categoria implements Serializable {

@Id

private Long id;

private String categoria;

private String descricao;

//getters e setters omitidos

}

Listagem 2 – A tabela Categoria no banco de dados MySQL

create table Categoria(

id bigint(20) primary key not null,

categoria varchar(255),

descricao varchar(255)

);

Anotações @Table, @Column e @Id

Se necessitarmos definir o nome de uma tabela, como foi feito em JPA 2.0 na Prática – Parte 2, utilizamos a notação @Table, de javax.persistence.Table. O mesmo também pode ser feito para dar nomes a colunas, utilizando a anotação @Column, de javax.persistence.Column. Desta forma, se fizermos a modificação na classe Categoria, como na Listagem 3, teremos o resultado mostrado na Figura 1.

Listagem 3 – Utilizando as anotações @Table e @Column

@Entity

@Table(name="categorias")

public class Categoria implements Serializable {

@Id

@Column(name="categoria_id", nullable=false, columnDefinition="integer")

private Long id;

@Column(name="categoria_nome", length=30, nullable=false)

private String categoria;

@Column(columnDefinition="text")

private String descricao;

//getters e setters omitidos

}
Figura 1 – Anotações da Entidade Categoria refletida na tabela categorias no banco de dados

Figura 1 – Anotações da Entidade Categoria refletida na tabela categorias no banco de dados

A Listagem 3 exibe os atributos contidos na anotação @Column, que são úteis no mapeamento de uma tabela equivalente no banco de dados. Temos os seguintes atributos utilizados no exemplo:

name – Nome da coluna na tabela do banco de dados, recebe como valor uma String;

columnDefinition – Recebe uma String com o tipo que será usado pela coluna equivalente na tabela do banco de dados. Um exemplo é a coluna descricao que possui columnDefinition como text.

length – Alguns tipos de colunas nas tabelas dos bancos de dados possuem um valor variável de largura do campo. Um exemplo são os campos varchar(). No MySQL, se não definirmos um valor de largura para o tipo varchar, este é criado em seu tamanho máximo de caracteres, que no caso é 255. Cada banco de dados possui um limite máximo em seu determinado tipo.

nullable – Recebe um valor booleano cujo o padrão é true, caso não declarado. Se false,  este campo é obrigatório.

A anotação @Id, mostrada pela primeira vez em JPA 2.0 na Prática – Parte 2, possui  uma anotação dependente, chamada de @javax.persistence.GeneratedValue.  Esta anotação é utilizada quando desejamos que o provedor de persistência gere as chaves para nós.

A anotação @GeneratedValue possui um atributo chamado strategy, que define a estratégia de geração de valores incrementados. A estratégia mais comum é javax.persistence.GeneratorType.AUTO, mas no exemplo visto na parte 2 dos artigos sobre JPA, utilizamos javax.persistence.GeneratorType. IDENTITY.

Entretanto, alguns gerenciadores de banco de dados, como Oracle, possuem uma estrutura predefinida para gerar valores seqüenciais. Nestes casos, utilizamos a anotação @javax.persistence.SequenceGenerator. A Listagem 4 exibe esta anotação utilizada em um banco de dados ORACLE.

Listagem 4 – Utilizando a anotação @SequenceGenerator

@Entity

@Table(name="CATEGORIAS_TABLE")

@SequenceGenerator(name="CATEGORIA_SEQUENCE", sequenceName="MINHA_SEQ", initialValue=1, allocationSize=1)

public class Categoria implements Serializable {

@Id

@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CATEGORIA_SEQUENCE")

private Long id;

@Column(length=30, nullable=false)

private String categoria;

@Column(length=3500)

private String descricao;

//getters e setters omitidos

}

A anotação @SequenceGenerator possui um atributo name do qual é referenciado em @GeneratedValue, através do atributo generator. A anotação @GeneratedValue também precisa utilizar, no atributo strategy, o valor GenerationType.SEQUENCE.

O nome da sequence gerada no Oracle, por exemplo, seria a colocada no atributo sequenceName, de @SequenceGenerator.

Também, em @SequenceGenerator temos os atributos initialValue e  allocationSize[1].  O resultado de uma sequence criada no banco de dados Oracle, com estas informações fornecidas pela entidade, através da JPA, pode ser vista na Figura 2.

Figura 2 – Sequencia gerada no Oracle XE e visualizada pelo Browser de Objetos

Figura 2 – Sequencia gerada no Oracle XE e visualizada pelo Browser de Objetos

Atenção: A forma como adicionamos a anotação @javax.persistence.Id na Entidade determina como podemos declarar as demais anotações no Bean. Se colocarmos a anotação @Id nos atributos, as demais precisam estar nos atributos. Se colocarmos no método getter, as demais precisarão estar nos métodos getters.

Na próxima parte

Na Parte 3 da série JPA 2.0 na Prática aprendemos as anotações básicas que podemos utilizar para criar uma entidade bean e tê-la refletida em uma tabela no banco de dados relacional.


[1] Sem o atributo allocationSize em 1, o Oracle, por exemplo, usando o Hibernate como provedor JPA, criará uma sequence com valor de 50 em 50.

Tags: , , , ,


Próxima página »