Apresentação criada com intuíto de servir como base para o estudo do framework Spring.

1. Introdução ao Spring
Framework
Natanael Fonseca
Arquiteto de Software

2. Ementa
• O que é o Spring Framework ?
• O que são POJOS ?
• Inversão de Controle;
• Injeção de dependência;
• Módulos do Spring;
• Cenários de uso com Spring;
• Configurando o projeto;

3. O que é ?
• Fornece uma infra-estrutura completa de
componentes que se integram facilmente
com sua aplicação, deixando você livre para
programar apenas suas regras de negócio.
• No seu core, existe um container de Ioc.

4. POJOS
• Acrônimo para “Plain Old Java Object”;
• Termo estabelecido por Martin Fowler, Rebecca Parsons e John Mackenzie
em 2005;
• Denota o desenvolvimento da lógica de negócio em Objetos Java definidos a
partir de classes ordinárias sem o uso especifico de um modelo de
componentização, em especial sem o uso de EJBs.
• Portanto, o Spring sugere o uso de “JavaBeans” para a definição dos objetos
da aplicação, criando um modelo de componentes simples e sem o uso de
EJBs;

5. Inversão de Controle
• Normalmente o “controle” sobre o
software em execução fica a cargo do
próprio programador, contudo, quando em
alguns trechos o controle é passado para
outro componente(Container), dizemos
que houve uma inversão de
controle(Inversão de responsabilidades).

6. Injeção de dependência
• A injeção de dependência é um design
pattern que visa desacoplar os componentes
da aplicação.
• Os componentes são instanciados
externamente a classe.
• Um gerenciador controla essas instancias.
• Os componentes tem dependências entre si.
• Esse gerenciador, através de uma
configuração, liga os componentes de forma
a montar a aplicação.

7. Módulos do Spring

8. Cenários de Uso
• Dando suporte completo a uma aplicação
JEE(Transação, Acesso a dados, Serviços e
etc.);
• Se integrando a algum framework Web, tal
como: Struts, JSF e etc. Para acesso a infra-
estrutura do Spring;
• Servindo como ponte para a conexão entre
diversas aplicações.Via Web Services, por
exemplo;

9. Configurando o Projeto
• Basta baixar os “Jars” do spring, disponíveis
em:
• http://www.springsource.org/spring-community-download
• Ou se você estiver usando um Gerenciador
de dependência, como o Maven, basta
consultar:
• http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/
overview.html#d0e6

10. Exemplo
Imagine o cenário ao lado. Sem
o uso de Spring, teríamos um
código semelhante a este:
ComponenteC componenteC = new ComponenteC();
Servico servico = new Servico();
ComponenteB componenteB = new ComponenteB();
componenteB.setServico( servico );
ComponentA componentA = new ComponentA();
componentA.setComponenteB( componenteB );
componentA.setComponenteC( componenteC );
/*
O que acontece acima é a injeção manual pelo próprio programador
das instancias que os respectivos componentes dependem via método set. */

11. Exemplo
Com spring, basta declarar os beans e fazer uso da
injeção de dependência fornecida pelo mesmo.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-
beans.xsd">
<bean id="compA" class="com.blogspot.training.spring.ComponenteA">
<property name="componenteB" ref="compB"/>
<property name="componenteC" ref="compC"/>
</bean>
<bean id="compB" class="com.blogspot.training.spring.ComponenteB">
<property name="servico" ref="servico"/>
</bean>
<bean id="compC" class="com.blogspot.training.spring.ComponenteC"/>
<bean id="servico" class="com.blogspot.training.spring.Servico"/>
</beans>

12. Exemplo
Como resultado final, temos a “Inversão de controle”
de criação das instancias que agora são gerenciadas
pelo Spring, ou seja, basta solicitarmos o componenteA
que o mesmo já vem com todas as suas dependências
preenchidas.
public static void main(String[] args) {
Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory factory = new XmlBeanFactory( resource );
ComponenteA componentA = (ComponenteA) factory.getBean( "compA" );
System.out.println( componentA );
System.out.println( componentA.getComponenteB() );
System.out.println( componentA.getComponenteB().getServico() );
}

13. BeanFactory
• Fábrica de Objetos responsável por realizar
a inversão de controle (Ioc) na injeção de
dependências dos objetos instanciados e
solicitados por uma aplicação.
• Substitui o operador “new” da linguagem
java, deixando a cargo do Spring controlar a
criação das instancias.

14. BeanFactory
• Possui diversos métodos para
obter uma instancia de
determinado objeto;
• Pode-se usar o “id” lógico
fornecido no XML ou ainda o
tipo da classe .class;
• Um implementação simples é a
classe XMLBeanFactory que
utiliza um arquivo XML para a
definição dos beans;

15. Interface Resource
• Interface que abstrai a origem do arquivo XML,
esta possui diversas implementações, por exemplo:
• ClassPathResource
• ServletContainerResource
• URLResource
• FileSystemResource
• InputStreamResource
• PortletResource

16. Beans Singleton
Por padrão, todos os beans são “Singleton”, mas caso
queira explicitar, basta colocar “Scope=Singleton”,
conforme exemplo abaixo:
<bean id="compC" class="com.blogspot.training.spring.ComponenteC" scope="singleton" />
Fazendo isso, ao se tentar obter 5 instancias de
compC, obteremos sempre as mesmas :
for (int i = 0; i < 5; i++) {
ComponenteC componentC = (ComponenteC) factory.getBean("compC");
System.out.println(componentC);
}
Resultado no console:
com.blogspot.training.spring.ComponenteC@679bfb30
com.blogspot.training.spring.ComponenteC@679bfb30
com.blogspot.training.spring.ComponenteC@679bfb30
com.blogspot.training.spring.ComponenteC@679bfb30
com.blogspot.training.spring.ComponenteC@679bfb30

17. Beans Prototype
Caso queira que o spring retorne sempre instancias
novas, basta alterar o atributo scope para
“prototype”.
<bean id="compC" class="com.blogspot.training.spring.ComponenteC" scope="prototype" />
Fazendo isso, ao se tentar obter 5 instancias de
compC, obteremos instancias diferentes :
for (int i = 0; i < 5; i++) {
ComponenteC componentC = (ComponenteC) factory.getBean("compC");
System.out.println(componentC);
}
Resultado no console:
com.blogspot.training.spring.ComponenteC@5097eded
com.blogspot.training.spring.ComponenteC@26858bf1
com.blogspot.training.spring.ComponenteC@9a68ef9
com.blogspot.training.spring.ComponenteC@15f48262
com.blogspot.training.spring.ComponenteC@679bfb30

18. ApplicationContext
• Estende BeanFactory adicionando novas
funcionalidades e provendo características
JEE como, por exemplo:
• Suporte a AOP;
• Internacionalização;
• Propagação de Eventos;
• Dentre outras;

19. ApplicationContext
• Existem diversas implementações de
ApplicationContext. Em suma, podemos utilizar
ClasspathXMLApplicationContext para
indicar que iremos ler o XML do classpath da
aplicação.
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ComponenteA compA = (ComponenteA) ctx.getBean("compA");
System.out.println( compA );
}

20. Referencias
• Spring Framework Reference
• http://static.springsource.org/spring/docs/3.1.x/spring-framework-
reference/html/
• Spring in Action, Terceira Edição
de Craig Walls.