Injeção de Dependências com CDI em JSF: Passo-a-passo com IntelliJ IDEA e WildFly

A injeção de dependências é uma técnica poderosa que simplifica a criação de software ao reduzir o acoplamento entre classes e serviços. No JavaServer Faces (JSF), o CDI (Context and Dependency Injection) é amplamente utilizado para gerenciar o ciclo de vida dos beans e injetá-los automaticamente nas classes. Este tutorial ensina como configurar um projeto utilizando IntelliJ IDEA e o servidor WildFly para aplicar o CDI em uma aplicação JSF.

Sumário

1. Pré-requisitos e Configuração do Ambiente no IntelliJ IDEA

2. Configurando o Projeto com Maven

3. Criando a Interface com JSF

4. Testabilidade Facilitada com CDI utilizando JUnit

5. Executando o Projeto no WildFly

6. Conclusão

1. Pré-requisitos e Configuração do Ambiente no IntelliJ IDEA

Antes de iniciar o desenvolvimento com JSF e CDI, vamos garantir que você tenha todas as ferramentas configuradas corretamente.

Ferramentas Necessárias:

• Java SDK: Utilize o JDK 11 ou superior.

• IntelliJ IDEA: A versão Community Edition já é suficiente. Download.

• WildFly: Baixe e instale o servidor de aplicações (versão 25 ou posterior, para garantir suporte às últimas especificações do Jakarta EE e otimizações de desempenho.). Download.

• Maven: O IntelliJ IDEA Community Edition tem suporte nativo para Maven.

Passo 1: Instalar o JDK

1. Baixe e instale o JDK 11.

2. Configure o SDK no IntelliJ IDEA:

   • Vá para File > Project Structure > Project.

   • Em Project SDK, adicione o JDK que foi instalado.

Passo 2: Baixar e Configurar o WildFly

1. Baixe e extraia o WildFly.

2. No terminal, navegue até a pasta bin/ e execute o comando:

   • No Linux:

   •     ./standalone.sh
     

     No Windows:

       standalone.bat
     

Passo 3: Criar um Novo Projeto Maven no IntelliJ

1. No IntelliJ IDEA, clique em New Project.

2. Selecione Maven e configure o GroupId e ArtifactId do seu projeto.

3. Crie a seguinte estrutura de pastas:

src
 └── main
     └── java (para os arquivos Java)
     └── webapp (para arquivos XHTML)
         └── WEB-INF
             └── beans.xml

Passo 4: Adicionar Dependências ao pom.xml

Adicione as seguintes dependências no arquivo pom.xml:

<dependencies>
    <!-- JSF API (Mojarra) -->
    <dependency>
        <groupId>javax.faces</groupId>
        <artifactId>javax.faces-api</artifactId>
        <version>2.3</version>
    </dependency>

    <!-- CDI API -->
    <dependency>
        <groupId>javax.enterprise</groupId>
        <artifactId>cdi-api</artifactId>
        <version>2.0.SP1</version>
    </dependency>

    <!-- Servlet API -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

Passo 5: Configurar o Arquivo beans.xml

Crie o arquivo WEB-INF/beans.xml para habilitar o CDI no projeto:

<?xml version="1.0" encoding="UTF-8"?>
<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.1">
</beans>

2. Configurando o Projeto com Maven

Passo 1: Criar o Serviço CDI (Bean para Injeção)

Crie uma classe de serviço chamada SaudacaoService:

import javax.enterprise.context.RequestScoped;
import javax.inject.Named;

@Named
@RequestScoped
public class SaudacaoService {

    public String saudar(String nome) {
        return "Olá, " + nome + "!";
    }
}

Passo 2: Criar o Managed Bean JSF com Injeção CDI

Agora, crie o Managed Bean que irá utilizar o serviço SaudacaoService:

import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;

@Named
@RequestScoped
public class SaudacaoBean {

    @Inject
    private SaudacaoService saudacaoService;

    private String nome;
    private String mensagem;

    public void saudar() {
        this.mensagem = saudacaoService.saudar(nome);
    }

    // Getters e Setters
    public String getNome() {
        return nome;
    }

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

    public String getMensagem() {
        return mensagem;
    }

    public void setMensagem(String mensagem) {
        this.mensagem = mensagem;
    }
}

3. Criando a Interface com JSF

Crie uma página JSF simples (index.xhtml):

<h:form>
    <h:inputText value="#{saudacaoBean.nome}" />
    <h:commandButton value="Saudar" action="#{saudacaoBean.saudar}" />
    <h:outputText value="#{saudacaoBean.mensagem}" />
</h:form>

4. Testabilidade Facilitada com CDI utilizando JUnit

Passo 1: Adicionar Dependências no pom.xml

Adicione as dependências para JUnit 5 e Mockito:

<dependencies>
    <!-- JUnit 5 para testes -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito para criar mocks -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>3.9.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Passo 2: Criar o Teste Unitário

Aqui está um exemplo de teste unitário para o SaudacaoBean utilizando o JUnit 5 e Mockito:

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

public class SaudacaoBeanTest {

    // Cria um mock do SaudacaoService
    @Mock
    private SaudacaoService saudacaoService;

    // Injeta o mock no SaudacaoBean
    @InjectMocks
    private SaudacaoBean saudacaoBean;

    // Inicializa os mocks antes de cada teste
    @BeforeEach
    public void setup() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testSaudar() {
        // Define o comportamento do mock
        when(saudacaoService.saudar("Mundo")).thenReturn("Olá, Mundo!");

        // Define o nome no bean
        saudacaoBean.setNome("Mundo");

        // Chama o método saudar
        saudacaoBean.saudar();

        // Verifica se a mensagem foi gerada corretamente
        assertEquals("Olá, Mundo!", saudacaoBean.getMensagem());

        // Verifica se o método saudar foi chamado com o argumento correto
        verify(saudacaoService).saudar("Mundo");
    }
}

5. Executando o Projeto no WildFly

Passo 1: Build do Projeto

Execute o build do projeto com o Maven. No IntelliJ, clique em Maven > Lifecycle > install.

Passo 2: Deploy no WildFly

1. Inicie o servidor WildFly.

2. Faça o deploy do arquivo .war gerado na pasta target no diretório standalone/deployments do WildFly.

3. Acesse a aplicação no navegador:

http://localhost:8080/seu-projeto/index.xhtml

Conclusão

Neste tutorial, você aprendeu como configurar um projeto com JSF e CDI no IntelliJ IDEA Community, utilizando o WildFly como servidor. Passamos por todas as etapas essenciais, desde a configuração inicial até a criação de testes automatizados com JUnit e Mockito. Agora, você tem uma base sólida para desenvolver aplicações web robustas e organizadas.

Espero que este guia tenha sido útil e ajudado a direcionar seus estudos. Obrigado por acessar meu blog e continuar acompanhando para mais conteúdos que possam te apoiar de alguma forma. Até mais! :)