Spring Inversão de Controle, Desenvolvimento leve, Orientação a aspectos,... Ricardo Cavalcanti Jobson Ronan

Apresentação em tema: "Spring Inversão de Controle, Desenvolvimento leve, Orientação a aspectos,... Ricardo Cavalcanti Jobson Ronan"— Transcrição da apresentação:

1 Spring Inversão de Controle, Desenvolvimento leve, Orientação a aspectos,... Ricardo Cavalcanti roc3@cin.ufpe.br Jobson Ronan jrjs@cin.ufpe.br

2 O que é?  Spring é um framework “leve” de inversão de controle(IOC) e orientação a aspectos(AOP) Torna o desenvolvimento de aplicações J2EE mais fácil e interessante!

3 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

4 Como é?  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 empolgante

5 Visão geral

6 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)

7 Sobre a arquitetura  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?

8 Mas 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

9 Benefícios  Remove a responsabilidade de encontrar ou criar objetos dependentes, movendo-a para a configuração  Reduz o acoplamento entre implementações de objetos e encoraja o design baseado em interfaces  Permite a aplicação ser reconfigurada fora do código  Pode encorajar a escrever código “testável”

10 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; }...

11 Modo tradicional  Ainda podemos usar padrões de projeto como “Service Locators” ou “Factories”

12 Modo Spring.. 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); }... Com Spring, o container de IOC ira cuidar da injeção de uma apropriada implementação

13 Conceitos de AOP  Aplicações devem estar possuir interesses como:  Gerenciamento de transações  Logging  Seurança  Essas responsabilidades devem pertencer a implementação das classes?  Nossa classe AccountService deve ser ser responsavel pelo gerenciamento de transação, logging e segurança?

14 //... public class AccountService { public void updateAccount(updateAccount acount) throws Exception { SecurityManager.requireUserRole(“admin”); TransactionManager.beginTransaction(); try { //...código de negócio TransactionManager.commit(); log.info(“acount updated”); } catch (Exception e) { TransactionManager.rollback(); log.warning(“exception throw”, e); throw e; } ///... Conceitos de AOP  Implementação tradicional com todos estes interesses Segurança Transações Logging

15 Conceitos de AOP  Esses interesses são chamados de interesses atravessadores (Cross cutting Concerns)  Sua implementação atravessa a implementação de toda uma classe ou até mesmo várias classes (como logging)

16 Conceitos de AOP  Com AOP separamos esses interesses e definimo-os como um advice  Before Advice  After Advice  Around Advice  Throws Advice  E baseado em certos critérios (Pointcuts), estes são inseridos na aplicação (Weaver)

17 Tipos de AOP  AOP Estático  Aspectos são tipicamente introduzidos ao byte code em tempo de compilação ou através de classloaders customizados em tempo de execução AspectJ (byte code) JBoss AOP, AspectWerkz (classloader)  AOP Dinâmico  Cria proxies para todos os objetos interessados  Leve perda de performance  Fácil de configurar Spring

18 Em detalhes... O Container de Beans do Spring

19 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 controla o ciclo de vida dos Beans

20 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

21 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 greeting() { return message; }

22 Bean Factory <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> Bem vindos...salvo em um arquivo chamado, por exemplo, myapp-config.xml

23 Bean Factory... public static void main(String[] args) { BeanFactory factory = new XmlBeanFactory( new FileSystemResource(“myapp-config.xml”)); Greeting greeting = (Greeting) factory.getBean(“greeting”); System.out.println(greeting.greeting()); } Saída no console: Bem vindos

24 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

25 Spring como suporte a camada de negócio Spring DAO + Spring ORM

26 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)

27 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  Mais 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.

28 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 }

29 Spring DAO  Usando um template jdbc do spring 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); } O jdbcTemplate pode ser injetado pelo container...

30 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); }

31 Spring DAO  Usando o objeto UpdateCustomer 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); } A classe UpdateCustomer pode ser uma inner class

32 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

33 Integração ao Hibernate  Exemplo de configuração... <bean id=“sessionFactory” class=“org.springframework.orm. hibernate.LocalSessionFactoryBean”> net.sf.hibernate.dialect.MySQLDialect Customer.hbm.xml Continua...

34 Integração ao Hibernate  Exemplo de configuração (cont) <bean id=“dataSource” class=“org.springframework.jndi. JndiObjectFactoryBean”> java:comp/env/jdbc/myDataSource

35 Integração ao Hibernate  Customer DAO... public class HibernateCustomerDao extends HibernateDaoSupport implements CustomerDao { public void updateCustomer(Customer customer) { getHibernateTemplate().update(customer); }  Simples e limpo!  Existe suporte semelhante para outras tecnologias ORM como iBatis, JDO e OJB

36 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 involvidos (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

37 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

38 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

39 Transações com Spring  Exemplo... <bean id=“customerService” class=“org.springframework.transaction. interceptor.TransactionProxyFactoryBean”> PROPAGATION_REQUIRED, readOnly PROPAGATION_REQUIRED... Continua...

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

41 AOP com Spring  Em prática public interface IBusinessLogic { public void foo(); } public class BusinessLogic implements IBusinessLogic { public void foo() { System.out.println( “Inside BusinessLogic.foo()” ); }

42 AOP com Spring  Em prática import org.springframework.context.ApplicationContext; import org.springframework.context.support.FileSystemXmlApplicationContext; public class MainApplication { public static void main(String [] args) { // Read the configuration file ApplicationContext ctx = new FileSystemXmlApplicationContext("springconfig.xml"); //Instantiate an object IBusinessLogic testObject = (IBusinessLogic) ctx.getBean("businesslogicbean"); // Execute the public // method of the bean testObject.foo(); }

43 AOP com Spring  Uma vez que nossa MainApplication chama o método ctx.getBean() ela abre mão da instanciação e gerênciamento do Bean para o Spring  Controlando a inicialização do nosso objeto, o Spring implementa todas as tarefas de gerenciamentos requeridas por aplicações J2EE  Isso, claro, antes que nosso objeto seja utilizado pela aplicação

44 AOP com Spring  springconfig.xml <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <bean id="businesslogicbean" class="org.springframework.aop.framework.ProxyFactoryBean"> IBusinessLogic

45 AOP com Spring  Diagrama de seqüência

46 AOP com Spring  Implementando um Advice import java.lang.reflect.Method; import org.springframework.aop.MethodBeforeAdvice; public class TracingBeforeAdvice implements MethodBeforeAdvice { public void before(Method m, Object[] args, Object target) throws Throwable { System.out.println("Hello world! (by " + this.getClass().getName() + ")"); }

47 AOP com Spring  Para acoplar o Advice a determinados joinpoints de nossa aplicação prescisamos acrescentar algumas declarações no springconfig.xml... <bean id="theTracingBeforeAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">.*... Aplicado por expressões regulares!

48 AOP com Spring  springconfig.xml (cont.) <bean id="businesslogicbean" class="org.springframework.aop.framework.ProxyFactoryBean"> IBusinessLogic theTracingBeforeAdvisor

49 AOP com Spring  Diagrama de seqüência Chamada transparente ao Advice do aspecto

50 AOP com Spring  Existem ainda outras formas de aplicar aspectos com o Spring  AutoProxy: BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator

51 Exercício  Implemente o exemplo “greeting”  Implemente um cadastro de usuários usando hibernate + Spring  Cadastrar  Remover  Atualizar  procurar

52 Exercícios (++)  Implemente DAOs para os objetos do modelo do projeto Java Avançado  Implemente uma fachada para o sistema(SessionFacade) tratando as transações de forma declarativa  Implemente, utilizando AOP, o logging de todas as exceções lançadas pelos DAOs