Spring

1
Spring

• Inversão de Controle, Desenvolvimento leve,
  Orientação a aspectos, ...

Ricardo Cavalcanti roc3_at_cin.ufpe.br
Jobson Ronan jrjs_at_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("javacomp/env")
• Object obj env.lookup("ejb/AccountServic
  eHome")
• 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
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)
• ...

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
Conceitos de AOP

• Implementação tradicional com todos estes
  interesses

//... public class AccountService public void
updateAccount(updateAccount acount) throws
Exception SecurityManager.requireUserRole(a
dmin) TransactionManager.beginTransaction()
try //...código de negócio
TransactionManager.commit()
log.info(acount updated) catch
(Exception e) TransactionManager.rollbac
k() log.warning(exception throw, e)
throw e ///...
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
lt?xml version"1.0" encoding"UTF-8"?gt lt!DOCTYPE
beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http//www.springframework.org/dtd/spring-beans.d
td"gt ltbeansgt ltbean idgreeting
classWelcomeGreetinggt ltproperty
namemessagegt ltvaluegtBem vindoslt/valuegt
lt/propertygt lt/beangt lt/beansgt
...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(gr
eeting) System.out.println(greeting.greetin
g())
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.e
xecuteUpdate() 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, 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))
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

... ltbeansgt ltbean idsessionFactory
classorg.springframework.orm. hibernate.Loc
alSessionFactoryBeangt ltproperty
namedataSourcegt ltref beandataSource/gt
lt/propertygt ltproperty namehibernateProperties
gt ltpropsgt ltprop keyhibernate.dialectgt
net.sf.hibernate.dialect.MySQLDialect
lt/propgt lt/propsgt lt/propertygt ltproperty
namemappingResourcesgt ltlistgtltvaluegtCustomer
.hbm.xmllt/valuegtlt/listgt lt/propertygt lt/beangt
Continua...
34
Integração ao Hibernate

• Exemplo de configuração (cont)

ltbean idcustomerDao classHibernateCustomerDao
gt ltproperty namesessionFactorygt ltref
beansessionFactory/gt lt/propertygt lt/beangt ltbea
n iddataSource classorg.springframework.jndi.
JndiObjectFactoryBeangt ltproperty
namejndiNamegt ltvaluegtjavacomp/env/jdbc/myD
ataSourcelt/valuegt lt/propertygt lt/beangt
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

Transação somente de leitura? opcional
Comportamento de propagação
PROPAGATION, ISOLATION, readOnly, -Exceptions,
Exception
Grau de isolamento opcional
Regras de Rollback opcional
Os atributos são declarados no arquivo de
definição dos beans
39
Transações com Spring

• Exemplo

... ltbeansgt ltbean idcustomerService
classorg.springframework.transaction. interc
eptor.TransactionProxyFactoryBeangt ltproperty
nametransactionManagergt ltref
beantransactionManager/gt lt/propertygt
ltproperty nametargetgt ltref
beancustomerServiceTarget/gt lt/propertygt
ltproperty nametransactionAttributesgt
ltpropsgt ltprop keygetgtPROPAGATION_REQUIRE
D, readOnlylt/propgt ltprop keystoregtPROPAG
ATION_REQUIREDlt/propgt lt/propsgt
lt/propertygt ltbeangt ...
Continua...
40
Transações com Spring

• Exemplo (cont)

... ltbean idcustomerServiceTarget
classCustomerServiceImplgt ltproperty
namecustomerDaogt ltref beancustomerDao/gt
lt/propertygt lt/beangt ltbean idtransactionManager
classorg.springframework.orm. hibernate.Hi
bernateTransactionManagergt ltproperty
namesessionFactorygt ltref
beansessionFactory/gt lt/propertygt lt/beangt ltbea
n idcustomerDao classHibernateCustomerDaogt
ltproperty namesessionFactorygt ltref
beansessionFactory/gt lt/propertygt lt/beangt ...
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.ApplicationCont
ext import org.springframework.context.support.Fi
leSystemXmlApplicationContext 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

lt?xml version"1.0" encoding"UTF-8"?gt lt!DOCTYPE
beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http//www.springframework.org/dtd/spring-beans.d
td"gt ltbeansgt lt!-- Bean configuration --gt
ltbean id"businesslogicbean"
class"org.springframework.aop.framework.ProxyFact
oryBean"gt ltproperty name"proxyInterfaces"gt
ltvaluegtIBusinessLogiclt/valuegt
lt/propertygt ltproperty name"target"gt
ltref local"beanTarget"/gt lt/propertygt
lt/beangt lt!-- Bean Classes --gt ltbean
id"beanTarget" class"BusinessLogic"/gt lt/beansgt
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 publi
c 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

... lt!-- Advisor pointcut definition for before
advice --gt ltbean id"theTracingBeforeAdvisor"
class"org.springframework.aop.support.RegexpMetho
dPointcutAdvisor"gt ltproperty name"advice"gt
ltref local"theTracingBeforeAdvice"/gt
lt/propertygt ltproperty name"pattern"gt
ltvaluegt.lt/valuegt lt/propertygt lt/beangt lt!--
Advice classes --gt ltbean id"theTracingBeforeAdvi
ce" class"TracingBeforeAdvice"/gt ...
Aplicado por expressões regulares!
48
AOP com Spring

• springconfig.xml (cont.)

lt!-- Bean configuration --gt ltbean
id"businesslogicbean" class"org.springframewo
rk.aop.framework.ProxyFactoryBean"gt ltproperty
name"proxyInterfaces"gt ltvaluegtIBusinessLog
iclt/valuegt lt/propertygt ltproperty
name"target"gt ltref local"beanTarget"/gt
lt/propertygt ltproperty name"interceptorNames
"gt ltlistgt ltvaluegttheTracingBefore
Advisorlt/valuegt lt/listgt lt/propertygt
lt/beangt
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(SessionFacad
  e) tratando as transações de forma declarativa
• Implemente, utilizando AOP, o logging de todas as
  exceções lançadas pelos DAOs