01-SpringFramework

(1)

Spring

Framework

O

O Spring Framework Spring Framework é uma solução leve que permite a construção deé uma solução leve que permite a construção de aplicativos empresarias.

aplicativos empresarias. Spring Spring é modular, isso permite o uso de apenasé modular, isso permite o uso de apenas as partes necessárias, sem ter de implementar todos os módulos do as partes necessárias, sem ter de implementar todos os módulos do framework. Pode-se utilizar somente o módulo IoC,

framework. Pode-se utilizar somente o módulo IoC, com ocom o StrutsStruts no topo,no topo, como também usar somente a integração com o

como também usar somente a integração com o HibernateHibernate ou a camadaou a camada de abstração

de abstração JDBC JDBC . . OO Spring Spring suporta o gerenciamento de transaçãosuporta o gerenciamento de transação declarativas, acesso remoto e lógica através do modelo

declarativas, acesso remoto e lógica através do modelo RMI RMI ou serviçosou serviços da Web, e várias opções para a persistência dos dados. Oferece uma da Web, e várias opções para a persistência dos dados. Oferece uma completa estrutura MVC, e permite a

completa estrutura MVC, e permite a integraçãointegração AOP AOP transparente.transparente.

Versão 1.0 Versão 1.0

(2)

Sumário

1. Spring Framework...3

A v A visão geral do Spring Framewisão geral do Spring Framework:...ork:... ...33

Módulos do Spring Framework...3

Exemplos de Aplicações...5

2. Injeção de Dependência ou IoC...6

3. Spring e Hibernate...10 3. Spring e Hibernate...10 Introdução...10 Introdução...10 Amostra de Integração...10 Amostra de Integração...10

1) Criação do banco de dados...10

2) A 2) A classe Empregado...classe Empregado... ...1111

3) Criar o arquivo de mapeamento do Hibernate...12

4) Criando o arquivo de configuração do Spring...13

5) Definir a classe EmpregadoDao...14

6) Aplicativo cliente para teste...16

4. Spring e JPA...17

Spring como um Contêiner de JP Spring como um Contêiner de JPA...A... ....17....17

Definição das Entidades...18

Usando as Entidades JPA com o Spring...18

Configuração da Camada de Persistência...20

Configurando o Contexto da Aplicação...20

Configurando o Entity Manager Factory Bean...21

Configurando o Configurando o VVendor Adapter...22endor Adapter...22

Outras Configurações...22 Outras Configurações...22 Testes da Aplicação...23 Testes da Aplicação...23 5. Gerenciamento de Transações...25 5. Gerenciamento de Transações...25

Propriedade das Transações...25

Trans Transações Local versus Global...ações Local versus Global... 2626 Programática versus Declarativa...26

Programática versus Declarativa...26

6. Spring Security...27

Segurança de uma aplicação...27

Protegendo a camada de serviço...28

7. Spring AOP...29

Conceitos...29

Hello World – Spring Hello World – Spring AOP...AOP... .30.30 Escrevendo nossa lógica de negócios...30

(3)

Sumário

1. Spring Framework...3

A v A visão geral do Spring Framewisão geral do Spring Framework:...ork:... ...33

Módulos do Spring Framework...3

Exemplos de Aplicações...5

2. Injeção de Dependência ou IoC...6

3. Spring e Hibernate...10 3. Spring e Hibernate...10 Introdução...10 Introdução...10 Amostra de Integração...10 Amostra de Integração...10

1) Criação do banco de dados...10

2) A 2) A classe Empregado...classe Empregado... ...1111

3) Criar o arquivo de mapeamento do Hibernate...12

4) Criando o arquivo de configuração do Spring...13

5) Definir a classe EmpregadoDao...14

6) Aplicativo cliente para teste...16

4. Spring e JPA...17

Spring como um Contêiner de JP Spring como um Contêiner de JPA...A... ....17....17

Definição das Entidades...18

Usando as Entidades JPA com o Spring...18

Configuração da Camada de Persistência...20

Configurando o Contexto da Aplicação...20

Configurando o Entity Manager Factory Bean...21

Configurando o Configurando o VVendor Adapter...22endor Adapter...22

Outras Configurações...22 Outras Configurações...22 Testes da Aplicação...23 Testes da Aplicação...23 5. Gerenciamento de Transações...25 5. Gerenciamento de Transações...25

Propriedade das Transações...25

Trans Transações Local versus Global...ações Local versus Global... 2626 Programática versus Declarativa...26

Programática versus Declarativa...26

6. Spring Security...27

Segurança de uma aplicação...27

Protegendo a camada de serviço...28

7. Spring AOP...29

Conceitos...29

Hello World – Spring Hello World – Spring AOP...AOP... .30.30 Escrevendo nossa lógica de negócios...30

(4)

1. Spring Framework

A v

A visão ger

isão geral do Spri

al do Spring Framew

ng Framework:

ork:

Spring

Spring é um padrão formado em uma estrutura leve de aplicativos corporativos.é um padrão formado em uma estrutura leve de aplicativos corporativos. SpringSpring éé

um

um framework framework ababerterto o e e cricriadado o parpara a embembarcarcar ar a a cocomplmplexexidaidade de do do desdesenvenvolvolvimeimento nto dede

aplicações corporativas. Uma das principais vantagens do

aplicações corporativas. Uma das principais vantagens do SpringSpring é a sua arquitetura emé a sua arquitetura em

camadas, permite que sejamos seletivos sobre quais de seus componentes que iremos camadas, permite que sejamos seletivos sobre quais de seus componentes que iremos utilizar para proporcionar um quadro coerente para o

utilizar para proporcionar um quadro coerente para o desenvolvimento de aplicações J2EE.desenvolvimento de aplicações J2EE. No entanto o

No entanto o SpringSpring está limitado ao lado servidor do desenvolvimento. Qualquer aplicaçãoestá limitado ao lado servidor do desenvolvimento. Qualquer aplicação

Java pode se beneficiar em termos de simplicidade, testabilidade, e

Java pode se beneficiar em termos de simplicidade, testabilidade, e baixo acoplamento.baixo acoplamento.

Módulos do Spring Framework

O

O SpringSpring possui uma arquitetura em camadas que consiste em possui uma arquitetura em camadas que consiste em sete módulos bem definidos.sete módulos bem definidos.

Os módulos mestres são construídos na parte superior do

Os módulos mestres são construídos na parte superior do Core Container Core Container , que define como, que define como

os

os beansbeans serão criados, configurados e geridos, como mostrado na seguinte figura:serão criados, configurados e geridos, como mostrado na seguinte figura:

Cada um desses módulos ou componentes consistem na estrutura do

Cada um desses módulos ou componentes consistem na estrutura do SpringSpring e podem ser e podem ser

aplicados em conjunto com um ou mais módulos ou

aplicados em conjunto com um ou mais módulos ou componentes.componentes.

Core Container Core Container ::

Proporciona a funcionalidade fundamental para o

Proporciona a funcionalidade fundamental para o SpringSpring. Neste, o componente primário é o. Neste, o componente primário é o

módulo

módulo BeanFactoryBeanFactory, sendo uma implementação do padrão de projeto, sendo uma implementação do padrão de projeto Abstract Abstract Factory Factory . . OO BeanFactory

BeanFactory aplica aaplica a InverInversão são de de ContControlerole ((IoC – Inversion of Control IoC – Inversion of Control ) padrão para) padrão para

sep

(5)

aplicativo real.

Módulo Contexto do Spring:

É um arquivo de configuração que fornece as informações de contexto para o Spring. Inclui

serviços corporativos tais como e-mail, JNDI, EJB, internacionalização, validação, programação de eventos do ciclo de vida de aplicações. Também está incluído o suporte

para a integração com templates como o Velocity .

Módulo Spring AOP:

Permite que um componente de software implemente, através do padrão de projeto

decorator , um comportamento adicional, através do recurso de gerenciamento de

configuração. Como resultado, é possível facilmente permitir AOP ( Aspect Oriented

Programming – Programação Orientada a Aspecto) em qualquer objeto gerenciado pelo Spring. Este módulo fornece serviços de gerenciamento de transações para os objetos em

qualquer aplicação baseada em Spring. É possível incorporar o gerenciamento de

transação declarativa em seus aplicativos, sem depender dos componentes EJB.

Módulo Spring DAO:

Fornece uma camada de abstração JDBC, que reduz a necessidade de fazer toda a

codificação e análise de banco de dados dos diferentes fornecedores e a transação dos códigos de erro específicos. Além disso, este módulo fornece uma nova maneira de realizar em modo de programação, o gerenciamento das transações declarativas, não apenas para

as classes que implementam interfaces especiais, mas para qualquer dos objetos POJO

(Plain Old Java Objects).

Módulo Spring ORM:

Fornece a integração com as ferramentas de mapeamento OR (Object Relational ) como

Hibernate, JDOe iBATIS. Suporta cada um dos frameworks ORM assim como JDBC. Módulo Spring Web:

Fornece os recursos básicos para a integração Web e constrói neste módulo um contexto de aplicação, fornecendo contextos de aplicativos baseados na Web. Como resultado, permite

que o Spring suporte a integração com o Struts. Este módulo também facilita as tarefas de

lidar com múltiplas partes para as requisições e parâmetros de solicitação da ligação de objetos de domínio.

Módulo Spring framework MVC:

Fornece uma arquitetura MVC (implementação do padrão de projeto Model – View – Control )

plugável. Os usuários têm a opção de usar o framework Web ou continuar a usar o seu

framework Web existente. O Spring separa as funções do controlador, o modelo de objeto, o

despachante do objeto manipulador que torna mais fácil sua personalização. O Spring não

obriga a utilização de codificação JSP para a camada de visão. O usuário possui a flexibilidade de utilizar JSP, modelos XSLT, Velocity, ou outros, para proporcionar a camada visão.

(6)

Exemplos de Aplicações

Exemplos de como um desenvolvedor de aplicativos, pode usar as vantagens da plataforma Spring:

• Um método Java para executar uma transação de banco de dados sem ter que lidar

com as APIs de transação.

• Um método Java local de um procedimento remoto sem ter que lidar com as APIs

remotas.

• Um método Java local para uma operação de gestão sem ter que lidar com APIs JMX.

• Um método Java local, com um manipulador de mensagens sem ter que lidar com

JMS API.

Às vezes as circunstâncias não permitem mudar completamente um quadro. O Spring não

força sua utilização total, não é uma solução “tudo ou nada”. Existem diversos front-ends

como o WebWork, Struts, Tapestry, ou outros frameworks que podem ser integrados com

base na camada intermediária, que permite utilizar os recursos de transação do Spring.

Precisamos simplesmente conectar a lógica de negócio usando um ApplicationContext e

(7)

2. Injeção de Dependência ou IoC

As aplicações Java, podem executar sobre uma gama de applets restritas a aplicações

n-camadas do lado do servidor das empresas – tipicamente consiste de objetos que colaboram para formar uma aplicação correta. Assim, os objetos em um aplicativo possuem dependências entre si.

Inversão de Controle está no coração do Spring. O conceito básico da inversão do padrão

de controle (também conhecido como injeção de dependência) é que não criamos os objetos, apenas descrevemos como devem ser criados. Não ligamos diretamente os componentes e serviços em conjunto ao código, mas descrevemos quais serviços são necessários para os componentes em um arquivo de configuração. O contêiner (no caso da

estrutura do Spring, o módulo IoC) é o responsável por ligar tudo.

A maneira mais fácil de entender a inversão de controle é vê-la em um exemplo. Este exemplo básico demonstra como é possível injetar as dependências do aplicativo através do recipiente.

É um código simples para desejar “Olá” e “Adeus”. Teremos duas interfaces HelloInterface

e ByeInterface conforme listado abaixo: A. Classe Domínio: 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); }

(8)

C. Interface: ByeService.java

package x25.com.tutorial.service; import x25.com.tutorial.domain.Name; public interface ByeService {

public String sayBye(Name name); }

Após a implementação dessas interfaces, o próximo detalhe é considerar como integrá-los de forma flexível. Observe que todos os métodos padrão SET serão implementados por um

Bean de configuração do Spring. Todas as dependências (isto é, as duas interfaces) podem

ser injetadas pela estrutura do Spring utilizando estes beans. Observe que o método

wishMe() utiliza os serviços para implementar o restante da aplicação. O arquivo hello.xml

e o arquivo de configuração do Spring.

D. Classe: HelloBean.java package x25.com.tutorial.bean; import java.util.Calendar; import x25.com.tutorial.domain.Name; import x25.com.tutorial.service.ByeService; import 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;

}

// Métodos de Domínio

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 {

(9)

return byeService.sayBye(name); }

} }

E. Arquivo de Configuração: 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 serviços. Temos várias maneiras de carregar o arquivo de configuração mestre (hello.xml) para a classpath. Neste

exemplo básico 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);

(10)

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

} }

Veja o código destacado na listagem acima. A classe TesteCliente carrega os arquivos de

configuração do Spring através de ClassPathXmlApplicationContext. Uma vez que os

beans são carregados, é possível acessá-los através do método getBean(), conforme

mostrado na Listagem. Na definição do HelloBean no arquivo hello.xml, que foi carregado

(11)

3. Spring e Hibernate

Introdução

Hibernate é um poderoso framework para a persistência de dados em qualquer tipo de

aplicação. Spring, por outro lado possui um módulo de injeção de dependência que suporta

IoC, isso permite que integre perfeitamente com a maioria das tecnologias populares.

Como pré-requisito devemos entender a necessidade da integração, antes de realmente

entrar na integração dessas duas tecnologias. É bem conhecido que o Hibernate é uma

poderosa ferramenta ORM, que se situa entre a aplicação e a base de dados. Permite que

aplicativos acessem os registros de qualquer banco de dados de maneira independente de plataforma. Não existe a necessidade da aplicação depender dos detalhes de baixo nível, como o gerenciamento da conexão JDBC, lidando com as declarações e conjuntos de resultados. Todos os detalhes necessários para acessar uma determinada fonte de dados é facilmente configurável 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 configuração: SessionFactory e Session.

Esses objetos continuam espalhados pelo código de todo o aplicativo. Além disso, o código

tem que manualmente manter e gerenciar esses objetos. No caso do Spring, esses objetos

de negócios podem ser altamente configuráveis com a ajuda do módulo de IoC. Em palavras

simples, o estado de um objeto pode ser exteriorizado do código do aplicativo. Isso significa

que é possível utilizar os objetos do Hibernate com os Beans do Spring e podemos

desfrutar de todas as comodidades que o Spring proporciona.

Amostra de Integração

Em vez de olhar para as APIs de integração que estão disponíveis no pacote do Spring,

vamos compreender essas APIs através de códigos de exemplo. As seções seguintes

abordam as diferentes etapas envolvidas na integração do Spring com o Hibernate.

1) Criação 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 instrução de cada comando. Uma vez que a base “exemplo” é criada, devemos abri-la com o comando:

use exemplo;

(12)

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 são 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 variáveis na classe Java com o tipo de dados apropriado.

A. Classe de Mapeamento: Empregado.java package x25.com.tutorial.mapa;

public class Empregado { private String matricula; private String nome;

private int idade;

private 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;

(13)

public void setSalario(double salario){ this.salario = salario;

}

public String toString(){ return "Matrícula: " + matricula + ", Nome: " + nome + ", Idade: " + idade + ", Salário: " + salario; } }

Observe que sobrepomos o método 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 aplicação. No entanto, não especificamos que a tabela deve ser mapeada para a classe Java e devemos mapear também os nomes das colunas da tabela para as variáveis

na classe Empregado. Vamos dar uma olhada no arquivo de mapeamento do Hibernate:

B. Arquivo de Configuração: 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>

Observe que o arquivo de mapeamento é um arquivo XML e seu nome por padrão é

empregado.hbm.xml. Este arquivo “hbm” é um arquivo de mapeamento reconhecido pelo

mapeamento do Hibernate. Embora não seja necessário seguir essa convenção, é fácil

descobrir que este é um arquivo do tipo XML e que deve estar em conformidade com um

DTD bem definido, com os mapeamentos padrões do hibernate-mapping-3.0.dtd.

(14)

pode definir um ou mais mapeamentos. Após 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 próxima série de elementos define o mapeamento dos nomes das coluna em relação as

suas variáveis homólogas de Java. O elemento 'id' é correspondente a um identificador para

uma linha usado como uma coluna de chave primária. O elemento “property” tem um

atributo chamado 'name' que aponta para o nome da variável Java, na sequência qual o

nome da coluna na tabela de banco de dados que é mapeado.

4) Criando o arquivo de configuração do Spring

Esta seção lida com a configuração de várias informações necessárias para o Spring. Todos

os objetos de negócios são configurados no arquivo XML e são chamados de Spring

Beans. Os Spring Beans são mantidos pelo IoC, que é fornecido ao cliente mediante uma

solicitação. Vamos definir uma fonte de dados:

C. Arquivo de Configuração: 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">

<!-- Outros Spring Beans –!> </beans>

A classe acima define uma fonte de dados do tipo BasicDataSource. Mais importante,

define as propriedades de conexão diferentes que são necessárias para acessar o banco de

dados. Para acessar o banco de dados MySql, precisamos de um driver padrão 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 é

necessário para se conectar a base de dados. A terceira e quarta propriedades representam o nome e senha do usuário para estabelecer uma sessão com o banco de dados.

O próximo Spring Bean representa uma implementação de um SessionFactoryBean.

Quando utilizamos o Hibernate, um SessionFactoryBean é responsável por criar os

objetos da sessão através do qual estaremos interagindo com a transação de dados. Porém, esse SessionFactoryBean será configurado pelo Spring através da adição do seguinte

código:

(15)

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 obrigatórios. O primeiro é a informação da fonte de dados que contém os detalhes para acessar o banco de dados. O próximo é uma lista de objetos que contém as informações 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 invólucro de baixo

nível de acesso a dados e para sua correta manipulação. Contém métodos 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 codificação: <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"> <property name="sessionFactory"> <ref bean="meuSessionFactory"/> </property> </bean>

A definição de um Final Bean é a classe DAO. Uma vez que esta classe foi definida a nível

da aplicação, pode conter qualquer número de métodos 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>

É feita uma referência à classe EmpregadoDao, discutida no item seguinte.

5) Definir a classe EmpregadoDao

Conforme descrito anteriormente, esta classe pode conter qualquer número de métodos 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

(16)

Classe: EmpregadoDao.java package x25.com.tutorial.dao; import java.sql.SQLException; import org.hibernate.HibernateException; import org.hibernate.Session; import org.springframework.orm.hibernate3.HibernateCallback; import 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 sessão) para o

acesso aos dados. Para instruir ao Spring acessar a API do Hibernate, colocamos a lógica

de negócio que faz uso da API em um determinado método bem definido e em uma interface

conhecida pelo Spring. Isto acontece com a interface HibernateCallback e o método

doInHibernate()com uma instância de uma sessão do Hibernate passada.

Definimos dois métodos: getEmpregado() e saveOrUpdate() na classe EmpregadoDao.

Para fazer o uso das APIs do Hibernate, definimos todo o código no método

HibernateCallback.doInHibernate() e informamos ao Spring para executar esse código,

(17)

6) Aplicativo cliente para teste

Para testarmos nosso ambiente, iremos criar uma classe que adiciona um novo empregado na base de dados e obtém o objeto deste.

Aplicativo Cliente: SpringHibernateTeste.java package x25.com.tutorial; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.Resource; import 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 método

BeanFactory.getBean("empregadoDao"), o Spring encontra todas as referências feitas na

definição do bean do EmpregadoDao. Criando um objeto de Hibernate Template. Em

seguida, é feita uma tentativa para inicializar este objeto onde uma sessão do objeto Bean

Factory é referenciado. Durante a construção do objeto Session Bean da Factory, as

informações da fonte de dados é resolvida juntamente com as tabelas do banco de dados e as classes Java.

O principal objetivo da integração do Spring ORM é a sobreposição clara da aplicação, com qualquer acesso de dados e a tecnologia de transação, e para o baixo acoplamento dos objetos da aplicação. Não existem mais dependências de serviços empresariais no acesso a dados ou estratégia de transação. Uma abordagem simples e consistente para os objetos de aplicação, mantendo-os como reutilizáveis e livres de dependências.

(18)

4. Spring e JPA

O padrão EJB 3.0 – Java Persistence API (JPA) foi lançado em maio de 2006 como parte

da plataforma Java Enterprise Edition 5 (Java EE). O que começou como um sucessor mais

fácil de usar para o tão difamado padrão Container-Managed Persistence (CMP) do

componente EJB, logo evoluiu para uma incorporação das melhores práticas existentes no uso da mais proeminente e popular object-relational (O-R) persistence products. O resultado é que os aplicativos possuem um padrão moderno, leve para a persistência de Java que pode-se usar em qualquer plataforma Java EE compatível com servidor de aplicação 5, ou em aplicações 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 aplicação e independente. Como a JPA, Spring é uma

tecnologia projetada para permitir que os aplicativos sejam construídos a partir de POJOs. O

Spring é executado dentro de qualquer contexto de tempo de execução de um aplicativo

que requer e suporta aplicações, fornecendo uma ampla gama de serviços. Alguns destes serviços são abstrações mais existentes de nível dos módulos de serviço, enquanto outros agregam valor ao recipiente Java EE.

A camada de acesso a persistência, é particularmente popular entre a comunidade Spring,

pois está muito bem integrado com qualquer tempo de execução e a persistência e facilitada por uma abordagem que permite trabalhar com objetos persistentes.

Spring como um Contêiner de JPA

A Java Persistence API foi arquitetada de forma que poderia ser utilizada tanto dentro como

fora da plataforma Java EE 5. Quando não há um recipiente para organizar os gerentes de entidade JPA e transações, este serviço deve ser mais a carga de gerenciamento.

Um dos objetivos da especificação do JPA foi fazer uma tecnologia plugável. Para permitir isso:

• Os papéis do provedor de recipientes – o recipiente ou o lado que tem o controle das

linhas de tempo de execução e transações.

• E o provedor de persistência – o fornecedor ou a parte que implementa a API de

persistência e gerencia as entidades persistentes.

• E uma interface de provedor de serviço (SPI – Service Provider Interface) – que liga

os dois na implantação e execução.

Um contêiner JPA host é compatível e deve ser implementado corretamente com o SPI a

partir da perspectiva do recipiente. Ou seja, um provedor de persistência compatível com

JPA implementa o SPI a partir da perspectiva do provedor. Se ambos os lados seguir essas

regras, um recipiente compatível deve ser capaz de executar qualquer implementação de provedor compatível, persistência e de mesma forma, um fornecedor deve ligar qualquer recipiente.

(19)

Embora o Spring não é um servidor de aplicação nem um contêiner Java EE 5, que faz

aumentar, e às vezes implementar muitos dos serviços utilizados em servidores de

aplicação. Spring implementa uma porção 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 JPAusam para ajudar a gerenciar as entidades em tempo

de execução.

Os usuários se beneficiam de um ambiente no qual o contêiner em tempo de execução e o

provedor de persistência JPA são totalmente integrados, não necessariamente em um

contexto da plataforma Java EE 5. Isto proporciona muitas das vantagens da persistência

Java EE sem a necessidade de um contêiner.

Definição das Entidades

A parte mais básica para se usar a JPA é projetar e criar as entidades a serem persistidas.

Vamos utilizar um sistema de Inventário de Livros como exemplo para o entendimento

deste capítulo.

Deste modo, vamos criar uma entidade LIVRO, definindo a classe e anotando-a com uma

anotação @Entity . O identificador de chave primária é o campo ISBN, por isso, devemos

anotar esse campo com @Id . Os campos título e autor serão mapeamentos básicos dos

campos de objeto para as colunas de mesmo nome na tabela de banco de dados. Teremos

um campo gênero para mapear para uma coluna da entidade CATEGORIA, para isso, uma

anotação @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, métodos padrão GET/SET, etc. }

Uma aplicação real teria muitas entidades, porém desejamos focar o uso da APP no Spring,

e não é 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

(20)

atualizar e excluir (Padrão CRUD). Atua como um gerente de todas as entidades carregadas e uma fábrica para consultas que permitem às entidades serem carregadas. Um gestor de

entidade é análogo a uma sessão TopLink do Oracle, sessão do Hibernate ou a uma

interface equivalente fornecido pelos diversos frameworksde mapeamento OR.

Por exemplo, para criar uma nova entidade persistente criamos um novo objeto Java do tipo

de entidade e invocamos o método persist() no gerenciador de entidade, e passamos a

nova entidade como parâmetro. Supondo que temos acesso a um gestor de entidade, o código 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 módulo gerenciador de entidade do Spring torna o trabalho muito simples.

Na maioria dos casos é uma questão de anotar um campo ou um método de um Spring

Bean com uma anotação @PersistenceContext 1_{, que faz com que um gestor de entidade}

seja injetado. Em seguida, invocar o gestor de entidade no contexto de uma operação de recipiente.

Utilizando o Spring, a transação pode ser iniciada e confirmada (commit) ou não (rollback)

na entrada ou saída do método. Para alcançar este objetivo é necessário ser realizado declarativamente a demarcação de uma transação automática que deve acontecer. No

Spring a maneira mais fácil de fazer isso é anotar a classe bean ou método com a anotação @Transactional , embora também seja possível a utilização de metadados XML que não

nescessitam anotar o código Java. O tipo de transação iniciada depende do tipo de

gerenciador de transações que está configurado no contexto da aplicação do Spring; o

conhecimento de sua infraestrutura de transação subjacente é completamente abstraída no código Java.

Um exemplo de um Spring Bean transacional e que utiliza um gestor de entidade para

executar operações 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); }

}

(21)

Esta classe é bastante comum, exceto pela presença de duas anotações adicionais,

@Transactional e @PersistenceContext . A anotação @Transactional define que todos os

métodos da classe obtenham uma transação automática, deste modo, uma transação será

fornecida sempre que é invocado o método addLivro(). Podemos ter facilmente o método

anotado diretamente para obter esse comportamento, mas a probabilidade de adicionar mais métodos que também precisam de uma transação é bastante elevada, então uma classe é a melhor forma de implementá-lo.

O atributo em será injetado como uma instância de EntityManager . O gestor de entidade

injetado será configurado de acordo com a unidade de persistência chamado referido no

atributo unitName da anotação @PersistenceContext . Unidades de persistência nomeados

são definidas e configuradas no arquivo de configuração persistence.xml da JPA e no

contexto do aplicativo Spring como parte do Factory Bean do EntityManager .

Configuração da Camada de Persistência

O arquivo de configuração padrão JPA é um arquivo XML denominado persistence.xml, e é

inserido no diretório META-INF do arquivo jar ou no classpath. Ao utilizar a JPA, na maioria

dos ambientes de execução este arquivo contém a maior parte das informações de

configuração em tempo de execução (exceto mapeamento O-R). Entretanto, ao usar JPAno

Spring, esse arquivo contém apenas a definição da unidade de persistência e, às vezes

uma lista das classes de entidade (se não for executado em um ambiente de implementação

do servidor). Um exemplo de um arquivo persistence.xmlcomo mostrado abaixo.

Arquivo de Configuração: persistence.xml

<class>x25.com.tutorial.Livro</class> </persistence-unit>

</persistence>

O tipo de transação também depende do ambiente de implantação. Neste exemplo, estamos executando um simples máquina virtual Java (VM) e não usamos o acesso a um gerenciador

de transações JTA, por isso, definimos o tipo de transação como um RESOURCE_LOCAL.

Configurando o Contexto da Aplicação

Cada aplicação do Spring deve, eventualmente, construir um contexto de aplicação – um

conjunto de definições em beans que especificam as dependências que um único bean tem

sobre os outros.

O Spring Bean é um componente na aplicação, que é configurado pelo Spring e elegido

para se beneficiar dos serviços oferecidos. O contexto de aplicação determina como os

beans se encaixam em tempo de execução e fornece a flexibilidade necessária para ligar as

(22)

Configurando o Entity Manager Factory Bean

Como parte do apoio para a JPA, o Spring fornece várias 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 disponível para a aplicação. Este bean

possui dependências que determinam os parâmetros de execução da APP, no Spring e,

embora muitas dessas configurações podem ser definidas no arquivo persistence.xml do

JPA, o contexto de aplicação pode proporcionar uma maior flexibilidade e capacidade de configuração. Fornece um estilo de configuração e experiência que é consistente com o que

os usuários estão acostumados no Spring.

A configuração do Entity Manager Factory Bean envolve três dependências principais: o

nome da unidade de persistência, 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 definição de bean é o EntityManagerFactory, que é o

ponto de partida para utilização da JPA.

O nome da unidade de persistência e a fonte de dados é definida da maneira usual. Spring

utiliza uma ou mais definições da plataforma Java 2 Standard Edition (J2SE) como fonte de dados e ponto de partida para a configuração de persistência. Um número de tipos de fontes de dados estão disponíveis, mas, neste caso, estamos usando um simples pool JDBC definida da seguinte forma:

A propriedade loadTimeWeaver especifica a estratégia que o Spring utiliza para

implementar um contêiner fornecedor de SPI e oferece a capacidade de weaving . Neste

exemplo, usamos o recurso de instrumentação 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 contêineres J2EE servidor (OC4J), devemos configurá-lo para

(23)

Configurando o Vendor Adapter

Realizamos uma dependência 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 específicas que são 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 persistência 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

configurações podem ser especificados independentemente da implementação do provedor que está sendo conectado. Isso facilita a mudança entre os prestadores de persistência diferentes ao minimizar as mudanças de configuração – algo que pode ajudar aos usuários a determinar quais provedores disponíveis apresenta um melhor desempenho ou pode atender melhor as necessidades da aplicação.

A seguinte definição do bean vendorAdapter com a propriedade jpaVendorAdapter . Define

TopLink como o fornecedor e fornece os valores para as três configurações comuns de

propriedade.

<bean id="vendorAdapter"

class="org.springframework.orm.jpa.vendor.TopLinkJpaVendorAdapter"> <property name="databasePlatform" value="${platform}"/>

A sequência da databasePlatform é entendido pelo provedor de persistência por isso

mesmo que o nome da propriedade é comum, os valores podem ser de diferentes fornecedores. Temos atribuído uma plataforma variável e definida em um aplicativo de contexto externo de propriedades.

Implementações como TopLink definem muito mais configurações JPA que podem ser

usados para configurar o provedor de maneiras que variam a especificação do tipo de cache para usar e declarar as classes personalizadas e os tipos de mapeamento. Estas propriedades adicionais são geralmente definidas como propriedades no arquivo

persistence.xml.

Outras Configurações

A próxima coisa que faremos é declarar a classe LivroInventarioSystem como um Spring

Bean. A definição de simples Bean apenas aponta ao Spring qual proxy e gerencia as

instâncias da classe e como serão criadas.

(24)

A seguir, vamos utilizar os recursos locais em nível de transações previstas pelo gerenciador

de entidades JPA, assim podemos definir um bean gerenciador de transações 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">

Este gerenciador de transações é projetado para suportar as conexões transacionais através

de JPA, também permite o acesso direto a JDBC utilizando a biblioteca do módulo de

abstração JDBC do Spring.

Realizamos um pouco de limpeza para indicar ao Spring que deve agir em qualquer

anotação @PersistenceContext e @Transactional encontrados na classe bean. Isto é feito

através da adição de dois elementos:

<bean class=

"org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/> <tx:annotation-driven/>

O namespace tx e o esquema adicionado ao topo da aplicação do arquivo de contexto XML

de modo que o espaço possa ser reconhecido.

Testes da Aplicação

Spring é projetado para facilitar as práticas ágeis de desenvolvimento – especialmente para

fazer testes mais fáceis do que no tradicional desenvolvimento Java EE. O uso de injeção

de dependência e de programação POJO permite que testes unitários sejam mais simples

de serem realizados.

Spring fornece uma poderosa integração com as facilidades de testes que permite o código

acessar dados persistentes e ser testado sem a necessidade da implantação de um servidor de aplicativos ou qualquer outro contêiner. Esta funcionalidade é empacotada no arquivo

spring-mock.jar incluído na distribuição do framework e permite os seguintes serviços: • Demarcação de transação automática. Cada teste é executado em sua própria

transação, que é revertida por padrão. Isso garante que cada teste pode ser

executado em sua própria sandbox sem produzir efeitos colaterais.

• Cache configurações. Uma configuração como a mapeamentos OR é carregado somente uma vez, assegurando que custos de inicialização não serão repetidos para cada teste.

• Injeção de dependência de casos de teste. Os casos de teste podem ser injetados como componentes de aplicação, tornando-os mais fáceis de desenvolver e inicializar. Em conjunto, esses serviços permitem que os testes podem ser escritos de forma rápida e facilmente executado em segundos. O exemplo a seguir mostra como facilmente podemos

(25)

Estendemos a classe de testes AbstractJpa, que é uma subclasse de TestCase do JUnit e,

então, especificar um dispositivo de localização de configuração. O suporte de ensaio será automaticamente injetado por dependência ao fornecer um método no padrão SET. Podemos fornecer qualquer número de métodos no padrão SET, sendo uma boa prática

testar um detalhe por vez. Devemos implementar o método getConfigLocations() para

retornar um array de configurações do Spring que deseja carregar. A maioria dos dados de

configuração é idêntico ao que foi utilizado em um cenário implantado, minimizando a quantidade de trabalho adicional necessário 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 número de métodos neste cenário. Estes podem acessar os

dados usando o nosso objeto de acesso a dados (DAO) de fixação ou o JdbcTemplate e

variáveis da instância 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 transação para verificar o comportamento correto do nosso DAO. Em primeiro lugar, consultamos o número de linhas na tabela LIVRO. Então adicionamos um livro, tendo a certeza de lavar a unidade de trabalho atual, usando o

método EntityManager.flush().

Isso obriga ao provedor de persistência para emitir o SQL necessário para a atualização. Agora podemos emitir outra consulta JDBC para verificar que adicionamos uma linha na

base de dados. Sabemos que o nosso DAO não se limita a executar, sem exceção, mas também faz mudanças necessárias em nosso banco de dados. Essas alterações serão

revertidas quando o método testAddLivro() for concluída, para que as alterações não sejam

(26)

5. Gerenciamento de Transações

Gerenciamento de transações é fundamental em qualquer tipo de aplicações que irão interagir com o banco de dados. A aplicação tem de assegurar que os dados são 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 integração com essas estruturas.

Propriedade das Transações

Uma transação é uma sequência de ações que são tratados como uma única unidade de trabalho. Essas ações devem ou completar totalmente ou tomar qualquer efeito. Gerenciamento de transações é uma parte importante de aplicações corporativas e RDBMS para garantir a integridade dos dados e consistência. O conceito de transações pode ser

descrito com as seguintes quatro propriedades essenciais descritas como ACID:

• Atomicidade: Uma transação deve ser tratada como única unidade de operação que significa que ou toda a sequência de operações é bem ou mal sucedidas.

• Consistência: Isto representa a consistência da integridade referencial do banco de dados, chaves primárias em tabelas, entre outras.

• Isolamento: Pode haver muitas transações de processamento com os mesmos dados ao mesmo tempo, cada transação deve ser isolada das outras para evitar corrupção de dados.

• Durabilidade: Uma vez que uma operação tenha completado, os resultados desta operação deve ser permanente e não 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 transação. A vista simplista de uma transação emitida para o banco de dados é usada em uma instrução SQL, como se segue:

• Iniciar a transação começando com o comando de transação.

• Realizar várias operações de manutenção de registros tais como, incluir, atualizar ou

excluir usando instruções SQL.

• Se toda a operação é bem sucedida em seguida, executar cometer outra forma de

reversão de todas as operações.

Spring oferece uma camada abstrata no topo das APIs de gestão subjacente transação

diferente. O apoio do Spring de transação tem como objetivo fornecer uma alternativa para

transações EJB, adicionando capacidades de transação para POJOs. Spring suporta o

gerenciamento de transações tanto programática quanto declarativa. EJB requer um

servidor de aplicação, mas o gerenciamento de transações Spring pode ser implementada

(27)

Transações Local versus Global

As transações locais são específicas para um único recurso transacional como uma conexão JDBC, enquanto que as operações globais podem se estender por vários recursos transacionais como transação em um sistema distribuído.

Gerenciamento de transações local pode ser útil em um ambiente de computação centralizada, onde os componentes do aplicativo e recursos estão localizados em um único site, e gerenciamento de transações envolve apenas um gerenciador de dados local executando em uma única máquina. As transações locais são mais fáceis de ser implementadas.

Gerenciamento de transações global é necessária em um ambiente de computação distribuída, onde todos os recursos são distribuídos através de múltiplos sistemas. Em tal gerenciamento de transações de um caso precisa ser feito tanto a nível local e global. A distribuição ou uma transação global é executado em vários sistemas, e sua execução requer coordenação entre o sistema global de gerenciamento de transações e todos os gerentes de dados locais de todos os sistemas envolvidos.

Programática versus Declarativa

Spring suporta dois tipos de gerenciamento de transações:

• Gestão programática de transação: Isso significa gerenciar a transação com a ajuda de programação. Isso proporciona extrema flexibilidade, mas é difícil de manter. • Gerenciamento de transação declarativa: Isto significa que o gerenciamento de

transações separado do código de negócios. Usar as anotações ou configuração baseado em XML para gerenciar as transações.

Gerenciamento de transação declarativa é preferível a gestão programática de transação, embora seja menos flexível do que a gestão programática de transação, que lhe permite controlar transações através de seu código. Mas como uma espécie de preocupação transversal, gerenciamento de transações declarativo pode ser modulado com a abordagem AOP.

(28)

6. Spring Security

Spring Security, é uma autenticação flexível e poderoso e uma estrutura de controle de

acesso para garantir Primavera baseado em Java aplicação Web. Usamos o Spring

Security para fornecer uma forma de autenticação de login simples para garantir o acesso à

URL em aplicação Web.

É uma forte autenticação e altamente personalizável e de controle de acesso quadro. É o padrão de fato para garantir Primavera aplicações baseadas sendo um dos projetos mais

maduros do Spring e amplamente utilizado. Possui as seguintes características:

• Ativar a segurança Web e proteger os padrões de URL diferentes em um aplicativo

• Usar um formulário de login com base em autenticação contra um repositório de

memória de usuários 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 básico que

vem com o Spring Security. É mais instrutivo para aumentar a segurança para um aplicativo

da Web existente, por isso primeiro devemos remover a configuração de segurança existente na aplicação, e, em seguida, adicionar gradativamente as opções de configuração necessárias para satisfazer as nossas necessidades. Pode-se fazer mais do isto, basta

modificar o arquivo WAR que vem com a distribuição do Spring Security, mas para obter

melhores resultados, recomendamos a criação do código de amostra em si mesmo.

Segurança de uma aplicação

Agora estamos prontos para adicionar um pouco de segurança. Nós não vamos substituir a configuração original exatamente, mas vão construir uma nova configuração em etapas para satisfazer um determinado conjunto de requisitos.

Do ponto de vista do aplicativo, vamos imaginar que existem três perfis de usuário, "supervisor", "caixa" e "usuário". Queremos aplicar os seguintes controles de acesso:

• Estar autenticado para acessar qualquer registro

• Páginas no diretório "/secure" só deve ser visível para usuários autenticados

• Páginas no diretório "/secure/extreme" só deve ser visível para o perfil supervisor

• Apenas os perfis caixa e supervisor podem realizar saques ou depósitos

• Somente o perfil supervisor pode exceder o limite de cheque especial

• Exigir autenticação para acessar uma determinada URL

Em geral, é uma boa prática negar o acesso por padrão, ao invés de apenas garantir os recursos que precisamos. Com isso em mente, vamos mudar o bloco <http> e adicionar alguns controles de acesso à Web

(29)

<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 serviço

Spring Security também permite que a adição de segurança para chamadas de método

feitas através dos Spring Beans no contexto do aplicativo. Esta é uma abordagem mais

poderosa que os padrões URL. Para ser capaz de fazer essas alterações, precisamos ser capaz de criar um código de amostra, portanto o ideal seria e seguir as instruções sobre como obter e construir uma base.

Para ativar a segurança método é necessário adicionar o seguinte elemento no arquivo de contexto de aplicação (acima do elemento <http>):

<global-method-security pre-post-annotations="enabled" />

Isso permite o uso de anotações de segurança em interfaces ao Spring. A principal interface

para o aplicativo de exemplo é chamado BankService e possui uma anotação necessária

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 anotação @PreAuthorize contém uma linguagem de expressão Spring que encapsula a

lógica de nossa exigência final. Ao executar o aplicativo, receberemos uma exceção se exceder o montante descoberto sem acesso supervisor. As expressões são uma ferramenta poderosa, mas devemos ser cuidadosos para construir a lógica excessivamente complicado.

(30)

7. Spring AOP

Spring AOP é um paradigma de nova programação, implementada em Java e não ocorre a necessidade de um processo de compilação especial. Não é necessário controlar a hierarquia do carregador de classe, e é portanto adequado para o uso em um contêiner Java Web ou um servidor de aplicação de Java EE.

É uma outra maneira de pensar sobre a estrutura do programa em termos de aspectos ou preocupação. Se compararmos AOP com OOP (Programação orientada a objetos), a OOP decompõe a aplicação em hierarquia de objetos onde, como o AOP decompõe a aplicação em Aspectos ou “preocupação”. Programação Orientada a Aspectos (AOP) complementa a Programação 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 preocupações, como o gerenciamento de transações que atravessam vários tipos e objetos. (Tais preocupações são muitas vezes chamado de interesses transversais em literatura AOP).

Um dos componentes chave da AOP. Enquanto que o módulo IoC não depende AOP, ou seja, não é necessário usar AOP se você não quiser, AOP complementa IoC para fornecer uma solução de middleware.

Conceitos

Aspecto – é um subprograma que está associado com uma propriedade específica de um

programa. Como essa propriedade varia, o efeito "ondulações" através de todo o programa. É a funcionalidade ou característica que atravessa sobre o objeto. AOP também aumenta a modularidade de um programa.

Um aspecto é disperso em virtude da função que está sendo lido por um número de funções não relacionadas. Isso significa mudar de uma função requer a modificação de todos os módulos afetados. Como o código tornando-o mais difícil de entender e manter.

Aviso – é uma ação tomada pelo aspecto em um determinado ponto comum. É um pedaço

de código que é executado durante a execução do programa. Existem vários tipos de conselho, dependendo da posição são chamados de um programa.

Tipos de Aviso:

Antes: Um aviso que executou antes de um ponto de junção (jointpoint). Um aviso do tipo

antes não tem a capacidade de interromper o fluxo de um processo de execução no ponto de articulação, a menos que ele lance uma exceção.

Depois de Retornar : Um aviso que executou depois de um ponto de junção concluído

normalmente. Por exemplo, um método retorna sem lançar uma exceção.

Em Torno: Responsável pela escolha de se proceder a um ponto de junção ou um atalho

(31)

comportamento personalizado antes e depois da invocação de método por em torno de um ponto de junção.

Depois de Lançar um Aviso: Executado quando um método gera uma exceção.

Depois de (finalmente) um aviso: Executado quando o programa sai do ponto de junção

normalmente ou lança uma exceção.

Weaving – Processo de vinculação ao aspecto com outro aplicativo ou objeto para criar um

tipo de conselho. Isso é realizado no Spring em tempo de execução.

Ponto de Junção – Um ponto utilizado no Spring AOP para representar a execução de um

método. Aponta durante a execução do programa ou métodos ou exceções. Inicia com métodos, intercepta AOP e neste momento para fazer algumas outras coisas. isto é, início dos métodos doThis(), doExtra(), test(), somethingElse(), entre outros.

Objeto-alvo: objeto que está sendo assessorado por um ou mais aspectos. Também

conhecido como o objeto aconselhou. O Spring AOP é implementado usando proxy de tempo de execução, este objeto é um objeto no padrão proxy.

Proxy AOP: um objeto criado pelo framework AOP para implementar os contratos de

aspecto (aconselhar execuções método e assim por diante). No Spring, um proxy AOP será um proxy JDK dinâmico ou um proxy CGLIB.

Hello World – Spring AOP

Escrevendo nossa lógica de negócios

Neste tutorial vai aprender como configurar o Spring AOP usando um BeanFactory.

HelloInterface.java

public interface HelloInterface { public void sayHello();

public void greet(); }

HelloWorldImpl.java

public class HelloWorldImpl implements HelloInterface { @Override

public void greet() {

System.out.println("Tenha um Bom Dia !!!"); }

@Override

public void sayHello() {