Mitarbeiterverwaltungssystem mit Spring IoC aufbauen

Einführung

In diesem Projekt lernst du, wie du ein Mitarbeiterverwaltungssystem mit dem Spring IoC (Inversion of Control)-Container aufbauen kannst. Ziel ist es, den Spring IoC-Container zu verwenden, um Mitarbeiterinformationen aus einer Konfigurationsdatei zu extrahieren und in einer Liste zu speichern, aus der die Mitarbeiterinformationen abgerufen und gedruckt werden können.

👀 Vorschau

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running org.labex.TestEmployeeSystem
11. Mai 2024 2:28:53 Uhr morgens org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
11. Mai 2024 2:28:53 Uhr morgens org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
11. Mai 2024 2:28:53 Uhr morgens org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
11. Mai 2024 2:28:53 Uhr morgens org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
11. Mai 2024 2:28:53 Uhr morgens org.labex.service.EmployeeServiceImpl addEmployee
INFO: Entering addEmployee() method
11. Mai 2024 2:28:53 Uhr morgens 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

🎯 Aufgaben

In diesem Projekt wirst du lernen:

Wie du die Schnittstelle IEmployeeService implementierst, um mit Mitarbeiterrelevanten Operationen umzugehen
Wie du die Klasse EmployeeServiceImpl erstellst, um die Implementierung der Schnittstelle IEmployeeService bereitzustellen
Wie du den Spring IoC-Container konfigurierst, um die Annotation-basierte Paketscanning zu aktivieren
Wie du die test()-Methode implementierst, um Mitarbeiterinformationen aus dem Spring IoC-Container abzurufen und auszugeben

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

Den Spring IoC-Container verwenden, um Mitarbeiterdaten zu verwalten
Service-Schnittstellen und deren Implementierungen mit Annotations zu implementieren
Den Spring IoC-Container mit einer XML-Konfigurationsdatei zu konfigurieren
Mitarbeiterinformationen aus dem Spring IoC-Container abzurufen und auszugeben

Implementiere das IEmployeeService-Schnittstelle

In diesem Schritt lernst du, wie du die Schnittstelle IEmployeeService implementierst. Folge den Schritten unten, um diesen Schritt abzuschließen:

Öffne die Datei IEmployeeService.java im Verzeichnis EmployeeSystemIoC/src/main/java/org/labex/service.
Deklariere zwei Methoden in der Schnittstelle IEmployeeService:
- addEmployee: Diese Methode nimmt ein Employee-Objekt als Parameter und gibt einen booleschen Wert zurück. Sie wird verwendet, um das Mitarbeiterobjekt zur Liste hinzuzufügen.
- getAllEmployees: Diese Methode hat keine Parameter und gibt eine List zurück. Sie wird verwendet, um alle Mitarbeiterinformationen abzurufen.

Deine Datei IEmployeeService.java sollte so aussehen:

package org.labex.service;

import org.labex.pojo.Employee;

import java.util.List;

public interface IEmployeeService {
    boolean addEmployee(Employee employee);

    List<Employee> getAllEmployees();
}

Implementiere die EmployeeServiceImpl-Klasse

In diesem Schritt lernst du, wie du die Klasse EmployeeServiceImpl implementierst, die die Implementierung der Schnittstelle IEmployeeService ist.

Erstelle eine neue Datei namens EmployeeServiceImpl.java im Verzeichnis EmployeeSystemIoC/src/main/java/org/labex/service.
Implementiere die Klasse EmployeeServiceImpl und lasse sie die Schnittstelle IEmployeeService implementieren.
Annotiere die Klasse EmployeeServiceImpl mit der Annotation @Service.
Deklariere eine statische List-Kollektion global und weise ihr in dem Parameterlosen Konstruktor ein Objekt der Kollektion zu.
Implementiere die Methoden addEmployee() und getAllEmployees():
- In der Methode addEmployee() logge den Ausführungsablauf mit der Methode logger.info().
- In der Methode getAllEmployees() logge den Ausführungsablauf mit der Methode logger.info().

Deine Datei EmployeeServiceImpl.java sollte so aussehen:

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

Konfiguriere den Spring IoC-Container

In diesem Schritt lernst du, wie du den Spring IoC-Container konfigurierst, um die Annotation-basierte Paketscanning zu aktivieren.

Öffne die Datei applicationContext.xml im Verzeichnis EmployeeSystemIoC/src/main/resources.

Füge die folgenden XML-Namespace-Deklarationen zum <beans>-Element hinzu:

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"

Füge das <context:component-scan>-Element hinzu, um die Annotation-basierte Paketscanning für das org.labex-Paket zu aktivieren.

Deine Datei applicationContext.xml sollte so aussehen:

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

    <!-- Aktivieren Sie die Komponentenscanning für Annotations -->
    <context:component-scan base-package="org.labex"/>

    <!-- Mitarbeiterinformationen -->
    <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"/>

    <!-- Fügen Sie hier weitere Mitarbeiter-Beans hinzu -->

</beans>

Implementiere die Testmethode

In diesem Schritt lernst du, wie du die test()-Methode in der Datei TestEmployeeSystem.java implementierst.

Öffne die Datei TestEmployeeSystem.java im Verzeichnis EmployeeSystemIoC/src/test/java/org/labex.
Implementiere die test()-Methode:
- Erstelle ein ClassPathXmlApplicationContext-Objekt und lade die Datei applicationContext.xml
- Hole das EmployeeServiceImpl-Bean aus dem Spring IoC-Container
- Hole die Mitarbeiter-Beans aus dem Spring IoC-Container und füge sie mit der addEmployee()-Methode zum EmployeeServiceImpl hinzu
- Drucke alle Mitarbeiterinformationen aus, indem du die getAllEmployees()-Methode des EmployeeServiceImpl-Beans aufrufst.

Deine Datei TestEmployeeSystem.java sollte so aussehen:

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

Jetzt hast du die Implementierung des Spring IoC Mitarbeiterverwaltungssystems abgeschlossen. Du kannst die test()-Methode ausführen, um die Funktionalität der Anwendung zu überprüfen.

Führe den Test aus:

cd ~/project/EmployeeSystemIoC/
mvn test

Die Ausgabe sollte ähnlich der folgenden sein:



() method

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Labs absolvieren, um deine Fähigkeiten zu verbessern.