Primeiramente gostaria de agradecer a Lia por ter me convidado a postar neste blog. Agora vamos ao que interessa :-)
Algo que tenho usado no meu dia a dia é injeção de dependência no Spring por anotação. Nada contra configurar todos os beans em um contexto XML, mas as vezes usar anotação facilita um pouco nossa vida.
As anotações são muito simples, vejam:
@Component - Anotação que faz com que o bean seja registrado no Spring. Esta anotação é genérica e serve para qualquer bean, seja ele um serviço, um dao, um controller, etc...
@Resource - Procura pelo bean especificado e o injeta na classe, exemplo, @Resource(name="serviceA") vai procurar pelo bean serviceA que está registrado no contexto Spring.
As anotações abaixo são especializações de @Component e servem para registrar o bean no spring, entretanto, podem prover algumas funcionalidades inerentes a camada a que pertencem:
@Repository - Para anotar sua camada de persistência.
@Service - Para anotar sua camada de serviço
@Controller - Para anotar sua camada de controller.
Para que o spring possa procurar por classes anotadas no seu classpath, é necessário adicionar a seguinte linha no seu applicationContext.xml :
<context:component-scan package="br.com..."> onde base-package seria a partir de qual pacote você deseja que o spring procure por beans gerenciaveis.
Vou mostrar um exemplo muito simples de como utilizar o spring desta forma...
A estrutura do projeto é a seguinte:
O applicationContext.xml fica desta forma:
<beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" context="http://www.springframework.org/schema/context" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan package="br.com.vidadecoder">
</context:component-scan>
</beans>
A classe ServiceA:package br.com.vidadecoder.service;
import org.springframework.stereotype.Service;
@Service(value="serviceA") //Faz com que o Spring registre o bean como serviceA no contexto.
public class ServiceA {
public void doServiceAStuff() {
System.out.println("Doing something with service A");
}
}
A classe ServiceB:package br.com.vidadecoder.service;
import org.springframework.stereotype.Service;
@Service("serviceB") //Faz com que o Spring registre o bean como serviceB no contexto.
public class ServiceB {
public void doServiceBStuff() {
System.out.println("Doing something with service B");
}
}
O bean Facade, que é o bean onde estes dois serviços serão injetados:
package br.com.vidadecoder.controller;
import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import br.com.vidadecoder.service.ServiceA;
import br.com.vidadecoder.service.ServiceB;
@Controller(value="facade")
public class Facade {
@Resource(name="serviceA") //Faz com que o spring injete o bean serviceA
private ServiceA serviceA;
@Resource(name="serviceB")//Faz com que o spring injete o bean serviceB
private ServiceB serviceB;
public ServiceA getServiceA() {
return serviceA;
}
public void setServiceA(ServiceA serviceA) {
this.serviceA = serviceA;
}
public ServiceB getServiceB() {
return serviceB;
}
public void setServiceB(ServiceB serviceB) {
this.serviceB = serviceB;
}
public void runBothServices() {
serviceA.doServiceAStuff();
serviceB.doServiceBStuff();
}
}
e por fim classe Main:
package br.com.vidadecoder.cmd;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import br.com.vidadecoder.controller.Facade;
public class Main {
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Facade facade = (Facade) ctx.getBean("facade");
facade.runBothServices();
}
}
Para maiores informações, acessem a documentação do Spring, na parte Annotation Driven Configuration:
Documentação do Spring
Neste exemplo utilizei o Spring na versão 2.5 .
