springframework jobson ronan {jrjs@cin.ufpe.br}. o que é o springframework? spring é um framework...
Post on 07-Apr-2016
224 Views
Preview:
TRANSCRIPT
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}
top related