1. Java EE Leve
Uma introdução ao framework Spring
David Ricardo do Vale Pereira
david@jeebrasil.com.br

2. O que é Spring?
Interface21

3. O que é Spring?
• Reduzir a complexidade do
desenvolvimento Java EE
• Simplificar sem perder o poder
• Facilitar o desenvolvimento usando as boas
práticas

4. O que é Spring?
• Possibilitar que as aplicações sejam
construídas com POJOs
• Aplicação de serviços aos POJOs de
maneira declarativa
– Ex: @Transactional

5. O que é Spring?
Poder para os POJOs

6. O que é Spring?
Spring influenciou...
– EJB 3.0
– Java Server Faces

7. O que é Spring?
• Container de DI
• AOP
• Acesso a dados (JDBC, Hibernate, iBatis...)
• Gerenciamento de Transações
• Agendamento de Tarefas
• Mail Support
• Remoting
• Spring MVC + Spring Web Flow
• Spring RCP

8. Injeção de Dependências
Inversão de Controle
“Inversion of Control (IoC) is a design
pattern that addresses a component's
dependency resolution, configuration and
lifecycle.”
(Paul Hammant - PicoContainer)

9. Injeção de Dependências
Dependency Lookup x Dependency Injection

10. Injeção de Dependências
The Hollywood Principle:
Don't call us, we'll call you!

11. Injeção de Dependências
Injeção de Dependências
Inversion of Control Containers
and The Dependency Injection
Pattern
http://www.martinfowler.com/articles/injection.html
Martin Fowler

12. Injeção de Dependências
Exemplo
depende de
Bean 1 Bean 2

13. Injeção de Dependências
Sem Inversão de Controle
public class Bean1 {
private Bean2 bean2;
public void metodo() {
bean2 = new Bean2(); // sem IoC
bean2.usandoBean();
}
}

14. Injeção de Dependências
Com Dependency Lookup
public class Bean1 {
private Bean2 bean2;
public void metodo() {
bean2 = Factory.getBean2(); // Factory (GoF)
bean2.usandoBean();
}
}

15. Injeção de Dependências
Com Dependency Injection
public class Bean1 {
private Bean2 bean2;
public void metodo() {
bean2.usandoBean();
}
public void setBean2(Bean2 bean2) {
this.bean2 = bean2;
}
}

16. Injeção de Dependências
Dois tipos...
– Setter Injection
– Constructor Injection
Spring trabalha com ambos!

17. Injeção de Dependências
Setter Injection
<bean id=”bean2” class=”pacote.Bean2”/>
<bean id=”bean1” class=”pacote.Bean1”>
<property name=”bean2”>
<ref bean=”bean2”/>
</property>
</bean>

18. Injeção de Dependências
Constructor Injection
<bean id=”bean2” class=”pacote.Bean2”/>
<bean id=”bean1” class=”pacote.Bean1”>
<constructor-arg>
<ref bean=”bean2”/>
</constructor-arg>
</bean>

19. AOP
AOP = Aspects Oriented Programming
Aspectos

20. AOP
0

21. AOP
• Advices
– Before Advice
– After Advice
– Around Advice
– Throws Advice
– Introduction Advice

22. AOP
Um “Hello World!” com AOP
public class MessageWriter {
public void writeMessage() {
System.out.println(“World”);
}
}

23. AOP
public class MessageDecorator implements
MethodInterceptor {
public Object invoke(MethodInvocation
invocation) throws Throwable {
System.out.println(“Hello ”);
invocation.proceed();
System.out.println(“!”);
return retVal;
}
}

24. AOP
public class HelloWorldAOPExample {
public static void main(String args[]) {
MessageWriter target = new MessageWriter();
ProxyFactory pf = new ProxyFactory();
pf.addAdvice(new MessageDecorator());
pf.setTarget(target);
MessageWriter proxy = (MessageWriter)pf.getProxy();
target.writeMessage();
proxy.writeMessage();
}
}

25. Acesso a Dados
Acesso a Dados com Spring

26. Acesso a Dados
Spring com JDBC
• Gerenciamento de DataSources
• JDBC Templates
• SQLExceptionTranslator

27. Acesso a Dados

28. Acesso a Dados
Gerenciamento de DataSources
<bean id=”dataSource”
class=”org.springframework.jndi.JndiObjectFactoryBean”>
<property name=”jndiName”>
<value>java:comp/env/jdbc/meuDataSource</value>
</property>
</bean>
<bean id=”meuDAO” class=”net.java.dev.javarn.dao.MeuDAO”>
<property name=”dataSource”>
<ref local=”dataSource”/>
</property>
</bean>

29. Acesso a Dados
JDBC Templates
• Facilita a execução de consultas
• Torna o código mais limpo

30. Acesso a Dados
int count = 0;
try {
PreparedStatement st = getConnection().
prepareStatement(“select count(*) from produto”);
ResultSet rs = st.executeQuery();
if (rs.next())
count = rs.getInt(1);
} catch(SQLException e) {
log.error(e);
} finally {
try { if (stmt != null) stmt.close(); }
catch(SQLException e) { log.warn(e); }
try { if (conn != null) conn.close(); }
catch(SQLException e) { log.warn(e); }
}

31. Acesso a Dados
JdbcTemplate jt = new JdbcTemplate(getDataSource());
int count = jt.queryForInt(
“select count(*) from produto”);

32. Acesso a Dados
<bean id=quot;jdbcTemplatequot;
class=quot;org.springframework.jdbc.core.JdbcTemplatequot;>
<property name=quot;dataSourcequot;>
<ref bean=quot;dataSourcequot;/>
</property>
</bean>
<bean id=quot;studentDaoquot; class=quot;StudentDaoJdbcquot;>
<property name=quot;jdbcTemplatequot;>
<ref bean=quot;jdbcTemplatequot;/>
</property>
</bean>

33. Acesso a Dados
SQLExceptionTranslator
BadSqlGrammarException
CannotGetJdbcConnectionException
SQLException
InvalidResultSetAccessException
IncorrectResultSetColumnCountException
...

34. Acesso a Dados
Spring com Hibernate
• Gerenciamento de Session Factories
• Hibernate DAO Support

35. Acesso a Dados
Gerenciamento de Session Factories
<bean id=”dataSource” ... />
<bean id=”sessionFactory”
class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
<property name=”dataSource”><ref local=”dataSource”/></property>
<property name=”hibernateProperties”>
<props><prop key=”hibernate.dialect”>
org.hibernate.dialect.PostgreSQLDialect
</prop></props>
</property>
<property name=”mappingResources”>
<list>
<value>Bean1.hbm.xml</value> <value>Bean2.hbm.xml</value>
</list>
</property> ...

36. Acesso a Dados
Hibernate DAO Support
public class AlunoDao extends HibernateDaoSupport implements Dao {
public Object get(int id) {
return getHibernateTemplate().load(Aluno.class, id);
}
public List getAll() {
return getHibernateTemplate().loadAll(Aluno.class);
}
public void saveOrUpdate(Object o) {
getHibernateTemplate().saveOrUpdate(o);
}
public List findAlunosReprovados() {
return getHibernateTemplate().find(“from Aluno a where
a.disciplinas.media < ?”, new Object[] { 7 });
}
}

37. Acesso a Dados
<bean id=quot;sessionFactoryquot; .../>
<bean id=quot;daoquot; class=quot;net.java.dev.javarn.TestDaoquot;>
<property name=quot;sessionFactoryquot;>
<ref bean=quot;sessionFactoryquot; />
</property>
</bean>

38. Gerenciamento de Transações

39. Gerenciamento de Transações
@Transactional
public interface FooService {
Foo getFoo(String fooName);
void insertFoo(Foo foo);
void updateFoo(Foo foo);
}

40. Gerenciamento de Transações
public class FooService {
public Foo getFoo(String fooName) { ... }
@Transactional(propagation =
Propagation.REQUIRES_NEW)
public void updateFoo(Foo foo) {
// ...
}
}

41. Spring na Web
Integração com Frameworks
• Spring + Spring MVC
• Spring + Java Server Faces
• Spring + Webwork
• Spring + Tapestry
• Spring + Struts

42. Spring na Web
Spring Web Flow
• Controle de fluxo de aplicações web
• Continuations
• Problema do botão voltar (back x undo)

43. Spring na Web
/step1.do
storeForm
page1
Controller 1 HTTP
Session
/step2.do
updateForm
page2
Controller 2
/lastStep.do
Business
Service
processTx
confirmationPage
Controller 3

44. Spring na Web

45. Spring na Web
• Fluxo como uma máquina de estados
• Estados e transições configurados com XML
• Atualmente compatível com Spring MVC e
Java Server Faces
• Suporte a AJAX

46. Spring no Desktop
Spring RCP
• Rich Client Platform
• Programação Desktop com o poder do
Spring
• Suporte a Swing, inicialmente

47. Spring no Desktop
Spring RCP – Form Builders
FormModelformModel= new DefaultFormModel(newCustomer());
TableFormBuilderbuilder = new TableFormBuilder(formModel);
builder.addSeparator(quot;separator.contactDetailsquot;);
builder.row();
builder.add(quot;namequot;);
builder.row();
builder.add(quot;orgPositionquot;);
builder.row();
builder.add(quot;orgNamequot;);
builder.row();
builder.addSeparator(quot;separator.addressDetailsquot;);
…
builder.add(quot;statequot;);
builder.add(quot;postcodequot;,quot;colSpec=2cmquot;);
builder.row();
builder.add(quot;countryquot;);
JComponentform = builder.getForm();

48. Spring no Desktop

49. Remoting
Sistemas Distribuídos com Spring
• Spring + EJBs
• Spring + RMI
• Spring + JAXRPC (Web Services)
• Spring HTTP Invoker

50. Spring 2.0
Novidades do Spring 2.0
• XML mais simples e poderoso (XML Schema)
• Mais uso de Annotations
• Convention over configuration
• Múltiplas linguagens (Java, Groovy, Jruby,
BeanShell)

51. Spring Annotation
Spring Annotation
• Configuração com Annotations
• Integração com JSF
• Brasileiro
http://spring-annotation.dev.java.net/

52. Livros

53. Dúvidas?
david@jeebrasil.com.br
www.jeebrasil.com.br
del.icio.us/davidrvp