Construire un système de gestion d'employés avec Spring IoC

Introduction

Dans ce projet, vous allez apprendre à construire un système de gestion d'employés à l'aide du conteneur Spring IoC (Inversion of Control). L'objectif est d'utiliser le conteneur Spring IoC pour extraire les informations des employés à partir d'un fichier de configuration et les stocker dans une collection de listes, à partir de laquelle les informations des employés peuvent être récupérées et imprimées.

👀 Aperçu

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Exécution de org.labex.TestEmployeeSystem
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl getAllEmployees
INFO: Entrée dans la méthode getAllEmployees()
Employés [employeeId=000001, employeeName=John Doe, employeeSex=Male, employeeBirthday=1993-11-06, employeeHiredate=2018-10-11, userId=1]
Employés [employeeId=000021, employeeName=Jane Smith, employeeSex=Female, employeeBirthday=1990-07-16, employeeHiredate=2019-10-21, userId=4]
Employés [employeeId=000022, employeeName=Alice Johnson, employeeSex=Female, employeeBirthday=1993-02-11, employeeHiredate=2019-12-27, userId=12]
Employés [employeeId=000035, employeeName=Bob Brown, employeeSex=Male, employeeBirthday=1991-06-23, employeeHiredate=2020-05-06, userId=19]
Employés [employeeId=000066, employeeName=Mary Taylor, employeeSex=Female, employeeBirthday=1997-12-21, employeeHiredate=2021-01-03, userId=20]
Tests exécutés: 1, Échecs: 0, Erreurs: 0, Ignorés: 0, Temps écoulé: 1,499 s

🎯 Tâches

Dans ce projet, vous allez apprendre :

Comment implémenter l'interface IEmployeeService pour gérer les opérations liées aux employés
Comment créer la classe EmployeeServiceImpl pour fournir l'implémentation de l'interface IEmployeeService
Comment configurer le conteneur Spring IoC pour activer la recherche de packages basée sur des annotations
Comment implémenter la méthode test() pour récupérer les informations des employés à partir du conteneur Spring IoC et les imprimer

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

Utiliser le conteneur Spring IoC pour gérer les données des employés
Implémenter des interfaces de service et leurs implémentations à l'aide d'annotations
Configurer le conteneur Spring IoC à l'aide d'un fichier de configuration XML
Récupérer et imprimer les informations des employés à partir du conteneur Spring IoC

Implémenter l'interface IEmployeeService

Dans cette étape, vous allez apprendre à implémenter l'interface IEmployeeService. Suivez les étapes ci-dessous pour terminer cette étape :

Ouvrez le fichier IEmployeeService.java situé dans le répertoire EmployeeSystemIoC/src/main/java/org/labex/service.
Décarez deux méthodes dans l'interface IEmployeeService :
- addEmployee : Cette méthode prend un objet Employee en paramètre et renvoie une valeur booléenne. Elle est utilisée pour ajouter l'objet employé à la liste.
- getAllEmployees : Cette méthode n'a pas de paramètres et renvoie une List. Elle est utilisée pour récupérer toutes les informations des employés.

Votre fichier IEmployeeService.java devrait ressembler à ceci :

package org.labex.service;

import org.labex.pojo.Employee;

import java.util.List;

public interface IEmployeeService {
    boolean addEmployee(Employee employee);

    List<Employee> getAllEmployees();
}

Implémenter la classe EmployeeServiceImpl

Dans cette étape, vous allez apprendre à implémenter la classe EmployeeServiceImpl, qui est l'implémentation de l'interface IEmployeeService.

Créez un nouveau fichier appelé EmployeeServiceImpl.java dans le répertoire EmployeeSystemIoC/src/main/java/org/labex/service.
Implémentez la classe EmployeeServiceImpl et faites en sorte qu'elle implémente l'interface IEmployeeService.
Annotez la classe EmployeeServiceImpl avec l'annotation @Service.
Décarez une collection List statique globalement et assignez un objet de collection dans le constructeur sans paramètres.
Implémentez les méthodes addEmployee() et getAllEmployees() :
- Dans la méthode addEmployee(), enregistrez le processus d'exécution à l'aide de la méthode logger.info().
- Dans la méthode getAllEmployees(), enregistrez le processus d'exécution à l'aide de la méthode logger.info().

Votre fichier EmployeeServiceImpl.java devrait ressembler à ceci :

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

Configurer le conteneur Spring IoC

Dans cette étape, vous allez apprendre à configurer le conteneur Spring IoC pour activer la recherche de packages basée sur des annotations.

Ouvrez le fichier applicationContext.xml situé dans le répertoire EmployeeSystemIoC/src/main/resources.

Ajoutez les déclarations d'espaces de noms XML suivantes à l'élément <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"

Ajoutez l'élément <context:component-scan> pour activer la recherche de packages basée sur des annotations pour le package org.labex.

Votre fichier applicationContext.xml devrait ressembler à ceci :

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

    <!-- Activer la recherche de composants pour les annotations -->
    <context:component-scan base-package="org.labex"/>

    <!-- Informations sur les employés -->
    <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"/>

    <!-- Ajoutez plus de beans d'employés ici -->

</beans>

Implémenter la méthode de test

Dans cette étape, vous allez apprendre à implémenter la méthode test() dans le fichier TestEmployeeSystem.java.

Ouvrez le fichier TestEmployeeSystem.java situé dans le répertoire EmployeeSystemIoC/src/test/java/org/labex.
Implémentez la méthode test() :
- Créez un objet ClassPathXmlApplicationContext et chargez le fichier applicationContext.xml.
- Récupérez le bean EmployeeServiceImpl à partir du conteneur Spring IoC.
- Récupérez les beans d'employés à partir du conteneur Spring IoC et ajoutez-les à EmployeeServiceImpl à l'aide de la méthode addEmployee().
- Affichez toutes les informations des employés en appelant la méthode getAllEmployees() du bean EmployeeServiceImpl.

Votre fichier TestEmployeeSystem.java devrait ressembler à ceci :

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

        // Récupérer les beans d'employés à partir du contexte
        Employee emp1 = (Employee) context.getBean("emp1");
        employeeService.addEmployee(emp1);
        Employee emp2 = (Employee) context.getBean("emp2");
        employeeService.addEmployee(emp2);
        // Ajoutez plus de beans d'employés ici

        // Affichez les informations des employés
        for (Employee e : employeeService.getAllEmployees()) {
            System.out.println(e.toString());
        }
    }
}

Maintenant, vous avez terminé l'implémentation du système de gestion d'employés Spring IoC. Vous pouvez exécuter la méthode test() pour vérifier la fonctionnalité de l'application.

Exécutez les tests :

cd ~/project/EmployeeSystemIoC/
mvn test

La sortie devrait être similaire à la suivante :



-----------------------------------------------------
 T E S T S
-------------------------------------------------------
Exécution de org.labex.TestEmployeeSystem
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entrée dans la méthode addEmployee()
11 mai 2024 02:28:53 org.labex.service.EmployeeServiceImpl addEmployee

Résumé

Félicitations ! Vous avez terminé ce projet. Vous pouvez pratiquer plus de laboratoires sur LabEx pour améliorer vos compétences.

Système de gestion d'employés Spring IoC