Spring IoC Mitarbeiterverwaltungssystem

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

Skills Graph

Implementiere die Schnittstelle IEmployeeService

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

1. Öffne die Datei IEmployeeService.java im Verzeichnis EmployeeSystemIoC/src/main/java/org/labex/service.

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

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

1. Erstelle eine neue Datei namens EmployeeServiceImpl.java im Verzeichnis EmployeeSystemIoC/src/main/java/org/labex/service.

2. Implementiere die Klasse EmployeeServiceImpl und lasse sie die Schnittstelle IEmployeeService implementieren.

3. Annotiere die Klasse EmployeeServiceImpl mit der Annotation @Service.

4. Deklariere eine statische List-Kollektion global und weise ihr in dem Parameterlosen Konstruktor ein Objekt der Kollektion zu.

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

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

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

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

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

1. Öffne die Datei TestEmployeeSystem.java im Verzeichnis EmployeeSystemIoC/src/test/java/org/labex.

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

3. Führe den Test aus:

cd ~/project/EmployeeSystemIoC/
mvn test

Die Ausgabe sollte ähnlich der folgenden sein:

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

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  6.199 s
[INFO] Finished at: 2024-05-11T02:28:53Z
[INFO] ------------------------------------------------------------------------

Zusammenfassung

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