01 SpringFramework

Spring Framework
O Spring Framework uma soluo leve que permite a construo de aplicativos empresarias. Spring modular, isso permite o uso de apenas as partes necessrias, sem ter de implementar todos os mdulos do framework. Pode-se utilizar somente o mdulo IoC, com o Struts no topo, como tambm usar somente a integrao com o Hibernate ou a camada de abstrao JDBC. O Spring suporta o gerenciamento de transao declarativas, acesso remoto e lgica atravs do modelo RMI ou servios da Web, e vrias opes para a persistncia dos dados. Oferece uma completa estrutura MVC, e permite a integrao AOP transparente.
Verso 1.0
Apostila destinada ao curso com carga horria de 20 (vinte) horas
Curso Spring Framework
Sumrio
1. Spring Framework..................................................................................................................3 A viso geral do Spring Framework:......................................................................................3 Mdulos do Spring Framework..............................................................................................3 Exemplos de Aplicaes........................................................................................................5 2. Injeo de Dependncia ou IoC.............................................................................................6 3. Spring e Hibernate...............................................................................................................10 Introduo............................................................................................................................10 Amostra de Integrao.........................................................................................................10 1) Criao do banco de dados........................................................................................10 2) A classe Empregado....................................................................................................11 3) Criar o arquivo de mapeamento do Hibernate............................................................12 4) Criando o arquivo de configurao do Spring.............................................................13 5) Definir a classe EmpregadoDao..................................................................................14 6) Aplicativo cliente para teste.........................................................................................16 4. Spring e JPA.........................................................................................................................17 Spring como um Continer de JPA......................................................................................17 Definio das Entidades......................................................................................................18 Usando as Entidades JPA com o Spring.............................................................................18 Configurao da Camada de Persistncia..........................................................................20 Configurando o Contexto da Aplicao...............................................................................20 Configurando o Entity Manager Factory Bean.....................................................................21 Configurando o Vendor Adapter...........................................................................................22 Outras Configuraes..........................................................................................................22 Testes da Aplicao.............................................................................................................23 5. Gerenciamento de Transaes............................................................................................25 Propriedade das Transaes...............................................................................................25 Transaes Local versus Global..........................................................................................26 Programtica versus Declarativa.........................................................................................26 6. Spring Security.....................................................................................................................27 Segurana de uma aplicao..............................................................................................27 Protegendo a camada de servio........................................................................................28 7. Spring AOP...........................................................................................................................29 Conceitos.............................................................................................................................29 Hello World Spring AOP....................................................................................................30 Escrevendo nossa lgica de negcios............................................................................30
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
2 de 31
1. Spring Framework
A viso geral do Spring Framework:
Spring um padro formado em uma estrutura leve de aplicativos corporativos. Spring um framework aberto e criado para embarcar a complexidade do desenvolvimento de aplicaes corporativas. Uma das principais vantagens do Spring a sua arquitetura em camadas, permite que sejamos seletivos sobre quais de seus componentes que iremos utilizar para proporcionar um quadro coerente para o desenvolvimento de aplicaes J2EE. No entanto o Spring est limitado ao lado servidor do desenvolvimento. Qualquer aplicao Java pode se beneficiar em termos de simplicidade, testabilidade, e baixo acoplamento.
Mdulos do Spring Framework

O Spring possui uma arquitetura em camadas que consiste em sete mdulos bem definidos. Os mdulos mestres so construdos na parte superior do Core Container, que define como os beans sero criados, configurados e geridos, como mostrado na seguinte figura:
Cada um desses mdulos ou componentes consistem na estrutura do Spring e podem ser aplicados em conjunto com um ou mais mdulos ou componentes. Core Container: Proporciona a funcionalidade fundamental para o Spring. Neste, o componente primrio o mdulo BeanFactory, sendo uma implementao do padro de projeto Abstract Factory. O BeanFactory aplica a Inverso de Controle (IoC Inversion of Control ) padro para separar configurao de um aplicativo e especificao de dependncia do cdigo do
3 de 31
aplicativo real. Mdulo Contexto do Spring: um arquivo de configurao que fornece as informaes de contexto para o Spring. Inclui servios corporativos tais como e-mail, JNDI, EJB, internacionalizao, validao, programao de eventos do ciclo de vida de aplicaes. Tambm est includo o suporte para a integrao com templates como o Velocity. Mdulo Spring AOP: Permite que um componente de software implemente, atravs do padro de projeto decorator, um comportamento adicional, atravs do recurso de gerenciamento de configurao. Como resultado, possvel facilmente permitir AOP (Aspect Oriented Programming Programao Orientada a Aspecto) em qualquer objeto gerenciado pelo Spring. Este mdulo fornece servios de gerenciamento de transaes para os objetos em qualquer aplicao baseada em Spring. possvel incorporar o gerenciamento de transao declarativa em seus aplicativos, sem depender dos componentes EJB. Mdulo Spring DAO: Fornece uma camada de abstrao JDBC, que reduz a necessidade de fazer toda a codificao e anlise de banco de dados dos diferentes fornecedores e a transao dos cdigos de erro especficos. Alm disso, este mdulo fornece uma nova maneira de realizar em modo de programao, o gerenciamento das transaes declarativas, no apenas para as classes que implementam interfaces especiais, mas para qualquer dos objetos POJO (Plain Old Java Objects). Mdulo Spring ORM: Fornece a integrao com as ferramentas de mapeamento OR (Object Relational) como Hibernate, JDO e iBATIS. Suporta cada um dos frameworks ORM assim como JDBC. Mdulo Spring Web: Fornece os recursos bsicos para a integrao Web e constri neste mdulo um contexto de aplicao, fornecendo contextos de aplicativos baseados na Web. Como resultado, permite que o Spring suporte a integrao com o Struts. Este mdulo tambm facilita as tarefas de lidar com mltiplas partes para as requisies e parmetros de solicitao da ligao de objetos de domnio. Mdulo Spring framework MVC: Fornece uma arquitetura MVC (implementao do padro de projeto Model View Control) plugvel. Os usurios tm a opo de usar o framework Web ou continuar a usar o seu framework Web existente. O Spring separa as funes do controlador, o modelo de objeto, o despachante do objeto manipulador que torna mais fcil sua personalizao. O Spring no obriga a utilizao de codificao JSP para a camada de viso. O usurio possui a flexibilidade de utilizar JSP, modelos XSLT, Velocity, ou outros, para proporcionar a camada viso.
4 de 31
Exemplos de Aplicaes
Exemplos de como um desenvolvedor de aplicativos, pode usar as vantagens da plataforma Spring: Um mtodo Java para executar uma transao de banco de dados sem ter que lidar com as APIs de transao. Um mtodo Java local de um procedimento remoto sem ter que lidar com as APIs remotas. Um mtodo Java local para uma operao de gesto sem ter que lidar com APIs JMX. Um mtodo Java local, com um manipulador de mensagens sem ter que lidar com JMS API.
s vezes as circunstncias no permitem mudar completamente um quadro. O Spring no fora sua utilizao total, no uma soluo tudo ou nada. Existem diversos front-ends como o WebWork, Struts, Tapestry, ou outros frameworks que podem ser integrados com base na camada intermediria, que permite utilizar os recursos de transao do Spring. Precisamos simplesmente conectar a lgica de negcio usando um ApplicationContext e usar um WebApplicationContext para integrar a camada Web.
5 de 31
2. Injeo de Dependncia ou IoC

As aplicaes Java, podem executar sobre uma gama de applets restritas a aplicaes ncamadas do lado do servidor das empresas tipicamente consiste de objetos que colaboram para formar uma aplicao correta. Assim, os objetos em um aplicativo possuem dependncias entre si. Inverso de Controle est no corao do Spring. O conceito bsico da inverso do padro de controle (tambm conhecido como injeo de dependncia) que no criamos os objetos, apenas descrevemos como devem ser criados. No ligamos diretamente os componentes e servios em conjunto ao cdigo, mas descrevemos quais servios so necessrios para os componentes em um arquivo de configurao. O continer (no caso da estrutura do Spring, o mdulo IoC) o responsvel por ligar tudo. A maneira mais fcil de entender a inverso de controle v-la em um exemplo. Este exemplo bsico demonstra como possvel injetar as dependncias do aplicativo atravs do recipiente. um cdigo simples para desejar Ol e Adeus. Teremos duas interfaces HelloInterface e ByeInterface conforme listado abaixo: A. Classe Domnio: Name.java
package x25.com.tutorial.domain; public class Name { public String firstName; public String lastName; public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; }
B. Interface: HelloService.java
package x25.com.tutorial.service; import x25.com.tutorial.domain.Name; public interface HelloService { public String sayHello(Name name); }
6 de 31
C. Interface: ByeService.java
package x25.com.tutorial.service; import x25.com.tutorial.domain.Name; public interface ByeService { public String sayBye(Name name); }
Aps a implementao dessas interfaces, o prximo detalhe considerar como integr-los de forma flexvel. Observe que todos os mtodos padro SET sero implementados por um Bean de configurao do Spring. Todas as dependncias (isto , as duas interfaces) podem ser injetadas pela estrutura do Spring utilizando estes beans. Observe que o mtodo wishMe() utiliza os servios para implementar o restante da aplicao. O arquivo hello.xml e o arquivo de configurao do Spring. D. Classe: HelloBean.java
package x25.com.tutorial.bean; import import import import java.util.Calendar; x25.com.tutorial.domain.Name; x25.com.tutorial.service.ByeService; x25.com.tutorial.service.HelloService;
public class HelloBean { public Name name; public HelloService helloService; public ByeService byeService; // GETs e SETs public void setHelloService(HelloService helloService) { this.helloService = helloService; } public void setByeService(ByeService byeService) { this.byeService = byeService; } public Name getName() { return name; } public void setName(Name name) { this.name = name; } // Mtodos de Domnio public String wishMe(Name name) { Calendar calendar = Calendar.getInstance(); if (calendar.get(Calendar.HOUR_OF_DAY) < 12){ // Invoca o helloService return helloService.sayHello(name); } else { // Invoca o byeService
7 de 31
} } }
return byeService.sayBye(name);
E. Arquivo de Configurao: hello.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <beans> <bean id="helloBean" class="com.developersBook.springExample.bean.HelloBean"> <property name="helloService"> <ref bean="helloService" /> </property> <property name="byeService"> <ref bean="byeService" /> </property> </bean> <bean id="helloService" class="com.developersBook.springExample.serviceImpl.HelloServiceImpl" /> <bean id="byeService" class="com.developersBook.springExample.serviceImpl.ByeServiceImpl" /> </beans>
Por fim, vamos implementar a classe TesteCliente que invoca estes servios. Temos vrias maneiras de carregar o arquivo de configurao mestre (hello.xml) para a classpath. Neste exemplo bsico usamos a ClassPathXmlApplicationContext. 4. Classe Exemplo:TesteCliente.java
package x25.com.tutorial.client; import org.springframework.context.support.ClassPathXmlApplicationContext; import x25.com.tutorial.bean.HelloBean; import x25.com.tutorial.domain.Name; public class TesteCliente { public static void main(String[] args) { try { System.out.println("Iniciando..."); // Lendo o hello.xml para a classpath ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] { "hello.xml" }); System.out.println("Lendo Classpath"); HelloBean helloBean = (HelloBean) appContext.getBean("helloBean"); Name name = new Name(); name.setFirstName("Fernando"); name.setLastName("Anselmo"); String str = helloBean.wishMe(name); System.out.println(str); System.out.println("Final.");
8 de 31
} }
} catch (Exception e) { e.printStackTrace(); }
Veja o cdigo destacado na listagem acima. A classe TesteCliente carrega os arquivos de configurao do Spring atravs de ClassPathXmlApplicationContext. Uma vez que os beans so carregados, possvel acess-los atravs do mtodo getBean(), conforme mostrado na Listagem. Na definio do HelloBean no arquivo hello.xml, que foi carregado pelo classpath, podemos acessar este bean usando o mtodo getBean().
9 de 31
3. Spring e Hibernate
Introduo
Hibernate um poderoso framework para a persistncia de dados em qualquer tipo de aplicao. Spring, por outro lado possui um mdulo de injeo de dependncia que suporta IoC, isso permite que integre perfeitamente com a maioria das tecnologias populares. Como pr-requisito devemos entender a necessidade da integrao, antes de realmente entrar na integrao dessas duas tecnologias. bem conhecido que o Hibernate uma poderosa ferramenta ORM, que se situa entre a aplicao e a base de dados. Permite que aplicativos acessem os registros de qualquer banco de dados de maneira independente de plataforma. No existe a necessidade da aplicao depender dos detalhes de baixo nvel, como o gerenciamento da conexo JDBC, lidando com as declaraes e conjuntos de resultados. Todos os detalhes necessrios para acessar uma determinada fonte de dados facilmente configurvel em arquivos XML. Outro detalhe que essa estrutura pode ser acoplada com qualquer aplicativo das plataformas Java Standard Edition e Java Enterprise Edition. Um dos problemas com o Hibernate que o aplicativo cliente acessa a base de dados usando este framework depende das APIs de configurao: SessionFactory e Session. Esses objetos continuam espalhados pelo cdigo de todo o aplicativo. Alm disso, o cdigo tem que manualmente manter e gerenciar esses objetos. No caso do Spring, esses objetos de negcios podem ser altamente configurveis com a ajuda do mdulo de IoC. Em palavras simples, o estado de um objeto pode ser exteriorizado do cdigo do aplicativo. Isso significa que possvel utilizar os objetos do Hibernate com os Beans do Spring e podemos desfrutar de todas as comodidades que o Spring proporciona.
Amostra de Integrao
Em vez de olhar para as APIs de integrao que esto disponveis no pacote do Spring, vamos compreender essas APIs atravs de cdigos de exemplo. As sees seguintes abordam as diferentes etapas envolvidas na integrao do Spring com o Hibernate.
1) Criao do banco de dados

Nosso aplicativo exemplo utiliza o banco de dados MySql como gerenciador do Banco de dados. O MySql pode ser baixado gratuitamente. Depois de instalado o banco de dados, inicie o cliente MySql e crie um banco de dados de teste, com o seguinte comando:
create database exemplo;
Observar que o caractere ';' o terminador de instruo de cada comando. Uma vez que a base exemplo criada, devemos abri-la com o comando:
use exemplo;
Uma vez aberta significa que qualquer operao que realizemos, como a criao de tabelas,
10 de 31
afeta diretamente a base exemplo. Criamos uma tabela exemplo chamada "empregado" com quatro campos: matricula, nome, idade e salario. O comando a seguir cria a tabela "empregado" no banco de dados exemplo:
create table empregado( matricula char(10) not null, nome varchar(20), idade int(3), salario numeric(5,2), primary key (matricula) );
2) A classe Empregado
Criamos uma classe chamada Empregado para armazenar os dados que so obtidos a partir da tabela de empregados. O projeto de classe funciona de forma que os nomes das colunas de "empregado" da tabela sejam mapeados como os nomes das variveis na classe Java com o tipo de dados apropriado. A. Classe de Mapeamento: Empregado.java
package x25.com.tutorial.mapa; public class Empregado { private private private private String matricula; String nome; int idade; double salario;
public String getMatricula(){ return matricula; } public void setMatricula(String matricula){ this.matricula = matricula; } public String getNome(){ return nome; } public void setNome(String nome){ this.nome = nome; } public int getIdade(){ return idade; } public void setIdade(int idade){ this.idade = idade; } public double getSalario(){ return salario; }
11 de 31
public void setSalario(double salario){ this.salario = salario; } public String toString(){ return "Matrcula: " + matricula + ", Nome: " + nome + ", Idade: " + idade + ", Salrio: " + salario; }
Observe que sobrepomos o mtodo toString() para mostras os dados do objeto de empregado.
3) Criar o arquivo de mapeamento do Hibernate

Criamos a tabela 'empregado' no banco de dados e uma classe Java correspondente na camada de aplicao. No entanto, no especificamos que a tabela deve ser mapeada para a classe Java e devemos mapear tambm os nomes das colunas da tabela para as variveis na classe Empregado. Vamos dar uma olhada no arquivo de mapeamento do Hibernate: B. Arquivo de Configurao: empregado.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"> <hibernate-mapping> <class name="x25.com.tutorial.mapa.Empregado" table="Empregado"> <id name="matricula" column="Matricula"> <generator class="assigned"/> </id> <property name="nome"> <column name="Nome"/> </property> <property name="idade"> <column name="Idade"/> </property> <property name="salario"> <column name="Salario"/> </property> </class> </hibernate-mapping>
Observe que o arquivo de mapeamento um arquivo XML e seu nome por padro empregado.hbm.xml. Este arquivo hbm um arquivo de mapeamento reconhecido pelo mapeamento do Hibernate. Embora no seja necessrio seguir essa conveno, fcil descobrir que este um arquivo do tipo XML e que deve estar em conformidade com um DTD bem definido, com os mapeamentos padres do hibernate-mapping-3.0.dtd. O elemento de raiz para o arquivo de mapeamento o elemento hibernate-mapping que
12 de 31
pode definir um ou mais mapeamentos. Aps isso temos o elemento class que define um mapeamento entre o nome da tabela de banco de dados e a classe Java. O atributo ' name' deve apontar para um nome totalmente qualificado da classe Java enquanto o atributo 'column' deve apontar para a tabela de banco de dados. A prxima srie de elementos define o mapeamento dos nomes das coluna em relao as suas variveis homlogas de Java. O elemento ' id' correspondente a um identificador para uma linha usado como uma coluna de chave primria. O elemento property tem um atributo chamado 'name' que aponta para o nome da varivel Java, na sequncia qual o nome da coluna na tabela de banco de dados que mapeado.
4) Criando o arquivo de configurao do Spring

Esta seo lida com a configurao de vrias informaes necessrias para o Spring. Todos os objetos de negcios so configurados no arquivo XML e so chamados de Spring Beans. Os Spring Beans so mantidos pelo IoC, que fornecido ao cliente mediante uma solicitao. Vamos definir uma fonte de dados: C. Arquivo de Configurao: spring-hibernate.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"> <bean id="meuDataSource" class="org.apache.commons.dbcp.BasicDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/exemplo"/> <property name="username" value="usuario"/> <property name="password" value="senha"/> </bean> <!-- Outros Spring Beans !> </beans>
A classe acima define uma fonte de dados do tipo BasicDataSource. Mais importante, define as propriedades de conexo diferentes que so necessrias para acessar o banco de dados. Para acessar o banco de dados MySql, precisamos de um driver padro JDBC do banco de dados. A primeira propriedade chamada driverClassName que aponta para o nome da classe do driver do banco de dados. A segunda propriedade url representa o caminho que necessrio para se conectar a base de dados. A terceira e quarta propriedades representam o nome e senha do usurio para estabelecer uma sesso com o banco de dados. O prximo Spring Bean representa uma implementao de um SessionFactoryBean. Quando utilizamos o Hibernate, um SessionFactoryBean responsvel por criar os objetos da sesso atravs do qual estaremos interagindo com a transao de dados. Porm, esse SessionFactoryBean ser configurado pelo Spring atravs da adio do seguinte cdigo:
<bean id="mySessionFactory"
13 de 31
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource" ref="meuDataSource"/> <property name="mappingResources"> <list> <value>./resources/empregado.hbm.xml</value> </list> </property> <property name="hibernateProperties"> <value>hibernate.dialect=org.hibernate.dialect.HSQLDialect</value> </property> </bean>
Para que o SessionFactoryBean seja corretamente configurado, devemos fornecer os seguintes dados obrigatrios. O primeiro a informao da fonte de dados que contm os detalhes para acessar o banco de dados. O prximo uma lista de objetos que contm as informaes de mapeamento entre as tabelas de banco de dados e os nomes de classes Java. Definimos um arquivo de mapeamento, no item 3 e referenciamos aqui com o elemento list. O Spring Bean importante para o modelo Hibernate, pois fornece um invlucro de baixo nvel de acesso a dados e para sua correta manipulao. Contm mtodos para inserir, eliminar, atualizar e localizar os registros no banco de dados. Para o modelo Hibernate ser configurado, um nico argumento no objeto SessionFactoryBean repassado, como na seguinte codificao:
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory"> <ref bean="meuSessionFactory"/> </property> </bean>
A definio de um Final Bean a classe DAO. Uma vez que esta classe foi definida a nvel da aplicao, pode conter qualquer nmero de mtodos para envolver o acesso aos dados do cliente. Como sabemos que a classe HibernateTemplate interage com o banco de dados, ideal referir um exemplo do modelo Hibernate para a classe DAO.
<bean id="empregadoDao" class="x25.com.tutorial.dao.EmpregadoDao"> <property name="hibernateTemplate"> <ref bean="hibernateTemplate"/> </property> </bean>
feita uma referncia classe EmpregadoDao, discutida no item seguinte.
5) Definir a classe EmpregadoDao

Conforme descrito anteriormente, esta classe pode conter qualquer nmero de mtodos que podem ser acessados pelos clientes. O projeto desta classe pode ser obtido por duas escolhas. Uma delas a classe depender diretamente do objeto HibernateTemplate que injetado pelo IoC para acessar os dados. A segunda fazer uso da API do Hibernate para acessar os dados. A declarao da classe a seguinte:
14 de 31
Classe: EmpregadoDao.java
package x25.com.tutorial.dao; import import import import import java.sql.SQLException; org.hibernate.HibernateException; org.hibernate.Session; org.springframework.orm.hibernate3.HibernateCallback; org.springframework.orm.hibernate3.HibernateTemplate;
public class EmpregadoDao { private HibernateTemplate hibernateTemplate; public void setHibernateTemplate(HibernateTemplate hibernateTemplate){ this.hibernateTemplate = hibernateTemplate; } public HibernateTemplate getHibernateTemplate(){ return hibernateTemplate; } public Empregado getEmpregado(final String id){ HibernateCallback callback = new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException,SQLException { return session.load(Empregado.class, id); } }; return (Empregado)hibernateTemplate.execute(callback); } public void saveOrUpdate(final Empregado empregado){ HibernateCallback callback = new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException,SQLException { session.saveOrUpdate(empregado); return null; } }; hibernateTemplate.execute(callback); }
Esta classe faz uso da API do Hibernate (particularmente ao objeto de sesso) para o acesso aos dados. Para instruir ao Spring acessar a API do Hibernate, colocamos a lgica de negcio que faz uso da API em um determinado mtodo bem definido e em uma interface conhecida pelo Spring. Isto acontece com a interface HibernateCallback e o mtodo doInHibernate() com uma instncia de uma sesso do Hibernate passada. Definimos dois mtodos: getEmpregado() e saveOrUpdate() na classe EmpregadoDao. Para fazer o uso das APIs do Hibernate, definimos todo o cdigo no mtodo HibernateCallback.doInHibernate() e informamos ao Spring para executar esse cdigo, passando como referncia a interface para o mtodo HibernateTemplate.execute().
15 de 31
6) Aplicativo cliente para teste

Para testarmos nosso ambiente, iremos criar uma classe que adiciona um novo empregado na base de dados e obtm o objeto deste. Aplicativo Cliente: SpringHibernateTeste.java
package x25.com.tutorial; import import import import import org.springframework.beans.factory.BeanFactory; org.springframework.beans.factory.xml.XmlBeanFactory; org.springframework.core.io.FileSystemResource; org.springframework.core.io.Resource; org.springframework.orm.hibernate3.LocalSessionFactoryBean;
public class SpringHibernateTeste { public static void main(String[] args) { Resource resource = new FileSystemResource( "./src/resources/spring-hibernate.xml"); BeanFactory factory = new XmlBeanFactory(resource); Empregado empregado = new Empregado(); empregado.setMatricula("123"); empregado.setNome("Fernando Anselmo"); empregado.setIdade(20); empregado.setSalario(15000.00d); EmpregadoDao empregadoDao = (EmpregadoDao)factory.getBean("empregadoDao"); empregadoDao.saveOrUpdate(empregado); Empregado empResultado = empregadoDao.getEmpregado("123"); System.out.println(empResultado); } }
No aplicativo cliente o controle vai como foi definido. Quando chamado o mtodo BeanFactory.getBean("empregadoDao") , o Spring encontra todas as referncias feitas na definio do bean do EmpregadoDao. Criando um objeto de Hibernate Template. Em seguida, feita uma tentativa para inicializar este objeto onde uma sesso do objeto Bean Factory referenciado. Durante a construo do objeto Session Bean da Factory, as informaes da fonte de dados resolvida juntamente com as tabelas do banco de dados e as classes Java. O principal objetivo da integrao do Spring ORM a sobreposio clara da aplicao, com qualquer acesso de dados e a tecnologia de transao, e para o baixo acoplamento dos objetos da aplicao. No existem mais dependncias de servios empresariais no acesso a dados ou estratgia de transao. Uma abordagem simples e consistente para os objetos de aplicao, mantendo-os como reutilizveis e livres de dependncias.
16 de 31
4. Spring e JPA
O padro EJB 3.0 Java Persistence API (JPA) foi lanado em maio de 2006 como parte da plataforma Java Enterprise Edition 5 (Java EE). O que comeou como um sucessor mais fcil de usar para o to difamado padro Container-Managed Persistence (CMP) do componente EJB, logo evoluiu para uma incorporao das melhores prticas existentes no uso da mais proeminente e popular object-relational (O-R) persistence products. O resultado que os aplicativos possuem um padro moderno, leve para a persistncia de Java que pode-se usar em qualquer plataforma Java EE compatvel com servidor de aplicao 5, ou em aplicaes Java Standard Edition (SE). A estrutura do aplicativo Spring j existe h quatro anos, e tornou-se uma escolha popular, tanto em um contexto de servidor de aplicao e independente. Como a JPA, Spring uma tecnologia projetada para permitir que os aplicativos sejam construdos a partir de POJOs. O Spring executado dentro de qualquer contexto de tempo de execuo de um aplicativo que requer e suporta aplicaes, fornecendo uma ampla gama de servios. Alguns destes servios so abstraes mais existentes de nvel dos mdulos de servio, enquanto outros agregam valor ao recipiente Java EE. A camada de acesso a persistncia, particularmente popular entre a comunidade Spring, pois est muito bem integrado com qualquer tempo de execuo e a persistncia e facilitada por uma abordagem que permite trabalhar com objetos persistentes.
Spring como um Continer de JPA

A Java Persistence API foi arquitetada de forma que poderia ser utilizada tanto dentro como fora da plataforma Java EE 5. Quando no h um recipiente para organizar os gerentes de entidade JPA e transaes, este servio deve ser mais a carga de gerenciamento. Um dos objetivos da especificao do JPA foi fazer uma tecnologia plugvel. Para permitir isso: Os papis do provedor de recipientes o recipiente ou o lado que tem o controle das linhas de tempo de execuo e transaes. E o provedor de persistncia o fornecedor ou a parte que implementa a API de persistncia e gerencia as entidades persistentes. E uma interface de provedor de servio (SPI Service Provider Interface) que liga os dois na implantao e execuo.
Um continer JPA host compatvel e deve ser implementado corretamente com o SPI a partir da perspectiva do recipiente. Ou seja, um provedor de persistncia compatvel com JPA implementa o SPI a partir da perspectiva do provedor. Se ambos os lados seguir essas regras, um recipiente compatvel deve ser capaz de executar qualquer implementao de provedor compatvel, persistncia e de mesma forma, um fornecedor deve ligar qualquer recipiente.
17 de 31
Embora o Spring no um servidor de aplicao nem um continer Java EE 5, que faz aumentar, e s vezes implementar muitos dos servios utilizados em servidores de aplicao. Spring implementa uma poro de recipiente do SPI APP para que possa ser visto como um recipiente de APP. Como tal, fornece o suporte a classe de carregamento e tece o formato que os provedores JPA usam para ajudar a gerenciar as entidades em tempo de execuo. Os usurios se beneficiam de um ambiente no qual o continer em tempo de execuo e o provedor de persistncia JPA so totalmente integrados, no necessariamente em um contexto da plataforma Java EE 5. Isto proporciona muitas das vantagens da persistncia Java EE sem a necessidade de um continer.
Definio das Entidades

A parte mais bsica para se usar a JPA projetar e criar as entidades a serem persistidas. Vamos utilizar um sistema de Inventrio de Livros como exemplo para o entendimento deste captulo. Deste modo, vamos criar uma entidade LIVRO, definindo a classe e anotando-a com uma anotao @Entity. O identificador de chave primria o campo ISBN, por isso, devemos anotar esse campo com @Id. Os campos ttulo e autor sero mapeamentos bsicos dos campos de objeto para as colunas de mesmo nome na tabela de banco de dados. Teremos um campo gnero para mapear para uma coluna da entidade CATEGORIA, para isso, uma anotao @Column. Classe: Livro.java
package x25.com.tutorial; import javax.persistence.*; @Entity public class Livro { @Id private int isbn; private String titulo; private String autor; @Column(name="CATEGORIA") private Genero genero; } // Construtores, mtodos padro GET/SET, etc.
Uma aplicao real teria muitas entidades, porm desejamos focar o uso da APP no Spring, e no nosso objetivo explicar como definir e mapear entidades JPA.
Usando as Entidades JPA com o Spring

A principal maneira de operar as entidades usar um gerenciador de entidades. A API EntityManager a principal porta de entrada JPA e suporta o bsico definido por criar, ler,
18 de 31
atualizar e excluir (Padro CRUD). Atua como um gerente de todas as entidades carregadas e uma fbrica para consultas que permitem s entidades serem carregadas. Um gestor de entidade anlogo a uma sesso TopLink do Oracle, sesso do Hibernate ou a uma interface equivalente fornecido pelos diversos frameworks de mapeamento OR. Por exemplo, para criar uma nova entidade persistente criamos um novo objeto Java do tipo de entidade e invocamos o mtodo persist() no gerenciador de entidade, e passamos a nova entidade como parmetro. Supondo que temos acesso a um gestor de entidade, o cdigo para criar um novo Livro simples.
Livro livro = new Livro(12769356, "Guerra e Paz", "Leo Tolstoy", Genero.FICCAO); entityManager.persist(livro);
Usando a APP, o mdulo gerenciador de entidade do Spring torna o trabalho muito simples. Na maioria dos casos uma questo de anotar um campo ou um mtodo de um Spring Bean com uma anotao @PersistenceContext1, que faz com que um gestor de entidade seja injetado. Em seguida, invocar o gestor de entidade no contexto de uma operao de recipiente. Utilizando o Spring, a transao pode ser iniciada e confirmada (commit) ou no (rollback) na entrada ou sada do mtodo. Para alcanar este objetivo necessrio ser realizado declarativamente a demarcao de uma transao automtica que deve acontecer. No Spring a maneira mais fcil de fazer isso anotar a classe bean ou mtodo com a anotao @Transactional, embora tambm seja possvel a utilizao de metadados XML que no nescessitam anotar o cdigo Java. O tipo de transao iniciada depende do tipo de gerenciador de transaes que est configurado no contexto da aplicao do Spring; o conhecimento de sua infraestrutura de transao subjacente completamente abstrada no cdigo Java. Um exemplo de um Spring Bean transacional e que utiliza um gestor de entidade para executar operaes de APP mostrado na classe abaixo: Classe: LivroInventarioSystem.java
package x25.com.tutorial; import javax.persistence.*; import org.springframework.transaction.annotation.Transactional; @Transactional public class LivroInventarioSystem { @PersistenceContext(unitName="BIS") EntityManager em; public void addLivro(int isbn, String titulo, String autor, Genero genero) { Livro livro = new Livro(isbn, titulo, autor, genero); em.persist(livro); } } 1 Observamos que @PersistenceContext uma anotao JPA padro e no especfico para o Spring.
19 de 31
Esta classe bastante comum, exceto pela presena de duas anotaes adicionais, @Transactional e @PersistenceContext. A anotao @Transactional define que todos os mtodos da classe obtenham uma transao automtica, deste modo, uma transao ser fornecida sempre que invocado o mtodo addLivro(). Podemos ter facilmente o mtodo anotado diretamente para obter esse comportamento, mas a probabilidade de adicionar mais mtodos que tambm precisam de uma transao bastante elevada, ento uma classe a melhor forma de implement-lo. O atributo em ser injetado como uma instncia de EntityManager. O gestor de entidade injetado ser configurado de acordo com a unidade de persistncia chamado referido no atributo unitName da anotao @PersistenceContext. Unidades de persistncia nomeados so definidas e configuradas no arquivo de configurao persistence.xml da JPA e no contexto do aplicativo Spring como parte do Factory Bean do EntityManager.
Configurao da Camada de Persistncia

O arquivo de configurao padro JPA um arquivo XML denominado persistence.xml, e inserido no diretrio META-INF do arquivo jar ou no classpath. Ao utilizar a JPA, na maioria dos ambientes de execuo este arquivo contm a maior parte das informaes de configurao em tempo de execuo (exceto mapeamento O-R). Entretanto, ao usar JPA no Spring, esse arquivo contm apenas a definio da unidade de persistncia e, s vezes uma lista das classes de entidade (se no for executado em um ambiente de implementao do servidor). Um exemplo de um arquivo persistence.xml como mostrado abaixo. Arquivo de Configurao: persistence.xml
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0"> <persistence-unit name="BIS" transaction-type="RESOURCE_LOCAL"> <class>x25.com.tutorial.Livro</class> </persistence-unit> </persistence>
O tipo de transao tambm depende do ambiente de implantao. Neste exemplo, estamos executando um simples mquina virtual Java (VM) e no usamos o acesso a um gerenciador de transaes JTA, por isso, definimos o tipo de transao como um RESOURCE_LOCAL.
Configurando o Contexto da Aplicao

Cada aplicao do Spring deve, eventualmente, construir um contexto de aplicao um conjunto de definies em beans que especificam as dependncias que um nico bean tem sobre os outros. O Spring Bean um componente na aplicao, que configurado pelo Spring e elegido para se beneficiar dos servios oferecidos. O contexto de aplicao determina como os beans se encaixam em tempo de execuo e fornece a flexibilidade necessria para ligar as partes de uma aplicao de diferentes maneiras, sem alterar o cdigo da aplicao Java.
20 de 31
Configurando o Entity Manager Factory Bean

Como parte do apoio para a JPA, o Spring fornece vrias classes relacionadas destinados a ser utilizados como Spring Beans. O mais importante destes o Entity Manager Factory Bean, que torna um JPA Entity Manager Factory disponvel para a aplicao. Este bean possui dependncias que determinam os parmetros de execuo da APP, no Spring e, embora muitas dessas configuraes podem ser definidas no arquivo persistence.xml do JPA, o contexto de aplicao pode proporcionar uma maior flexibilidade e capacidade de configurao. Fornece um estilo de configurao e experincia que consistente com o que os usurios esto acostumados no Spring. A configurao do Entity Manager Factory Bean envolve trs dependncias principais: o nome da unidade de persistncia, a fonte de dados, e o LoadTimeWeaver. Isto feito como se segue:
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"> <property name="persistenceUnitName" value="BIS"/> <property name="dataSource" ref="dataSource"/> <property name="loadTimeWeaver" class= "org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/> <property name="jpaVendorAdapter" ref="vendorAdapter"/> </bean>
O tipo de componente criado por esta definio de bean o EntityManagerFactory, que o ponto de partida para utilizao da JPA. O nome da unidade de persistncia e a fonte de dados definida da maneira usual. Spring utiliza uma ou mais definies da plataforma Java 2 Standard Edition (J2SE) como fonte de dados e ponto de partida para a configurao de persistncia. Um nmero de tipos de fontes de dados esto disponveis, mas, neste caso, estamos usando um simples pool JDBC definida da seguinte forma:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/exemplo"/> <property name="userName" value="root"/> <property name="password" value="senha"/> </bean>
A propriedade loadTimeWeaver especifica a estratgia que o Spring utiliza para implementar um continer fornecedor de SPI e oferece a capacidade de weaving. Neste exemplo, usamos o recurso de instrumentao introduzida na plataforma Java SE 5 VM para especificar a classe InstrumentationLoadTimeWeaver. Se estamos executando um servidor Tomcat, seria este conjunto de ReflectiveLoadTimeWeaver utilizado como um carregador da classe Tomcat fornecida pelo Spring. Se estamos executando o Spring dentro do Oracle para contineres J2EE servidor (OC4J), devemos configur-lo para OC4JLoadTimeWeaver, que liga o suporte de carregamento da classe especial em OC4J.
21 de 31
Configurando o Vendor Adapter

Realizamos uma dependncia adicional no Entity Manager Factory Bean e com um bean chamado vendorAdapter. A propriedade jpaVendorAdapter uma propriedade opcional que facilita o estabelecimento de um fornecedor de propriedades especficas que so comuns entre os fornecedores. Detalhes desta propriedade: Se os rastreamentos SQL devem ser registrados A plataforma de banco de dados utilizada Se o esquema deve ser gerado no banco de dados quando o aplicativo for iniciado
Adicionamos essa propriedade porque os provedores de persistncia diferentes tendem a fornecer um mecanismo para configurar essas propriedades, mas os mecanismos diferem de provedor para provedor. Ao definir os nomes de propriedade comum no Spring, as configuraes podem ser especificados independentemente da implementao do provedor que est sendo conectado. Isso facilita a mudana entre os prestadores de persistncia diferentes ao minimizar as mudanas de configurao algo que pode ajudar aos usurios a determinar quais provedores disponveis apresenta um melhor desempenho ou pode atender melhor as necessidades da aplicao. A seguinte definio do bean vendorAdapter com a propriedade jpaVendorAdapter. Define TopLink como o fornecedor e fornece os valores para as trs configuraes comuns de propriedade.
<bean id="vendorAdapter" class="org.springframework.orm.jpa.vendor.TopLinkJpaVendorAdapter"> <property name="databasePlatform" value="${platform}"/> <property name="showSql" value="true"/> <property name="generateDdl" value="true"/> </bean>
A sequncia da databasePlatform entendido pelo provedor de persistncia por isso mesmo que o nome da propriedade comum, os valores podem ser de diferentes fornecedores. Temos atribudo uma plataforma varivel e definida em um aplicativo de contexto externo de propriedades. Implementaes como TopLink definem muito mais configuraes JPA que podem ser usados para configurar o provedor de maneiras que variam a especificao do tipo de cache para usar e declarar as classes personalizadas e os tipos de mapeamento. Estas propriedades adicionais so geralmente definidas como propriedades no arquivo persistence.xml.
Outras Configuraes
A prxima coisa que faremos declarar a classe LivroInventarioSystem como um Spring Bean. A definio de simples Bean apenas aponta ao Spring qual proxy e gerencia as instncias da classe e como sero criadas.
<bean class="x25.com.tutorial.LivroInventarioSystem"/>
22 de 31
A seguir, vamos utilizar os recursos locais em nvel de transaes previstas pelo gerenciador de entidades JPA, assim podemos definir um bean gerenciador de transaes e vincul-lo classe JpaTransactionManager. Em seguida, referem-se a Entity Manager Factory Dependency para a nossa Entity Manager Factory Bean.
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/> </bean>
Este gerenciador de transaes projetado para suportar as conexes transacionais atravs de JPA, tambm permite o acesso direto a JDBC utilizando a biblioteca do mdulo de abstrao JDBC do Spring. Realizamos um pouco de limpeza para indicar ao Spring que deve agir em qualquer anotao @PersistenceContext e @Transactional encontrados na classe bean. Isto feito atravs da adio de dois elementos:
<bean class= "org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/> <tx:annotation-driven/>
O namespace tx e o esquema adicionado ao topo da aplicao do arquivo de contexto XML de modo que o espao possa ser reconhecido.
Testes da Aplicao
Spring projetado para facilitar as prticas geis de desenvolvimento especialmente para fazer testes mais fceis do que no tradicional desenvolvimento Java EE. O uso de injeo de dependncia e de programao POJO permite que testes unitrios sejam mais simples de serem realizados. Spring fornece uma poderosa integrao com as facilidades de testes que permite o cdigo acessar dados persistentes e ser testado sem a necessidade da implantao de um servidor de aplicativos ou qualquer outro continer. Esta funcionalidade empacotada no arquivo spring-mock.jar includo na distribuio do framework e permite os seguintes servios: Demarcao de transao automtica . Cada teste executado em sua prpria transao, que revertida por padro. Isso garante que cada teste pode ser executado em sua prpria sandbox sem produzir efeitos colaterais. Cache configuraes. Uma configurao como a mapeamentos OR carregado somente uma vez, assegurando que custos de inicializao no sero repetidos para cada teste. Injeo de dependncia de casos de teste . Os casos de teste podem ser injetados como componentes de aplicao, tornando-os mais fceis de desenvolver e inicializar.
Em conjunto, esses servios permitem que os testes podem ser escritos de forma rpida e facilmente executado em segundos. O exemplo a seguir mostra como facilmente podemos testar nosso sistema de Inventrio.
23 de 31
Estendemos a classe de testes AbstractJpa, que uma subclasse de TestCase do JUnit e, ento, especificar um dispositivo de localizao de configurao. O suporte de ensaio ser automaticamente injetado por dependncia ao fornecer um mtodo no padro SET. Podemos fornecer qualquer nmero de mtodos no padro SET, sendo uma boa prtica testar um detalhe por vez. Devemos implementar o mtodo getConfigLocations() para retornar um array de configuraes do Spring que deseja carregar. A maioria dos dados de configurao idntico ao que foi utilizado em um cenrio implantado, minimizando a quantidade de trabalho adicional necessrio para implementar testes:
package x25.com.tutorial; import org.springframework.test.jpa.AbstractJpaTests; public class LivroInventarioSystemTest extends AbstractJpaTests { private LivroInventarioSystem livroInventarioSystem; public void setBookInventorySystem(LivroInventarioSystem livroInventarioSystem) { this.livroInventarioSystem = livroInventarioSystem; } protected String[] getConfigLocations() { return new String[] {"/my/path/my-spring-config.xml"}; }
Podemos adicionar qualquer nmero de mtodos neste cenrio. Estes podem acessar os dados usando o nosso objeto de acesso a dados (DAO) de fixao ou o JdbcTemplate e variveis da instncia sharedEntityManager herdados JpaTestCase como segue:
public void testAddLivro() { int ctOldLivro = jdbcTemplate.queryForInt("SELECT COUNT(0) FROM LIVRO"); livroInventarioSystem.addLivro( 12769356, "Guerra e Paz", "Leo Tolstoy", Genero.FICCAO); sharedEntityManager.flush(); int ctNewLivro = jdbcTemplate.queryForInt("SELECT COUNT(0) FROM LIVRO"); assertEquals("Deve ser adicionado nova linha na tabela LIVRO", ctOldLivro + 1, ctNewLivro); }
Usamos as consultas JDBC na mesma transao para verificar o comportamento correto do nosso DAO. Em primeiro lugar, consultamos o nmero de linhas na tabela LIVRO. Ento adicionamos um livro, tendo a certeza de lavar a unidade de trabalho atual, usando o mtodo EntityManager.flush(). Isso obriga ao provedor de persistncia para emitir o SQL necessrio para a atualizao. Agora podemos emitir outra consulta JDBC para verificar que adicionamos uma linha na base de dados. Sabemos que o nosso DAO no se limita a executar, sem exceo, mas tambm faz mudanas necessrias em nosso banco de dados. Essas alteraes sero revertidas quando o mtodo testAddLivro() for concluda, para que as alteraes no sejam persistentes ou afetem outros testes.
24 de 31
5. Gerenciamento de Transaes
Gerenciamento de transaes fundamental em qualquer tipo de aplicaes que iro interagir com o banco de dados. A aplicao tem de assegurar que os dados so consistentes e da integridade dos dados mantida. H muitas estruturas de dados populares como JDBC, JPA, Hibernate, entre outros e o Spring Framework fornece uma maneira perfeita de integrao com essas estruturas.
Propriedade das Transaes

Uma transao uma sequncia de aes que so tratados como uma nica unidade de trabalho. Essas aes devem ou completar totalmente ou tomar qualquer efeito. Gerenciamento de transaes uma parte importante de aplicaes corporativas e RDBMS para garantir a integridade dos dados e consistncia. O conceito de transaes pode ser descrito com as seguintes quatro propriedades essenciais descritas como ACID: Atomicidade: Uma transao deve ser tratada como nica unidade de operao que significa que ou toda a sequncia de operaes bem ou mal sucedidas. Consistncia: Isto representa a consistncia da integridade referencial do banco de dados, chaves primrias em tabelas, entre outras. Isolamento: Pode haver muitas transaes de processamento com os mesmos dados ao mesmo tempo, cada transao deve ser isolada das outras para evitar corrupo de dados. Durabilidade: Uma vez que uma operao tenha completado, os resultados desta operao deve ser permanente e no pode ser apagada a partir do banco de dados devido a falha do sistema.
Um sistema de banco de dados RDBMS deve garantir todas as propriedades para cada transao. A vista simplista de uma transao emitida para o banco de dados usada em uma instruo SQL, como se segue: Iniciar a transao comeando com o comando de transao. Realizar vrias operaes de manuteno de registros tais como, incluir, atualizar ou excluir usando instrues SQL. Se toda a operao bem sucedida em seguida, executar cometer outra forma de reverso de todas as operaes.
Spring oferece uma camada abstrata no topo das APIs de gesto subjacente transao diferente. O apoio do Spring de transao tem como objetivo fornecer uma alternativa para transaes EJB, adicionando capacidades de transao para POJOs. Spring suporta o gerenciamento de transaes tanto programtica quanto declarativa. EJB requer um servidor de aplicao, mas o gerenciamento de transaes Spring pode ser implementada sem a necessidade de servidor de aplicativos.
25 de 31
Transaes Local versus Global

As transaes locais so especficas para um nico recurso transacional como uma conexo JDBC, enquanto que as operaes globais podem se estender por vrios recursos transacionais como transao em um sistema distribudo. Gerenciamento de transaes local pode ser til em um ambiente de computao centralizada, onde os componentes do aplicativo e recursos esto localizados em um nico site, e gerenciamento de transaes envolve apenas um gerenciador de dados local executando em uma nica mquina. As transaes locais so mais fceis de ser implementadas. Gerenciamento de transaes global necessria em um ambiente de computao distribuda, onde todos os recursos so distribudos atravs de mltiplos sistemas. Em tal gerenciamento de transaes de um caso precisa ser feito tanto a nvel local e global. A distribuio ou uma transao global executado em vrios sistemas, e sua execuo requer coordenao entre o sistema global de gerenciamento de transaes e todos os gerentes de dados locais de todos os sistemas envolvidos.
Programtica versus Declarativa

Spring suporta dois tipos de gerenciamento de transaes: Gesto programtica de transao : Isso significa gerenciar a transao com a ajuda de programao. Isso proporciona extrema flexibilidade, mas difcil de manter. Gerenciamento de transao declarativa : Isto significa que o gerenciamento de transaes separado do cdigo de negcios. Usar as anotaes ou configurao baseado em XML para gerenciar as transaes.
Gerenciamento de transao declarativa prefervel a gesto programtica de transao, embora seja menos flexvel do que a gesto programtica de transao, que lhe permite controlar transaes atravs de seu cdigo. Mas como uma espcie de preocupao transversal, gerenciamento de transaes declarativo pode ser modulado com a abordagem AOP.
26 de 31
6. Spring Security
Spring Security, uma autenticao flexvel e poderoso e uma estrutura de controle de acesso para garantir Primavera baseado em Java aplicao Web. Usamos o Spring Security para fornecer uma forma de autenticao de login simples para garantir o acesso URL em aplicao Web. uma forte autenticao e altamente personalizvel e de controle de acesso quadro. o padro de fato para garantir Primavera aplicaes baseadas sendo um dos projetos mais maduros do Spring e amplamente utilizado. Possui as seguintes caractersticas: Ativar a segurana Web e proteger os padres de URL diferentes em um aplicativo Usar um formulrio de login com base em autenticao contra um repositrio de memria de usurios de teste Usar senhas com hash para reduzir os riscos de comprometimento dos dados.
Vamos olhar com um pouco mais de profundidade no aplicativo de exemplo mais bsico que vem com o Spring Security. mais instrutivo para aumentar a segurana para um aplicativo da Web existente, por isso primeiro devemos remover a configurao de segurana existente na aplicao, e, em seguida, adicionar gradativamente as opes de configurao necessrias para satisfazer as nossas necessidades. Pode-se fazer mais do isto, basta modificar o arquivo WAR que vem com a distribuio do Spring Security, mas para obter melhores resultados, recomendamos a criao do cdigo de amostra em si mesmo.
Segurana de uma aplicao

Agora estamos prontos para adicionar um pouco de segurana. Ns no vamos substituir a configurao original exatamente, mas vo construir uma nova configurao em etapas para satisfazer um determinado conjunto de requisitos. Do ponto de vista do aplicativo, vamos imaginar que existem trs perfis de usurio, "supervisor", "caixa" e "usurio". Queremos aplicar os seguintes controles de acesso: Estar autenticado para acessar qualquer registro Pginas no diretrio "/secure" s deve ser visvel para usurios autenticados Pginas no diretrio "/secure/extreme" s deve ser visvel para o perfil supervisor Apenas os perfis caixa e supervisor podem realizar saques ou depsitos Somente o perfil supervisor pode exceder o limite de cheque especial Exigir autenticao para acessar uma determinada URL
Em geral, uma boa prtica negar o acesso por padro, ao invs de apenas garantir os recursos que precisamos. Com isso em mente, vamos mudar o bloco <http> e adicionar alguns controles de acesso Web
27 de 31
<http use-expressions="true"> <intercept-url pattern="/index.jsp" access="permitAll" /> <intercept-url pattern="/secure/**" access="isAuthenticated()" /> <intercept-url pattern="/secure/extreme/**" access="hasRole('supervisor')" /> <intercept-url pattern="/listAccounts.html" access="isAuthenticated()" /> <intercept-url pattern="/post.html" access="hasAnyRole('supervisor','caixa')" /> <intercept-url pattern="/**" access="denyAll" /> <form-login /> </http>
Protegendo a camada de servio

Spring Security tambm permite que a adio de segurana para chamadas de mtodo feitas atravs dos Spring Beans no contexto do aplicativo. Esta uma abordagem mais poderosa que os padres URL. Para ser capaz de fazer essas alteraes, precisamos ser capaz de criar um cdigo de amostra, portanto o ideal seria e seguir as instrues sobre como obter e construir uma base. Para ativar a segurana mtodo necessrio adicionar o seguinte elemento no arquivo de contexto de aplicao (acima do elemento <http>):
<global-method-security pre-post-annotations="enabled" />
Isso permite o uso de anotaes de segurana em interfaces ao Spring. A principal interface para o aplicativo de exemplo chamado BankService e possui uma anotao necessria
public interface BankService { public Account readAccount(Long id); public Account[] findAccounts(); @PreAuthorize( "hasRole('supervisor') or " + "hasRole('teller') and (#account.balance + #amount >= -#account.overdraft)" ) public Account post(Account account, double amount); }
A anotao @PreAuthorize contm uma linguagem de expresso Spring que encapsula a lgica de nossa exigncia final. Ao executar o aplicativo, receberemos uma exceo se exceder o montante descoberto sem acesso supervisor. As expresses so uma ferramenta poderosa, mas devemos ser cuidadosos para construir a lgica excessivamente complicado.
28 de 31
7. Spring AOP
Spring AOP um paradigma de nova programao, implementada em Java e no ocorre a necessidade de um processo de compilao especial. No necessrio controlar a hierarquia do carregador de classe, e portanto adequado para o uso em um continer Java Web ou um servidor de aplicao de Java EE. uma outra maneira de pensar sobre a estrutura do programa em termos de aspectos ou preocupao. Se compararmos AOP com OOP (Programao orientada a objetos), a OOP decompe a aplicao em hierarquia de objetos onde, como o AOP decompe a aplicao em Aspectos ou preocupao. Programao Orientada a Aspectos (AOP) complementa a Programao Orientada a Objetos (OOP), fornecendo outra maneira de pensar sobre a estrutura do programa. A unidade de chave de modularidade em OOP a classe, enquanto que em AOP a unidade de modularidade o aspecto. Aspectos permitem a modularidade das preocupaes, como o gerenciamento de transaes que atravessam vrios tipos e objetos. (Tais preocupaes so muitas vezes chamado de interesses transversais em literatura AOP). Um dos componentes chave da AOP. Enquanto que o mdulo IoC no depende AOP, ou seja, no necessrio usar AOP se voc no quiser, AOP complementa IoC para fornecer uma soluo de middleware.
Conceitos
Aspecto um subprograma que est associado com uma propriedade especfica de um programa. Como essa propriedade varia, o efeito "ondulaes" atravs de todo o programa. a funcionalidade ou caracterstica que atravessa sobre o objeto. AOP tambm aumenta a modularidade de um programa. Um aspecto disperso em virtude da funo que est sendo lido por um nmero de funes no relacionadas. Isso significa mudar de uma funo requer a modificao de todos os mdulos afetados. Como o cdigo tornando-o mais difcil de entender e manter. Aviso uma ao tomada pelo aspecto em um determinado ponto comum. um pedao de cdigo que executado durante a execuo do programa. Existem vrios tipos de conselho, dependendo da posio so chamados de um programa. Tipos de Aviso: Antes: Um aviso que executou antes de um ponto de juno (jointpoint). Um aviso do tipo antes no tem a capacidade de interromper o fluxo de um processo de execuo no ponto de articulao, a menos que ele lance uma exceo. Depois de Retornar: Um aviso que executou depois de um ponto de juno concludo normalmente. Por exemplo, um mtodo retorna sem lanar uma exceo. Em Torno: Responsvel pela escolha de se proceder a um ponto de juno ou um atalho para executar, retornando o seu valor prprio retorno ou lanar uma exceo. Executar o
29 de 31
comportamento personalizado antes e depois da invocao de mtodo por em torno de um ponto de juno. Depois de Lanar um Aviso: Executado quando um mtodo gera uma exceo. Depois de (finalmente) um aviso : Executado quando o programa sai do ponto de juno normalmente ou lana uma exceo. Weaving Processo de vinculao ao aspecto com outro aplicativo ou objeto para criar um tipo de conselho. Isso realizado no Spring em tempo de execuo. Ponto de Juno Um ponto utilizado no Spring AOP para representar a execuo de um mtodo. Aponta durante a execuo do programa ou mtodos ou excees. Inicia com mtodos, intercepta AOP e neste momento para fazer algumas outras coisas. isto , incio dos mtodos doThis(), doExtra(), test(), somethingElse(), entre outros. Objeto-alvo: objeto que est sendo assessorado por um ou mais aspectos. Tambm conhecido como o objeto aconselhou. O Spring AOP implementado usando proxy de tempo de execuo, este objeto um objeto no padro proxy. Proxy AOP: um objeto criado pelo framework AOP para implementar os contratos de aspecto (aconselhar execues mtodo e assim por diante). No Spring, um proxy AOP ser um proxy JDK dinmico ou um proxy CGLIB.
Hello World Spring AOP

Escrevendo nossa lgica de negcios
Neste tutorial vai aprender como configurar o Spring AOP usando um BeanFactory. HelloInterface.java
package x25.com.tutorial; public interface HelloInterface { public void sayHello(); public void greet(); }
HelloWorldImpl.java
package x25.com.tutorial; public class HelloWorldImpl implements HelloInterface { @Override public void greet() { System.out.println("Tenha um Bom Dia !!!"); } @Override public void sayHello() { System.out.println("Hello World");
30 de 31
SimpleAdvice.java
package x25.com.tutorial; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class SimpleAdvice implements MethodInterceptor { @Override public Object invoke(MethodInvocation methodInvocation) throws Throwable { System.out.println("Hello"); Object object = methodInvocation.proceed(); System.out.println("Done ..."); return object; }
Principal.java
package x25.com.tutorial; import org.springframework.aop.framework.ProxyFactory; public class MainClaz { public static void main(String[] args) { HelloWorldImpl helloWorldImpl = new HelloWorldImpl(); SimpleAdvice advice = new SimpleAdvice(); ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.addAdvice(advice); proxyFactory.setTarget(helloWorldImpl); HelloWorldImpl proxy = (HelloWorldImpl) proxyFactory.getProxy(); proxy.sayHello(); proxy.greet(); } }
Ao executar este aplicativo vai exibir a mensagem conforme mostrado abaixo:

Hello Hello World Done ... Hello Tenha um bom dia !!! Done ...
31 de 31

01 SpringFramework

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

01 SpringFramework

Încărcat de

Drepturi de autor:

Formate disponibile

Spring Framework

Curso Spring Framework

Curso Spring Framework

Mdulos do Spring Framework

Curso Spring Framework

Curso Spring Framework

Curso Spring Framework

2. Injeo de Dependncia ou IoC

Curso Spring Framework

Curso Spring Framework

E. Arquivo de Configurao: hello.xml

Curso Spring Framework

} catch (Exception e) { e.printStackTrace(); }

Curso Spring Framework

1) Criao do banco de dados

Curso Spring Framework

Curso Spring Framework

3) Criar o arquivo de mapeamento do Hibernate

Curso Spring Framework

4) Criando o arquivo de configurao do Spring

Curso Spring Framework

feita uma referncia classe EmpregadoDao, discutida no item seguinte.

5) Definir a classe EmpregadoDao

Curso Spring Framework

Curso Spring Framework

6) Aplicativo cliente para teste

Curso Spring Framework

Spring como um Continer de JPA

Curso Spring Framework

Definio das Entidades

Usando as Entidades JPA com o Spring

Curso Spring Framework

Curso Spring Framework

Configurao da Camada de Persistncia

Configurando o Contexto da Aplicao

Curso Spring Framework

Configurando o Entity Manager Factory Bean

Curso Spring Framework

Configurando o Vendor Adapter

Curso Spring Framework

Curso Spring Framework

Curso Spring Framework

Propriedade das Transaes

Curso Spring Framework

Transaes Local versus Global

Programtica versus Declarativa

Curso Spring Framework

Segurana de uma aplicao

Curso Spring Framework

Protegendo a camada de servio

Curso Spring Framework

Curso Spring Framework

Hello World Spring AOP

Curso Spring Framework

Ao executar este aplicativo vai exibir a mensagem conforme mostrado abaixo:

S-ar putea să vă placă și