Guia Contexts and Dependency Injection - CDI

Configurando o CDI em projetos Java

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
 (4)  (0)

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.

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