Construir un sistema de gestión de empleados con Spring IoC

Introducción

En este proyecto, aprenderá a construir un sistema de gestión de empleados utilizando el contenedor Spring IoC (Inversión de Control). El objetivo es utilizar el contenedor Spring IoC para extraer información de empleados de un archivo de configuración y almacenarla en una colección de listas, de la cual se puede recuperar e imprimir la información de empleados.

👀 Vista previa

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Ejecutando org.labex.TestEmployeeSystem
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl getAllEmployees
INFO: Entrando en el método getAllEmployees()
Empleados [employeeId=000001, employeeName=John Doe, employeeSex=Masculino, employeeBirthday=1993-11-06, employeeHiredate=2018-10-11, userId=1]
Empleados [employeeId=000021, employeeName=Jane Smith, employeeSex=Femenino, employeeBirthday=1990-07-16, employeeHiredate=2019-10-21, userId=4]
Empleados [employeeId=000022, employeeName=Alice Johnson, employeeSex=Femenino, employeeBirthday=1993-02-11, employeeHiredate=2019-12-27, userId=12]
Empleados [employeeId=000035, employeeName=Bob Brown, employeeSex=Masculino, employeeBirthday=1991-06-23, employeeHiredate=2020-05-06, userId=19]
Empleados [employeeId=000066, employeeName=Mary Taylor, employeeSex=Femenino, employeeBirthday=1997-12-21, employeeHiredate=2021-01-03, userId=20]
Pruebas ejecutadas: 1, Fallos: 0, Errores: 0, Omisiones: 0, Tiempo transcurrido: 1,499 segundos

🎯 Tareas

En este proyecto, aprenderá:

Cómo implementar la interfaz IEmployeeService para manejar operaciones relacionadas con los empleados
Cómo crear la clase EmployeeServiceImpl para proporcionar la implementación de la interfaz IEmployeeService
Cómo configurar el contenedor Spring IoC para habilitar la exploración de paquetes basada en anotaciones
Cómo implementar el método test() para recuperar información de empleados del contenedor Spring IoC e imprimirla

🏆 Logros

Después de completar este proyecto, podrá:

Utilizar el contenedor Spring IoC para administrar datos de empleados
Implementar interfaces de servicio y sus implementaciones utilizando anotaciones
Configurar el contenedor Spring IoC utilizando un archivo de configuración XML
Recuperar e imprimir información de empleados del contenedor Spring IoC

Implementar la interfaz IEmployeeService

En este paso, aprenderá a implementar la interfaz IEmployeeService. Siga los pasos siguientes para completar este paso:

Abra el archivo IEmployeeService.java ubicado en el directorio EmployeeSystemIoC/src/main/java/org/labex/service.
Declare dos métodos en la interfaz IEmployeeService:
- addEmployee: Este método toma un objeto Employee como parámetro y devuelve un valor booleano. Se utiliza para agregar el objeto de empleado a la lista.
- getAllEmployees: Este método no tiene parámetros y devuelve una List. Se utiliza para recuperar toda la información de empleados.

Su archivo IEmployeeService.java debería verse así:

package org.labex.service;

import org.labex.pojo.Employee;

import java.util.List;

public interface IEmployeeService {
    boolean addEmployee(Employee employee);

    List<Employee> getAllEmployees();
}

Implementar la clase EmployeeServiceImpl

En este paso, aprenderá a implementar la clase EmployeeServiceImpl, que es la implementación de la interfaz IEmployeeService.

Cree un nuevo archivo llamado EmployeeServiceImpl.java en el directorio EmployeeSystemIoC/src/main/java/org/labex/service.
Implemente la clase EmployeeServiceImpl y hágala implementar la interfaz IEmployeeService.
Anote la clase EmployeeServiceImpl con la anotación @Service.
Declare una colección estática List globalmente y asigne un objeto de colección en el constructor sin parámetros.
Implemente los métodos addEmployee() y getAllEmployees():
- En el método addEmployee(), registre el proceso de ejecución utilizando el método logger.info().
- En el método getAllEmployees(), registre el proceso de ejecución utilizando el método logger.info().

Su archivo EmployeeServiceImpl.java debería verse así:

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 el contenedor Spring IoC

En este paso, aprenderá a configurar el contenedor Spring IoC para habilitar la exploración de paquetes basada en anotaciones.

Abra el archivo applicationContext.xml ubicado en el directorio EmployeeSystemIoC/src/main/resources.

Agregue las siguientes declaraciones de espacios de nombres XML al 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"

Agregue el elemento <context:component-scan> para habilitar la exploración de paquetes basada en anotaciones para el paquete org.labex.

Su archivo applicationContext.xml debería verse así:

<?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">

    <!-- Habilitar la exploración de componentes para anotaciones -->
    <context:component-scan base-package="org.labex"/>

    <!-- Información de empleados -->
    <bean id="emp1" class="org.labex.pojo.Employee"
          c:employeeId="000001" c:employeeName="John Doe" c:employeeSex="Masculino"
          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="Femenino"
          c:employeeBirthday="1990-07-16" c:employeeHiredate="2019-10-21" c:userId="4"/>

    <!-- Agregue más beans de empleados aquí -->

</beans>

Implementar el método de prueba

En este paso, aprenderá a implementar el método test() en el archivo TestEmployeeSystem.java.

Abra el archivo TestEmployeeSystem.java ubicado en el directorio EmployeeSystemIoC/src/test/java/org/labex.
Implemente el método test():
- Cree un objeto ClassPathXmlApplicationContext y cargue el archivo applicationContext.xml.
- Recupere el bean EmployeeServiceImpl del contenedor Spring IoC.
- Recupere los beans de empleados del contenedor Spring IoC y agréguelos al EmployeeServiceImpl utilizando el método addEmployee().
- Imprima toda la información de empleados llamando al método getAllEmployees() del bean EmployeeServiceImpl.

Su archivo TestEmployeeSystem.java debería verse así:

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);

        // Recuperar beans de empleados del contexto
        Employee emp1 = (Employee) context.getBean("emp1");
        employeeService.addEmployee(emp1);
        Employee emp2 = (Employee) context.getBean("emp2");
        employeeService.addEmployee(emp2);
        // Agregar más beans de empleados aquí

        // Imprimir la información de empleados
        for (Employee e : employeeService.getAllEmployees()) {
            System.out.println(e.toString());
        }
    }
}

Ahora, ha completado la implementación del sistema de gestión de empleados con Spring IoC. Puede ejecutar el método test() para verificar la funcionalidad de la aplicación.

Ejecute la prueba:

cd ~/project/EmployeeSystemIoC/
mvn test

La salida debería ser similar a la siguiente:



:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrando en el método addEmployee()
11 de mayo de 2024 2:28:53 AM org.labex.service.EmployeeServiceImpl getAllEmployees
INFO: Entrando en el método getAllEmployees()

Resumen

¡Felicidades! Has completado este proyecto. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.

Sistema de gestión de empleados con Spring IoC