Système de gestion d'employés 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

Skills Graph

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 :

1. Ouvrez le fichier IEmployeeService.java situé dans le répertoire EmployeeSystemIoC/src/main/java/org/labex/service.

2. 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.

1. Créez un nouveau fichier appelé EmployeeServiceImpl.java dans le répertoire EmployeeSystemIoC/src/main/java/org/labex/service.

2. Implémentez la classe EmployeeServiceImpl et faites en sorte qu'elle implémente l'interface IEmployeeService.

3. Annotez la classe EmployeeServiceImpl avec l'annotation @Service.

4. Décarez une collection List statique globalement et assignez un objet de collection dans le constructeur sans paramètres.

5. 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.

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

2. 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"

3. 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.

1. Ouvrez le fichier TestEmployeeSystem.java situé dans le répertoire EmployeeSystemIoC/src/test/java/org/labex.

2. 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.

3. 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
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

Résultats :

Tests exécutés: 1, Échecs: 0, Erreurs: 0, Ignorés: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Temps total:  6,199 s
[INFO] Terminé à: 2024-05-11T02:28:53Z
[INFO] ------------------------------------------------------------------------

Sommaire

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