Springframework

Jobson Ronan {jrjs@cin.ufpe.br}

O que é o Springframework?

Spring é um framework “leve” de inversão de controle(IOC) e orientação a aspectos(AOP)

Torna o desenvolvimento de aplicaçõesmais fácil e mais interessante!

Como assim?

Como Spring ajuda os desenvolvedores J2EE: Oferece um container leve de JavaBeans que elimina a

necessidade de escrever códigos repetitivos “de encanador” como lookups

Oferece um framework de inversão de controle que permite as dependências dos beans serem descobertas durante a instanciação

Permitir que cross cutting concers como gerenciamento de transações ser aplicado aos beans como Aspectos ao invés ser escrito no objeto de negócio

Oferecer camadas de abstração sobre tecnologias populares como JDBC e Hibernate que facilite seu uso e organize o gerenciamento de configuração

Como assim?

Tudo isso seguindo alguns principios: O Código de sua aplicação não deve depender da API do

Spring Spring não deve competir com boas soluções existentes mais

sim promover integração Escrever código testável é crítico e o container deve ajudar(não

interferir) nesse objetivo Usar o Spring deve ser um prazer!

Visão geral

Sobre a arquitetura

Spring pode ser usado em uma variedade de situações Aplicações web Aplicações que envolvem EJBs ou outros serviços Aplicações que acessem uma ou mais recursos(BDs)

Apesar disso, Spring lidera os chamados frameworks para o Desenvolvimento “leve” de aplicações J2EE Realmente precisamos de serviços pesados, como EJB,

providos pelos tradicionais Servidores de aplicação J2EE?

Relembrando o que é IoC?

Um modo de remover as dependências entre os objetos “injetando” as referências para os colaboradores sobre demanda (Dependency Injection)

O framework de IOC determina como os objetos serão injetados, normalmente através de um arquivo de configuração XML

Modo tradicional

...private AccountService accountService = null;

public void execute(HttpServletRequest req, ...) throws Exception { Account account = createAccount(req); AccountService service = getAccountService(); service.updateAccount(account);}

private AccountService getAccountService() throws ... { if (accountService == null){ Context ctx = new InitialContext(); Context env = (Context)ctx.look p("java:comp/env"); Object obj = env.lookup("ejb/AccountServiceHome"); AccountServiceHome home = (AccountServiceHome) PortableRemoteObject.narrow(env,Acco ntService.class); accountService = home.create(); } return accountService;}...

Modo Spring

Com Spring, o container de IOC ira cuidar da injeção de uma apropriada implementação

..private AccountService accountService = null;

public void setAccountService(AccountService accountService){ this.accountService = accountService;}

public void execte(HttpServletRequest req, ...) throws Exception { Account account = createAccount(req); accountService.updateAccount(account);}...

O Container de Beans

É o núcleo do Spring famework Usa IOC para gerenciar os componentes que compõem

uma aplicação Componentes são expressos como simples Java Beans O Container gerencia as relações entre os Beans e é

responsável por sua configuração O Container gerencia o ciclo de vida dos Beans

Tipos de Containers

Bean Factory Dá suporte básico a injeção de dependência Configuração e gerenciamento do ciclo de vida

Application Context Construido sobre o Bean Factory adicionando serviços de:

Resolução “mensagens” através de arquivos de propriedades para internacionalização

Carregamento de recursos genéricos Publicação de eventos

Bean Factorypublic interface Greeting { String greeting();}

public class WelcomeGreeting implements Greeting { private String message;

public void setMessage(String message) { this.message = message; }

public String getGreeting() { return message; }}

Bean Factory

...salvo em um arquivo chamado, por exemplo, myapp.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=“greeting” class=“WelcomeGreeting”> <property name=“message”> <value>Bem vindos</value> </property> </bean></beans>

Bean Factory

Saída no console:> Bem vindos

...public static void main(String[] args) {

BeanFactory factory = new XmlBeanFactory( new FileInputStream(“foo.xml”));

Greeting greeting = (Greeting) factory.getBean(“greeting”);

System.out.println(greeting.getGreeting());}

Bean Factory

Características dos managed beans Singletons por default Propriedades setadas por Dependency Injection

Referência para outros managed beans Strings Tipos primitivos Coleções (lists, sets, map, props) Inner Beans

Parâmetros podem ser extraídos para arquivos de propriedades

Spring DAO + Spring ORM

Spring como suporte a camada de negócio

O que temos?

Uma camada de abstração para persistência de dados utilizando um ou mais das seguintes tecnologias JDBC Hibernate, OJB JDO iBatis

Uma robusta infra-estrutura para o gerenciamento de transações de forma declarativa que suporta tanto transações locais como transações distribuídas através da JTA

Uma camada simplificadora para tecnologias de distribuição incluindo EJBs, RMI, e Web Services

Útil suporte a JNDI, JMS, email, e agendamento de tarefas(task scheduling)

Spring DAO

Possui uma API de acesso a dados que ajuda a isolar e melhorar o modo como o dado é servido pela camada de negócio

Uma consistente e rica hierarquia de exceções suficiente para mapear exceções específicas dependentes de tecnologia para outras exceções genéricas

Além de uma série de templates e wrapper classes para se trabalhar com JDBC, Hibernate, JDO, etc.

JDBC Tradicional

public void updateCustomer(Customer customer) { Connection conn = null; PreparedStatement ps = null; try { conn = getConnection();ps = conn.prepareStatement(“update customer set ” +“firstName = ?, lastName = ?, ...”);ps.setString(1, customer.getFirstName());ps.setString(2, customer.getLastName());ps.executeUpdate(); } catch (SQLException e) { log.error(e); } finally {try { if (ps != null) ps.close(); }catch (SQLException e) {log.error(e);}try {if (conn != null) conn.close();} catch (SQLException e) {log.error(e);} }

}private Connection getConnection() {

//... Mais código de encanador}

Spring DAO

Usando um template jdbc do spring

O jdbcTemplate pode ser injetado pelo container...

public void updateCustomer(Customer customer) { String sql = “update customer set ” +

“firstName = ?, lastName = ?, ...”); Object[] params = new Object[] { customer.getFirstName(), customer.getLastName(),

...}; int[] types = new int[] { Types.VARCHAR, Types.VARCHAR,

...}; jdbcTemplate.update(sql, params, types);

}

Spring DAO

Operações também podem ser modeladas como objetospublic class UpdateCustomer extends SqlUpdate {

public UpdateCustomer(DataSource ds) { setDataSource(ds); setSql(“update customer set… values (?,?..)”); declareParameter(new SqlParameter(Types.VARCHAR)); declareParameter(new SqlParameter(Types.VARCHAR)); //... compile();

} public int update(Customer customer) { Object[] params = new Object[] {

customer.getFirstName(), customer.getLastName()

}; return update(params); }

}

Spring DAO

Usando o objeto UpdateCustomer

A classe UpdateCustomer pode ser uma inner class

public class JdbcCustomerDao extends JdbcDaoSupportimplements CustomerDao {

private UpdateCustomer updateCustomer;

protected void initDao() throws Exception {super.initDao();updateCustomer = new UpdateCustomer(getDataSource()); }

public void updateCustomer(Customer customer) {updateCustomer.update(customer); }

}

Integração ao Hibernate

Spring prove um bean SessionFactory que simplifica a configuração e o gerênciamento de sessões em objetos de negócio

Uma classe HibernateTemplate Uma classe HibernateDaoSupport que pode ser herdada

para maior abstração Gerenciamento e mapeamento das HibernateException´s Facilmente plugável ao framework de Transações do

Spring

Integração ao Hibernate

Exemplo de configuração...<beans> <bean id=“sessionFactory” class=“org.springframework.orm.

hibernate3.LocalSessionFactoryBean”> <property name=“dataSource”> <ref bean=“dataSource”/> </property> <property name=“hibernateProperties”> <props> <prop key=“hibernate.dialect”>

org.hibernate.dialect.MySQLDialect </prop>

</props> </property> <property name=“mappingResources”> <list><value>Customer.hbm.xml</value></list> </property></bean>...

Integração ao Hibernate

Exemplo de configuração (cont)<bean id=“customerDao” class=“HibernateCustomerDao”> <property name=“sessionFactory”> <ref bean=“sessionFactory”/> </property></bean><bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close"> <property name="driverClassName"> <value>com.mysql.jdbc.Driver</value> </property> <property name="url"> <value>jdbc:mysql://localhost/jea</value> </property> <property name="username">

<value>sa</value></property><property name="password">

<value></value></property>

</bean>

Integração ao Hibernate

Customer DAO...

Simples e limpo! O uso do HibernateTemplate é bastante semelhante ao do objeto

Session do hibernate Existe suporte semelhante para outras tecnologias ORM como

iBatis, JDO e OJB

public class HibernateCustomerDao extends HibernateDaoSupportimplements CustomerDao

{

public void updateCustomer(Customer customer) { getHibernateTemplate().update(customer); }}

Transações com Spring: Motivação

Ambientes gerenciados com EJBs permitem uma tratamento declarativo de transações

Fora do código, descreve-se, para cada método transacional, suas características transacionais

Ex: “método x da classe br.org.citi.XYZ deve representar uma transação”

Elimina uma grande quantidade de código repetitivo Facilita a manutenção Entre outros

Transações com Spring: Motivação

Porém, já falamos muito mal dos EJBs neste curso Queremos ter os mesmo benefícios... Mas só os

benefícios

Transações com Spring

Suporte para gerenciamento programático e declarativo de transações

Transações locais são delegadas pelo Spring para o gerente de transações do data-source

Quando múltiplos recursos estão envolvidos (transações distribuídas), Spring delega para o gerente de transações JTA obtido através do JNDI

Apenas algumas pequenas mudanças são necessárias para trocar entre local e JTA

Transações com Spring

Gerenciamento Declarativo (+) Usa AOP para encapsular chamadas a objetos transacionais

com código de begin e commit de transações Comportamento de propagação

Mandatory, Never, Not Supported, Required, Requires New, Support, Nested

Similar a EJBs Também suporta níveis de isolação

Default, Read Uncommitted, Read Committed, Repeatable Read, Serializable

Modelo transacional

Normalmente o modelo flat transactions Se método é chamado dentro de uma transação, ele

pode continuar transação anterior Se ele falhar, transação inteira é revertida

Se nova transação for iniciada no método que já faz parte de uma transação, ela é independente Se falhar, pode sinalizar rollback() para desfazer transação

externa (ou não, e permitir que transação externa continue) O possível rollback da transação externa não afetará outras

transações (T2) cujos resultados já foram cometidos

Modelo transacional

T1 Suspensa T1

T2

Suspensa T1

T3

Início

A=0

B=0

C=0

A=5

sucesso

A=5

B=3 falha

C=8 C=0

Fim

A=5

B=0

C=0B=0

Comportamento de propagação

Mandatory Indica que o método só pode ser chamado no escopo de uma

transação do cliente Se o método for chamado fora de uma transação, ele causará uma

exceção Never

Indica que o método nunca pode estar dentro de uma transação Se o cliente que chama o método for parte de uma transação, ele

causará uma exceção

Comportamento de propagação

NotSupported Indica que o método não suporta transações

Se o método for chamado pelo cliente no escopo de uma transação, a mesma será suspensa enquanto durar a chamada do método (não haverá propagação de transações do cliente)

Required Indica que o escopo de uma transação é requerido pelo

método Se não existe transação, uma nova é criada e dura até que o método

termine (é propagada para todos os métodos chamados) Se já existe uma transação iniciada pelo cliente, o bean é incluído no

seu escopo durante a chamada do método

Comportamento de propagação

Requires New Indica que o método requer uma nova transação

Estando ou não o cliente no escopo de uma transação, o bean irá iniciar uma nova transação que iniciará e terminará no bean.

Support Indica que o método suporta transações

Será incluído no escopo da transação do cliente se existir Se ele for chamado fora do escopo de uma transação ele

realizará suas tarefa sem transações e pode chamar objetos que não suportam transações

Transações com Spring

Declarando atributos

PROPAGATION, ISOLATION, readOnly, -Exceptions, +Exception

Comportamento de propagação

Grau de isolamento[opcional]

Transação somente de leitura?[opcional]

Regras de Rollback

[opcional]

Os atributos são declarados no arquivo de definição dos beans

Transações com Spring

Exemplo...<beans><bean id=“customerService” class=“org.springframework.transaction.

interceptor.TransactionProxyFactoryBean”> <property name=“transactionManager”> <ref bean=“transactionManager”/> </property> <property name=“target”> <ref bean=“customerServiceTarget”/> </property> <property name=“transactionAttributes”> <props> <prop key=“get*”>PROPAGATION_REQUIRED, readOnly</prop> <prop key=“store*”>PROPAGATION_REQUIRED</prop> </props> </property><bean>...

Transações com Spring

Exemplo (cont)...<bean id=“customerServiceTarget” class=“CustomerServiceImpl”> <property name=“customerDao”> <ref bean=“customerDao”/> </property></bean><bean id=“transactionManager” class=“org.springframework.orm.

hibernate3.HibernateTransactionManager”> <property name=“sessionFactory”> <ref bean=“sessionFactory”/> </property></bean><bean id=“customerDao” class=“HibernateCustomerDao”> <property name=“sessionFactory”> <ref bean=“sessionFactory”/> </property></bean>...

Transações com Spring

E pronto! Nada de código com begin, commit e rollback!

O que mais?

Spring Remoting Distribuição com RMI, WebServices e outros extremamente

facilitada Considere as seguintes classes

// Account servicepublic interface AccountService { public void insertAccount(Account acc); public List getAccounts(String name);}

// ... and corresponding implement doing nothing at the momentpublic class AccountServiceImpl implements AccountService { public void insertAccount(Account acc) { // do something } public List getAccounts(String name) { // do something }

Spring Remoting

Exportando nosso objeto como uma serviço RMI Usa-se o RmiServiceExporter

<bean id="accountService" class="example.AccountServiceImpl"> <!-- any additional properties, maybe a DAO? --></bean>

<bean class="org.springframework.remoting.rmi.RmiServiceExporter"> <property name="serviceName"><value>AccountService</value></property> <property name="service"><ref bean="accountService"/></property> <property name="serviceInterface"> <value>example.AccountService</value> </property> <!-- defaults to 1099 --> <property name="registryPort"><value>1199</value></property></bean>

Spring Remoting

Para acessar nosso serviço remoto basta usar um RmiProxyFactoryBean

E pronto!

<bean id="accountService" class="org.springframework.remoting.rmi.RmiProxyFactoryBean"> <property name="serviceUrl">

<value>rmi://HOST:1199/AccountService</value> </property> <property name="serviceInterface">

<value>example.AccountService</value> </property></bean>

Spring Remoting

Isso que é distribuição transparente! A camada de distribuição desapareceu do código

Java! Agora é só XML!

Conclusões

O spring é um framework para todas as a camadas

O seu uso aumenta a manutenibilidade do sistema consideravelmente

Ainda existe um framework, ageci, sub-projeto do Spring, para gerenciamento de segurança declarativo!

Exercícios

Altere a camada de dados da nossa aplicação com o Spring (usar Spring DAO + Spring ORM).

Altere o gerenciamento de transações de nossa aplicação para usar o framework de transações do Spring.

Transforme sua fachada em um serviço remoto. Teste tudo!

Springframework

Jobson Ronan {jrjs@cin.ufpe.br}