Springframework Jobson Ronan

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ções mais 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 Factory public 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 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" " Bem vindos

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, , 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,...}; jdbcTemplate.update(sql, params, types); }

Spring DAO Operações também podem ser modeladas como objetos public class UpdateCustomer extends SqlUpdate { public UpdateCustomer(DataSource ds) { setDataSource(ds); setSql(“update customer set… values (?,?..)”); 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 JdbcDaoSupport implements 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... <bean id=“sessionFactory” class=“org.springframework.orm. hibernate3.LocalSessionFactoryBean”> org.hibernate.dialect.MySQLDialect Customer.hbm.xml...

Integração ao Hibernate Exemplo de configuração (cont) com.mysql.jdbc.Driver jdbc:mysql://localhost/jea sa

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 HibernateDaoSupport implements 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 T1SuspensaT1 T2 SuspensaT1 T3 Início A=0 B=0 C=0 A=5 sucesso A=5 B=3 falha C=8C=0 Fim A=5 B=0 C=0 B=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... <bean id=“customerService” class=“org.springframework.transaction. interceptor.TransactionProxyFactoryBean”> PROPAGATION_REQUIRED, readOnly PROPAGATION_REQUIRED...

Transações com Spring Exemplo (cont)... <bean id=“transactionManager” class=“org.springframework.orm. hibernate3.HibernateTransactionManager”>...

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 service public interface AccountService { public void insertAccount(Account acc); public List getAccounts(String name); } //... and corresponding implement doing nothing at the moment public 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 AccountService example.AccountService 1199

Spring Remoting Para acessar nosso serviço remoto basta usar um RmiProxyFactoryBean E pronto! rmi://HOST:1199/AccountService example.AccountService

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