Construa um Sistema de Gerenciamento de Funcionários com Spring IoC em Java

Introdução

Neste projeto, você aprenderá como construir um sistema de gerenciamento de funcionários usando o contêiner Spring IoC (Inversion of Control). O objetivo é usar o contêiner Spring IoC para extrair informações de funcionários de um arquivo de configuração e armazená-las em uma coleção de listas, da qual as informações dos funcionários podem ser recuperadas e impressas.

👀 Visualização

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running org.labex.TestEmployeeSystem
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl getAllEmployees
INFO: Entering getAllEmployees() method
Employees [employeeId=000001, employeeName=John Doe, employeeSex=Male, employeeBirthday=1993-11-06, employeeHiredate=2018-10-11, userId=1]
Employees [employeeId=000021, employeeName=Jane Smith, employeeSex=Female, employeeBirthday=1990-07-16, employeeHiredate=2019-10-21, userId=4]
Employees [employeeId=000022, employeeName=Alice Johnson, employeeSex=Female, employeeBirthday=1993-02-11, employeeHiredate=2019-12-27, userId=12]
Employees [employeeId=000035, employeeName=Bob Brown, employeeSex=Male, employeeBirthday=1991-06-23, employeeHiredate=2020-05-06, userId=19]
Employees [employeeId=000066, employeeName=Mary Taylor, employeeSex=Female, employeeBirthday=1997-12-21, employeeHiredate=2021-01-03, userId=20]
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.499 sec

🎯 Tarefas

Neste projeto, você aprenderá:

Como implementar a interface IEmployeeService para lidar com operações relacionadas a funcionários
Como criar a classe EmployeeServiceImpl para fornecer a implementação da interface IEmployeeService
Como configurar o contêiner Spring IoC para habilitar a varredura de pacotes baseada em anotações
Como implementar o método test() para recuperar informações de funcionários do contêiner Spring IoC e imprimi-las

🏆 Conquistas

Após concluir este projeto, você será capaz de:

Usar o contêiner Spring IoC para gerenciar dados de funcionários
Implementar interfaces de serviço e suas implementações usando anotações
Configurar o contêiner Spring IoC usando um arquivo de configuração XML
Recuperar e imprimir informações de funcionários do contêiner Spring IoC

Implementar a Interface IEmployeeService

Nesta etapa, você aprenderá como implementar a interface IEmployeeService. Siga os passos abaixo para concluir esta etapa:

Abra o arquivo IEmployeeService.java localizado no diretório EmployeeSystemIoC/src/main/java/org/labex/service.
Declare dois métodos na interface IEmployeeService:
- addEmployee: Este método recebe um objeto Employee como parâmetro e retorna um valor booleano. Ele é usado para adicionar o objeto funcionário à lista.
- getAllEmployees: Este método não possui parâmetros e retorna um List. Ele é usado para recuperar todas as informações dos funcionários.

Seu arquivo IEmployeeService.java deve ser semelhante a este:

package org.labex.service;

import org.labex.pojo.Employee;

import java.util.List;

public interface IEmployeeService {
    boolean addEmployee(Employee employee);

    List<Employee> getAllEmployees();
}

Implementar a Classe EmployeeServiceImpl

Nesta etapa, você aprenderá como implementar a classe EmployeeServiceImpl, que é a implementação da interface IEmployeeService.

Crie um novo arquivo chamado EmployeeServiceImpl.java no diretório EmployeeSystemIoC/src/main/java/org/labex/service.
Implemente a classe EmployeeServiceImpl e faça com que ela implemente a interface IEmployeeService.
Anote a classe EmployeeServiceImpl com a anotação @Service.
Declare uma coleção List estática globalmente e atribua um objeto de coleção no construtor sem parâmetros.
Implemente os métodos addEmployee() e getAllEmployees():
- No método addEmployee(), registre o processo de execução usando o método logger.info().
- No método getAllEmployees(), registre o processo de execução usando o método logger.info().

Seu arquivo EmployeeServiceImpl.java deve ser semelhante a este:

package org.labex.service;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.labex.pojo.Employee;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class EmployeeServiceImpl implements IEmployeeService {

    private static List<Employee> employees;

    private static final Log logger  = LogFactory.getLog(EmployeeServiceImpl.class);

    public EmployeeServiceImpl() {
        employees = new ArrayList<>();
    }

    @Override
    public boolean addEmployee(Employee employee) {
        logger.info("Entering addEmployee() method");
        return employees.add(employee);
    }

    @Override
    public List<Employee> getAllEmployees() {
        logger.info("Entering getAllEmployees() method");
        return employees;
    }
}

Configurar o Container IoC do Spring

Nesta etapa, você aprenderá como configurar o contêiner IoC (Inversion of Control) do Spring para habilitar a varredura de pacotes baseada em anotações.

Abra o arquivo applicationContext.xml localizado no diretório EmployeeSystemIoC/src/main/resources.

Adicione as seguintes declarações de namespace XML ao elemento <beans>:

xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context.xsd"

Adicione o elemento <context:component-scan> para habilitar a varredura de pacotes baseada em anotações para o pacote org.labex.

Seu arquivo applicationContext.xml deve ser semelhante a este:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- Enable component scanning for annotations -->
    <context:component-scan base-package="org.labex"/>

    <!-- Employee Information -->
    <bean id="emp1" class="org.labex.pojo.Employee"
          c:employeeId="000001" c:employeeName="John Doe" c:employeeSex="Male"
          c:employeeBirthday="1993-11-06" c:employeeHiredate="2018-10-11" c:userId="1"/>

    <bean id="emp2" class="org.labex.pojo.Employee"
          c:employeeId="000021" c:employeeName="Jane Smith" c:employeeSex="Female"
          c:employeeBirthday="1990-07-16" c:employeeHiredate="2019-10-21" c:userId="4"/>

    <!-- Add more employee beans here -->

</beans>

Implementar o Método de Teste

Nesta etapa, você aprenderá como implementar o método test() no arquivo TestEmployeeSystem.java.

Abra o arquivo TestEmployeeSystem.java localizado no diretório EmployeeSystemIoC/src/test/java/org/labex.
Implemente o método test():
- Crie um objeto ClassPathXmlApplicationContext e carregue o arquivo applicationContext.xml.
- Recupere o bean EmployeeServiceImpl do contêiner IoC do Spring.
- Recupere os beans de funcionário do contêiner IoC do Spring e adicione-os ao EmployeeServiceImpl usando o método addEmployee().
- Imprima todas as informações do funcionário chamando o método getAllEmployees() do bean EmployeeServiceImpl.

Seu arquivo TestEmployeeSystem.java deve ser semelhante a este:

package org.labex;

import org.junit.Test;
import org.labex.pojo.Employee;
import org.labex.service.EmployeeServiceImpl;
import org.labex.service.IEmployeeService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestEmployeeSystem {

    @Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        IEmployeeService employeeService = context.getBean(EmployeeServiceImpl.class);

        // Retrieve Employee beans from the context
        Employee emp1 = (Employee) context.getBean("emp1");
        employeeService.addEmployee(emp1);
        Employee emp2 = (Employee) context.getBean("emp2");
        employeeService.addEmployee(emp2);
        // Add more employee beans here

        // Print out employee information
        for (Employee e : employeeService.getAllEmployees()) {
            System.out.println(e.toString());
        }
    }
}

Agora, você concluiu a implementação do Sistema de Gerenciamento de Funcionários com Spring IoC. Você pode executar o método test() para verificar a funcionalidade da aplicação.

Execute o teste:

cd ~/project/EmployeeSystemIoC/
mvn test

A saída deve ser semelhante à seguinte:



y 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
May 11, 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee

Resumo

Parabéns! Você concluiu este projeto. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.