Hoje vamos analisar a Injeção de Dependência do Spring. Os conceitos principais do Framework Spring são “Injeção de Dependência” e “Programação Orientada a Aspectos”. Eu já escrevi anteriormente sobre Injeção de Dependência em Java e como podemos utilizar o framework Google Guice para automatizar esse processo em nossas aplicações.
Injeção de Dependência do Spring
Este tutorial tem como objetivo fornecer detalhes sobre o exemplo de Injeção de Dependência do Spring com configuração baseada em anotações e configuração baseada em arquivo XML. Também fornecerei um exemplo de caso de teste JUnit para a aplicação, pois a facilidade de testabilidade é um dos principais benefícios da injeção de dependência. Criei o projeto Maven spring-dependency-injection, cuja estrutura se parece com a imagem abaixo. 
Vamos analisar cada um dos componentes um por um.
Injeção de Dependência do Spring – Dependências Maven
I have added Spring and JUnit maven dependencies in pom.xml file, final pom.xml code is below.
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.spring</groupId>
<artifactId>spring-dependency-injection</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
A versão estável atual do Spring Framework é 4.0.0.RELEASE e a versão atual do JUnit é 4.8.1, se estiver utilizando outras versões, pode haver uma pequena chance de que o projeto necessite de alguma alteração. Se você construir o projeto, notará que outros JARs também são adicionados às dependências do Maven devido a dependências transitivas, assim como na imagem acima.
Injeção de Dependência do Spring – Classes de Serviço
Vamos supor que queremos enviar mensagens de e-mail e mensagens de Twitter para os usuários. Para injeção de dependência, precisamos ter uma classe base para os serviços. Então, tenho a interface MessageService com a declaração de um único método para enviar mensagem.
package com.journaldev.spring.di.services;
public interface MessageService {
boolean sendMessage(String msg, String rec);
}
Agora teremos classes de implementação reais para enviar e-mail e mensagem do Twitter.
package com.journaldev.spring.di.services;
public class EmailService implements MessageService {
public boolean sendMessage(String msg, String rec) {
System.out.println("Email Sent to "+rec+ " with Message="+msg);
return true;
}
}
package com.journaldev.spring.di.services;
public class TwitterService implements MessageService {
public boolean sendMessage(String msg, String rec) {
System.out.println("Twitter message Sent to "+rec+ " with Message="+msg);
return true;
}
}
Agora que nossos serviços estão prontos, podemos passar para as classes de Componente que irão consumir o serviço.
Injeção de Dependência do Spring – Classes de Componente
Vamos escrever uma classe consumidora para os serviços acima. Teremos duas classes consumidoras – uma com anotações do Spring para autowiring e outra sem anotação e a configuração de fiação será fornecida no arquivo de configuração XML.
package com.journaldev.spring.di.consumer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import com.journaldev.spring.di.services.MessageService;
@Component
public class MyApplication {
//injeção de dependência baseada em campo
//@Autowired
private MessageService service;
// injeção de dependência baseada em construtor
// @Autowired
// public MyApplication(MessageService svc){
// this.service=svc;
// }
@Autowired
public void setService(MessageService svc){
this.service=svc;
}
public boolean processMessage(String msg, String rec){
//alguma mágica como validação, registro etc
return this.service.sendMessage(msg, rec);
}
}
Alguns pontos importantes sobre a classe MyApplication:
@Componentannotation é adicionada à classe, para que quando o framework Spring procurar por componentes, esta classe seja tratada como um componente. @Component a anotação pode ser aplicada apenas à classe e sua política de retenção é Runtime. Se você não estiver familiarizado com a política de retenção de anotações, sugiro que leia java annotations tutorial.@Autowireda anotação é usada para informar ao Spring que a autowiring é necessária. Isso pode ser aplicado a campos, construtores e métodos. Essa anotação nos permite implementar injeção de dependência baseada em construtor, campo ou método em nossos componentes.- Para o nosso exemplo, estou usando injeção de dependência baseada em método. Você pode descomentar o método do construtor para alternar para a injeção de dependência baseada em construtor.
Agora vamos escrever uma classe semelhante sem anotações.
package com.journaldev.spring.di.consumer;
import com.journaldev.spring.di.services.MessageService;
public class MyXMLApplication {
private MessageService service;
//injeção de dependência baseada em construtor
// public MyXMLApplication(MessageService svc) {
// this.service = svc;
// }
//injeção de dependência baseada em setter
public void setService(MessageService svc){
this.service=svc;
}
public boolean processMessage(String msg, String rec) {
// algum código mágico como validação, logging etc
return this.service.sendMessage(msg, rec);
}
}
A simple application class consuming the service. For XML based configuration, we can use implement either constructor-based spring dependency injection or method-based spring dependency injection. Note that method-based and setter-based injection approaches are same, it’s just that some prefer calling it setter-based and some call it method-based.
Configuração de Injeção de Dependência do Spring com Anotações
Para configuração baseada em anotações, precisamos escrever uma classe Configuradora que será usada para injetar a implementação real do bean na propriedade do componente.
package com.journaldev.spring.di.configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import com.journaldev.spring.di.services.EmailService;
import com.journaldev.spring.di.services.MessageService;
@Configuration
@ComponentScan(value={"com.journaldev.spring.di.consumer"})
public class DIConfiguration {
@Bean
public MessageService getMessageService(){
return new EmailService();
}
}
Alguns pontos importantes relacionados à classe acima são:
@Configurationé usada para informar ao Spring que é uma classe de configuração.- A anotação
@ComponentScané usada com a anotação@Configurationpara especificar os pacotes a serem verificados em busca de classes de componentes. - A anotação
@Beané usada para informar ao framework Spring que este método deve ser usado para obter a implementação do bean a ser injetada em classes de componentes.
Vamos escrever um programa simples para testar nosso exemplo de Injeção de Dependência do Spring baseada em anotações.
package com.journaldev.spring.di.test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.journaldev.spring.di.configuration.DIConfiguration;
import com.journaldev.spring.di.consumer.MyApplication;
public class ClientApplication {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DIConfiguration.class);
MyApplication app = context.getBean(MyApplication.class);
app.processMessage("Hi Pankaj", "[email protected]");
//fechar o contexto
context.close();
}
}
AnnotationConfigApplicationContext é a implementação da classe abstrata AbstractApplicationContext e é usada para realizar a ligação automática de serviços a componentes quando são usadas anotações. O construtor de AnnotationConfigApplicationContext recebe uma classe como argumento que será usada para obter a implementação do bean a ser injetado nas classes de componente. O método getBean(Class) retorna o objeto do componente e usa a configuração para realizar a ligação automática dos objetos. Objetos de contexto consomem muitos recursos, portanto, devemos fechá-los quando terminarmos. Ao executarmos o programa acima, obtemos a saída abaixo.
Dec 16, 2013 11:49:20 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@3067ed13: startup date [Mon Dec 16 23:49:20 PST 2013]; root of context hierarchy
Email Sent to [email protected] with Message=Hi Pankaj
Dec 16, 2013 11:49:20 PM org.springframework.context.support.AbstractApplicationContext doClose
INFO: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@3067ed13: startup date [Mon Dec 16 23:49:20 PST 2013]; root of context hierarchy
Configuração de Injeção de Dependência do Spring Baseada em XML
Vamos criar um arquivo de configuração do Spring com os dados abaixo; o nome do arquivo pode ser qualquer coisa. Código do arquivo applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
<!--
<bean id="MyXMLApp" class="com.journaldev.spring.di.consumer.MyXMLApplication">
<constructor-arg>
<bean class="com.journaldev.spring.di.services.TwitterService" />
</constructor-arg>
</bean>
-->
<bean id="twitter" class="com.journaldev.spring.di.services.TwitterService"></bean>
<bean id="MyXMLApp" class="com.journaldev.spring.di.consumer.MyXMLApplication">
<property name="service" ref="twitter"></property>
</bean>
</beans>
Observe que o XML acima contém configuração tanto para injeção de dependência baseada em construtor quanto para injeção baseada em setter do Spring. Como MyXMLApplication está usando o método setter para injeção, a configuração do bean contém o elemento property para injeção. Para injeção baseada em construtor, precisamos usar o elemento constructor-arg. O arquivo de configuração XML é colocado no diretório de origem, portanto, estará no diretório de classes após a compilação. Vamos ver como usar a configuração baseada em XML com um programa simples.
package com.journaldev.spring.di.test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.journaldev.spring.di.consumer.MyXMLApplication;
public class ClientXMLApplication {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
"applicationContext.xml");
MyXMLApplication app = context.getBean(MyXMLApplication.class);
app.processMessage("Hi Pankaj", "[email protected]");
// fechar o contexto
context.close();
}
}
ClassPathXmlApplicationContext é usado para obter o objeto ApplicationContext fornecendo a localização dos arquivos de configuração. Possui vários construtores sobrecarregados e podemos fornecer vários arquivos de configuração também. O restante do código é semelhante ao programa de teste de configuração baseada em anotações, a única diferença é a maneira como obtemos o objeto ApplicationContext com base na nossa escolha de configuração. Quando executamos o programa acima, obtemos a seguinte saída.
Dec 17, 2013 12:01:23 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@4eeaabad: startup date [Tue Dec 17 00:01:23 PST 2013]; root of context hierarchy
Dec 17, 2013 12:01:23 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
Twitter message Sent to [email protected] with Message=Hi Pankaj
Dec 17, 2013 12:01:23 AM org.springframework.context.support.AbstractApplicationContext doClose
INFO: Closing org.springframework.context.support.ClassPathXmlApplicationContext@4eeaabad: startup date [Tue Dec 17 00:01:23 PST 2013]; root of context hierarchy
Observe que parte da saída é escrita pelo Spring Framework. Como o Spring Framework usa o log4j para fins de registro e eu não o configurei, a saída está sendo gravada no console.
Caso de teste JUnit para Injeção de Dependência do Spring
Um dos principais benefícios da injeção de dependência no Spring é a facilidade de ter classes de serviço fictícias em vez de usar serviços reais. Portanto, combinei todo o aprendizado acima e escrevi tudo em uma única classe de teste JUnit 4 para injeção de dependência no Spring.
package com.journaldev.spring.di.test;
import org.junit.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import com.journaldev.spring.di.consumer.MyApplication;
import com.journaldev.spring.di.services.MessageService;
@Configuration
@ComponentScan(value="com.journaldev.spring.di.consumer")
public class MyApplicationTest {
private AnnotationConfigApplicationContext context = null;
@Bean
public MessageService getMessageService() {
return new MessageService(){
public boolean sendMessage(String msg, String rec) {
System.out.println("Mock Service");
return true;
}
};
}
@Before
public void setUp() throws Exception {
context = new AnnotationConfigApplicationContext(MyApplicationTest.class);
}
@After
public void tearDown() throws Exception {
context.close();
}
@Test
public void test() {
MyApplication app = context.getBean(MyApplication.class);
Assert.assertTrue(app.processMessage("Hi Pankaj", "[email protected]"));
}
}
A classe é anotada com @Configuration e @ComponentScan porque o método getMessageService() retorna a implementação mock de MessageService. É por isso que getMessageService() é anotado com @Bean. Como estou testando a classe MyApplication configurada com anotações, estou usando AnnotationConfigApplicationContext e criando seu objeto no método setUp(). O contexto é fechado no método tearDown(). O código do método test() apenas obtém o objeto do componente do contexto e o testa. Você se pergunta como o Spring Framework faz a injeção automática e chama os métodos que são desconhecidos para o Spring Framework. Isso é feito com o amplo uso de Java Reflection, que podemos usar para analisar e modificar os comportamentos das classes em tempo de execução.
Baixe o Projeto de Injeção de Dependência do Spring
Baixe o projeto de exemplo de Injeção de Dependência (DI) do Spring no URL acima e brinque com ele para aprender mais.
Source:
https://www.digitalocean.com/community/tutorials/spring-dependency-injection