Injeção de Dependências em Java com JSR-330 e Spring

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (3)  (0)

Veja neste artigo quais as principais vantagens que a nova especificação de injeção de dependências para Java trouxe (JSR-330) e sua utilização com o Spring Framework.

Para compreendermos porque foi necessário criar uma especificação para injeção de dependências em Java, vamos ver que benefícios trás uma especificação. Uma especificação pode ser comparada a um contrato, um modelo a ser seguido. Este contrato diz o que, mas não como uma determinada funcionalidade deve ser implementada na plataforma Java. Para ficar mais claro, o nosso artigo fala sobre a JSR-330, injeção de dependências baseada em anotações. Essa especificação determina o que o deve ser seguido para injetar dependências em Java. Os frameworks devem seguir esse padrão, visando manter a portabilidade entre eles.

Vamos supor que estamos utilizando um framework, como o Spring, e temos a necessidade de migrar para um outro, como o Guice. Antes da especificação, teríamos problemas, pois cada framework implementava a injeção de dependência de uma maneira, conforme pode ser visto na Figura 1.

Esquema de funcionamento dos frameworks

Figura 1: Esquema de funcionamento dos frameworks

A Figura 2 mostra a vantagem de se seguir uma especificação. Há portabilidade entre os frameworks, bastando escolher a implementação desejada. Para ficar mais claro, vamos à nossa aplicação.

Frameworks com a especificação

Figura 2: Frameworks com a especificação

Os mecanismos do Spring para implementar injeção de dependência, até a versão 2.5, não seguiam a especificação JSR-330. A partir da versão 3.0 do Spring, as anotações utilizadas são baseadas na especificação Java para injeção de dependências. A Tabela 1 mostra as anotações utilizadas antes da especificação, e a Tabela 2 mostra as anotações utilizadas pela especificação JSR-330:

@Component Anotação genérica para qualquer componente gerenciado pelo Spring. Esta anotação faz com que o bean registrado no Spring possa ser utilizado em qualquer bean, seja ele um serviço, um DAO, um controller, etc. No nosso exemplo, ele será responsável por um Bean que representa uma entidade.
@Repository Anotação que serve para definir uma classe como pertencente à camada de persistência.
@Service Anotação que serve para definir uma classe como pertencente à camada de Serviço da aplicação.
@Autowired A anotação @ Autowired fornece controle sobre onde e como a ligação entre os beans deve ser realizada. Pode ser usado para em métodos setter, no construtor, em uma propriedade ou métodos com nomes arbitrários e / ou vários argumentos.

Tabela 1: Anotações do Spring usadas na aplicação

@Named Ao invés de @Component do Spring
@Inject Ao invés de @Autowired do Spring

Tabela 2: Anotações para Injeção de Dependência em Java

Bom, agora é começar o projeto. Para isso, abra o IDE Eclipse e crie um novo Java Project. Após isso, crie um arquivo XML simples, com nome de spring.xml, conforme pode ser visto na Listagem 1. Este arquivo será o responsável pela configuração do Spring Framework. Após isso, vamos criar uma classe Java, nomeando-a para App.java. Esta classe é a principal de nossa aplicação, e é responsável por colocar o Spring dentro do contexto da aplicação, ou seja, permite que o Spring trabalhe por nós. Pedimos então ao Spring que inicie sua execução a partir do método save(), presente na classe ClienteService, conforme pode ser visto na Listagem 2.

Listagem 1: Arquivo de configuração do Spring Framework

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">
 
    <context:component-scan base-package="br.com" />
 
</beans>

Listagem 2: Classe que insere o Spring no contexto da aplicação (App.java)

package br.com.main;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import br.com.cliente.service.ClienteService;

public class App {
    public static void main( String[] args ) {
    	ApplicationContext context = new ClassPathXmlApplicationContext(
new String[] {"spring.xml"});
     	ClienteService cliente = (ClienteService)context.getBean("clienteService");
    	cliente.save();
     }
}

A classe ClienteService tem duas dependências gerenciadas e injetadas pelo Spring. São elas, a classe Cliente, apresentada na Listagem 3 e a classe ClienteDao, mostrada na Listagem 5. A classe ClienteService apresenta algumas anotações. A anotação @Service, representa esta classe como se fosse um serviço. Já as anotações @Inject, permitem que o Spring injete as dependências nesta classe, conforme pode ser visto na Listagem 3.

Listagem 3: Classe ClienteService.java

package br.com.cliente.service;

import javax.inject.Inject;
import javax.inject.Named; 
import br.com.cliente.dao.ClienteDao;
import br.com.cliente.entity.Cliente;

@Named
public class ClienteService {

	@Inject
	ClienteDao clienteDAO;
	@Inject
	Cliente cliente;
 
	public void save() {
		cliente.setNome("Leonel Messi");
		System.out.println("Cliente foi manipulado no Service");
		clienteDAO.save(cliente);
 	}
}

Listagem 4: Classe Cliente.java

package br.com.cliente.entity;

import javax.inject.Inject;
import javax.inject.Named;

@Named
public class Cliente {

	private String nome;
	
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
}

Listagem 5: Classe ClienteDao.java

package br.com.cliente.dao;

import org.springframework.stereotype.Repository;
import br.com.cliente.entity.Cliente;
	 
@Repository
public class ClienteDao 
{
	public void save(Cliente cliente) {
		System.out.println("Cliente salvo no Dao: "+cliente.getNome());
		
	}	
}

Bom, apesar de apresentarmos somente as anotações básicas da especificação Java para injeção de dependências, vimos que foi possível diminuir o acoplamento com o Framework Spring ao se utilizar desta especificação. Bom pessoal, obrigado e até um próximo artigo, abraço.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?