Configurando o CDI em projetos Java

Veja neste artigo como configurar o CDI no seu projeto Java e já começar a utilizar a especificação padrão para injeção de dependências.

Motivação

O CDI, acrônimo de Contexts and Dependency Injection, é uma especificação Java, criada a partir da JSR-299 (Java Specification Request), responsável por fazer o controle da injeção de dependências nas aplicações.

Por ser uma especificação, várias implementações foram feitas com base no CDI, como o JBoss Weld, Resin CanDI e Apache OpenWebBeans. No entanto, apesar de serem ferramentas distintas, elas requerem do desenvolvedor, basicamente, o conhecimento das mesmas anotações e técnicas de configuração estabelecidas pelo CDI.

Neste artigo veremos como utilizar essa especificação em um projeto Java, nos concentrando no JBoss Weld, implementação de referência dessa especificação.

Adicionando o CDI ao projeto com o Weld

Na página do Weld você pode encontrar todas as versões disponíveis para download. Entre elas, optamos pela 2.4.1.Final. Usaremos, ainda, o Maven, para adicionar o Weld ao nosso projeto sem nos preocuparmos com as dependências. Para isso, o primeiro deve ser a configuração do arquivo pom.xml, como mostra a Listagem 1.

<dependency> <groupId>org.jboss.weld.servlet</groupId> <artifactId>weld-servlet</artifactId> <version>2.4.1.Final</version> </dependency>
Listagem 1. Adicionando o Weld no pom.xml

O próximo passo é adicionar um arquivo chamado beans.xml ao diretório src/main/webapp/WEB-INF/. Esse arquivo habilita o CDI no seu projeto, mesmo estando sem configurações. A Listagem 2 apresenta o seu conteúdo.

<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd" version="1.2" bean-discovery-mode="all"> </beans>
Listagem 2. Arquivo beans.xml para o CDI 1.2.

Observe que declaramos o atributo version com o valor 1.2, especificando exatamente a versão do CDI que vamos utilizar. Um outro atributo importante é o bean-discovery-mode, declarado com o valor “all”. Isso indica que o CDI deverá buscar tanto por anotações quanto por arquivos XML que possuam a declaração dos beans que devem ser gerenciados.

Injetando seu bean

Para que seu bean torne-se gerenciável, é preciso adicionar a ele ao menos a anotação @Named, que dirá ao CDI que esse bean deve ser gerenciado, possibilitando a injeção do mesmo em outros beans através da anotação @Inject. Na Listagem 3 temos um exemplo de criação de um bean gerenciável.

package br.com.devmedia; import javax.inject.Named; @Named public class MeuBeanGerenciavel { public void executarRotina(){ //TODO: Rotina desejada aqui } }
Listagem 3. Criando um Bean gerenciável

Nesse trecho de código, criamos uma classe de exemplo com um método executarRotina(), e anotamos a classe com @Named. Dessa forma, ela poderá ser usada em outros pontos do projeto sem a necessidade de utilizarmos o operador new. Na Listagem 4 apresentamos um exemplo de como injetá-lo em um outro bean, bem como fazer uso dos seus métodos normalmente.

package br.com.devmedia; import javax.annotation.PostConstruct; import javax.inject.Inject; import javax.inject.Named; @Named public class MinhaClasseUtil { @Inject private MeuBeanGerenciavel bean; @PostConstruct public void init(){ bean.executarRotina(); } }
Listagem 4. Injetando o bean gerenciável

Note que nessa listagem criamos uma classe com a mesma anotação @Named usada na listagem anterior. Assim, esse bean também se torna gerenciável, do mesmo modo que a classe criada na Listagem 3. O primordial aqui é notar o uso da anotação @Inject, que irá, automaticamente, criar uma instância da classe MeuBeanGerenciavel e colocá-la dentro do objeto que nomeamos de “bean”.

Feito isso, podemos fazer a chamada a qualquer método que esteja acessível na classe injetada, como é o caso do executarRotina(). Usamos, também, a anotação @PostConstruct, fazendo com que o método init() seja chamado imediatamente após a construção do bean MinhaClasseUtil. Anotações como essa são úteis para casos em que é necessário carregar algo ou fazer alguma verificação, por exemplo, ao criar/destruir um bean.

Assim como as apresentadas nesse artigo, o CDI possui diversas outras anotações, recursos e técnicas disponíveis que o tornam tão robusto e completo. Sendo assim, quando houver a necessidade de empregar injeção de dependências em seus projetos, considere o uso de uma das implementações dessa especificação.

Artigos relacionados