Spring + Tapestry
Um novo paradigma de desenvolvimento
web

Spring Framework
MGJUG
João Vitor Lacerda Guimarães
joao.vitor@gmail.com
29/06/2005

Agenda
● O que é o Spring?
● Como ele é organizado?
● Inversão de controle
● Integração com a parte web
● Acesso a banco de dados
– Hibernate e JDBC
● Transações declarativas
● Utilizando mocks
● Conclusão

Spring Framework
● Um container leve que fornece aspectos prontos
para serem utilizados
● Diminui o código escrito
● Integra com diversos frameworks, não reinventa a
roda
● Portável entre diversos servidores de aplicações
● Pouco ou não invasivo, você escolhe o que vai
utilizar
● Torna seu código mais testável
● Converte diversas checked exceptions em
unchecked
● Versão atual é a 1.2.1

Organização do spring

Inversão de controle
● Muda-se o instanciador do objeto
● Define-se dependências no objeto
instanciado (através de get/set ou de
contrutores)
● Pode injetar objetos obtidos via jndi
– a classe que recebe não precisa de fazer
lookups
● Favorece a utilização de interfaces
● Spring fornece constructor-injection e
setter-injection

Vantagens do IOC
● Teste fica fácil
– Teste o seu componente isolado
● Manutenção fica fácil
– Alterações bem localizadas
● Configuração fica fácil
– Desacoplado da lógica do sistema
– Pode variar de acordo com o contexto
● Reutilização fica fácil
– Componentes com baixo acoplamento são
mais fáceis de serem reutilizados

Dependency Injection
● Código Java
public class Cliente {
private CartaoCredito cartaoCredito;
public void setCartaoCredito(CartaoCredito cartaoCredito)
{
this.cartaoCredito = cartaoCredito;
}
}
● Configuração XML
<bean id=\"cliente\"
class=\"com.mgjug.persistencia.cliente.Cliente\">
<property name=\"cartaoCredito\">
<ref bean=\"cartao\"/>
</property>
</bean>

Autowire
● no(default)
– Especifica-se todas as propriedades que
devem ser setadas e quais serão os seus
valores.
● byName
– O Spring monta o objeto injetando beans de
mesmo nome das dependências
● byType
– Idem ... mesmo tipo das dependências

Inversão de controle (autowire no)
<bean id=\"cliente-01-existente-banco\"
class=\"com.mgjug.persistencia.cliente.Cliente\">
<property name=\"aniversario\">
<value>1982/01/14</value>
</property>
<property name=\"cartaoCredito\">
<ref bean=\"cartao-01-existente-banco\"/>
</property>
<property name=\"name\">
<value>Cliente1</value>
</property>
<property name=\"id\">
<value>1</value>
</property>
</bean>

Mais autowire
● byName
Deve existir no contexto do Spring um bean
com o nome da dependência. O id dessa
dependência é único
● byType
Deve existir no contexto do Spring apenas
um bean com o tipo da dependência a ser
injetada.

Integrando com a web
● ContextLoaderListener carrega os beans
noServletContext – pode ser obtido com:
● WebApplicationContext ctx =
WebApplicationContextUtils.
getWebApplicationContext(servletContext);
● Struts - ContextLoaderPlugin e ActionSupport
● WebWork - SpringObjectFactory
● JSF - DelegatingVariableResolver
● Tapestry - sobrescreve BaseEngine e coloca o
contexto do spring no Global

Exceções padronizadas
● Converte exceções para uma hierarquia única e
coerente.

JDBC de um jeito simples
● O JDBCTemplate fornece facilitadores para
acessar o banco de dados.
● Abstração do controle de abertura de
conexão, statements.
● query, queryForList, queryForMap, update

Integração com Hibernate
● Fornece suporte às versões 2.1.x e 3.x
● Pacotes utilitários
– org.springframework.orm.hibernate
– org.springframework.orm.hibernate3
● Principais classes
– HibernateDaoSupport (superclasse para DAO)
– HibernateTemplate (executa acessos)

HibernateCallback
public Collection findByFiltro(
● Classe utilitária final Cliente filtro) {
return (Collection)
para facilitar a getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(
criação de métodos Session session)
throws HibernateException {
mais específicos if (filtro != null) {
Criteria criteria =
session.createCriteria(
(ex. FindByFiltro) Cliente.class);
if (filtro.getId() != null) {
criteria.add(
Restrictions.eq(\"id\",
filtro.getId()));
}
//...
return criteria.list();
}
return null;
//...

Templates
● JDBCTemplate
● JMSTemplate
● JNDITemplate
● HibernateTemplate
● SqlMapTemplate(Ibatis)
● PersisteneBrokerTemplate(OJB)

AOP
● Os aspectos do Spring são aplicáveis
somente aos beans gerenciados por ele
● O Spring fornece aspectos prontos como:
– DebugInterceptor
– PerformanceMonitorInterceptor
– TransactionInterceptor

Transações declarativas
1) Define-se qual será a regra da transação.
<bean id=\"transactionInterceptor\"
class=\"org.springframework.transaction.interceptor.Transact
ionProxyFactoryBean\" abstract=\"true\">
<property name=\"transactionManager\">
<ref bean=\"transactionManager\"/>
</property>
<property name=\"transactionAttributes\">
<props>
<prop key=\"insert*\">PROPAGATION_REQUIRED</prop>
<prop key=\"update*\">PROPAGATION_REQUIRED</prop>
<prop key=\"*\">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>

Transações declarativas
2) Define-se a instância do objeto que
precisa da transação
<bean id=\"apresentacaoManager\"
parent=\"transactionInterceptor\">
<property name=\"target\">
<bean class=\"com.mgjug.negocio.ApresentacaoManagerImpl\"
autowire=\"byName\" dependency-check=\"objects\"/>
</property>
</bean>

Rollback declarativo
● EJBs:
} catch(MyCheckedException e){
context.setRollbackOnly();
throw e;
}
● Spring:
<property name=\"interceptorNames\"> - rollback
<list> + commit
<value>
transactionInterceptor,-MyCheckedException
</value>
</list>
</property>

Aspectos também possuem
dependências
● O Spring integra também com o AspectJ
<bean id=\"securityAspect\"
class=\"com.mgjug.aspectj.LogAspect\"
factory-method=\"aspectOf\">
<property name=\"sessionFactory\">
<ref local=\"sessionFactory\"/>
</property>
</bean>

Spring mock
● O spring-mock fornece classes para
simplificar a integração dos testes com o
container leve.
● Evita-se a utilização direta do contexto do
spring nos testes unitários.
● Testes unitários possuem dependências.
● Fornece testes transacionais.

EasyMock
public void
● A utilização de testDeleteCartaoCredito() {
mocks facilita o CartaoCredito cartaoCredito =
new CartaoCredito();
teste de camadas cartaoCreditoDAOMock.
da aplicação de delete(cartaoCredito);
controlCartaoCreditoDAO.replay();
maneira
apresentacaoManager.
independente. deleteCartaoCredito(
cartaoCredito);
controlCartaoCreditoDAO.verify();
}

Projetos relacionados
● Projetos utilizando spring
– Appfuse
– Trails
● Sub-Projetos
– Acegi Security
– Spring-IDE
– Spring-RPC
– Spring-Webflow