Chinesisch-Englische Informationsumschaltung über IoC

Einführung

In diesem Projekt lernst du, wie du mithilfe des Inversion of Control (IoC)-Designmusters und des Spring-Frameworks ein einfaches Chinesisch-Englisch-Nachrichtenswitchingsystem implementierst.

👀 Vorschau

[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.labex.TestGreeting
你好, Labex
Hello, Labex
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.056 s - in com.labex.TestGreeting
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 11.295 s
[INFO] Finished at: 2024-05-10T12:05:55Z
[INFO] ------------------------------------------------------------------------

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie du ein IMessage-Interface mit einer abstrakten doMessage()-Methode erstellst
• Wie du das IMessage-Interface in zwei konkreten Klassen implementierst: MessageCN und MessageEN
• Wie du die Nachrichtenbeans mithilfe der applicationContext.xml-Datei konfigurierst
• Wie du die Nachrichtenwechselfunktionalität in der TestGreeting-Klasse testest

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Das IoC-Designmuster zu verwenden, um die Implementierung der Nachrichtenfunktionalität von der Hauptanwendung zu entkoppeln
• Das Spring-Framework zu verwenden, um die Nachrichtenbeans zu konfigurieren und zu verwalten
• Unit-Tests zu schreiben, um die Funktionalität des Nachrichtenwechselungssystems zu überprüfen

Skills Graph

Erstellen der IMessage-Schnittstelle

In diesem Schritt erstellst du die Schnittstelle IMessage, die eine abstrakte Methode namens doMessage() ohne Rückgabewert enthält.

1. Erstelle eine neue Java-Datei namens IMessage.java im Paket com.labex.
2. Definiere innerhalb der Datei die Schnittstelle IMessage mit dem folgenden Code:

package com.labex;

// Schnittstelle für die Nachrichtenfunktionalität
public interface IMessage {
    // Methodensignatur zum Anzeigen einer Nachricht
    void doMessage();
}

Diese Schnittstelle definiert die grundlegende Struktur für jede Klasse, die die Nachrichtenfunktionalität implementieren möchte. Die Methode doMessage() ist eine abstrakte Methode, die von den konkreten Nachrichtenklassen implementiert werden wird.

Erstellen der MessageCN-Klasse

In diesem Schritt erstellst du die Klasse MessageCN, die das IMessage-Interface implementiert. Diese Klasse wird ein Attribut msg haben und get/set-Methoden bereitstellen. Sie wird auch die doMessage()-Methode überschreiben, um die Zeichenfolge "你好,Labex" auszugeben.

1. Erstelle eine neue Java-Datei namens MessageCN.java im Paket com.labex.
2. Definiere innerhalb der Datei die Klasse MessageCN mit dem folgenden Code:

package com.labex;

// Implementierung des IMessage-Interfaces für chinesische Nachrichten
public class MessageCN implements IMessage {
    private String msg; // Variable zum Speichern der Nachricht

    // Getter-Methode zum Abrufen der Nachricht
    public String getMsg() {
        return msg;
    }

    // Setter-Methode zum Festlegen der Nachricht
    public void setMsg(String msg) {
        this.msg = msg;
    }

    // Implementierung der doMessage-Methode aus dem IMessage-Interface
    @Override
    public void doMessage() {
        // Druckt eine Begrüßungsnachricht auf Chinesisch
        System.out.println("你好, " + msg);
    }
}

Die Klasse MessageCN implementiert das IMessage-Interface und liefert die Implementierung für die doMessage()-Methode, die eine Begrüßungsnachricht auf Chinesisch ausgibt.

Erstellen der MessageEN-Klasse

In diesem Schritt erstellst du die Klasse MessageEN, die ebenfalls das IMessage-Interface implementiert. Diese Klasse wird ein Attribut msg haben und get/set-Methoden bereitstellen. Sie wird die doMessage()-Methode überschreiben, um die Zeichenfolge "hello,Labex" auszugeben.

1. Erstelle eine neue Java-Datei namens MessageEN.java im Paket com.labex.
2. Definiere innerhalb der Datei die Klasse MessageEN mit dem folgenden Code:

package com.labex;

// Implementierung des IMessage-Interfaces für englische Nachrichten
public class MessageEN implements IMessage {
    private String msg; // Variable zum Speichern der Nachricht

    // Getter-Methode zum Abrufen der Nachricht
    public String getMsg() {
        return msg;
    }

    // Setter-Methode zum Festlegen der Nachricht
    public void setMsg(String msg) {
        this.msg = msg;
    }

    // Implementierung der doMessage-Methode aus dem IMessage-Interface
    @Override
    public void doMessage() {
        // Druckt eine Begrüßungsnachricht auf Englisch
        System.out.println("Hello, " + msg);
    }
}

Die Klasse MessageEN implementiert das IMessage-Interface und liefert die Implementierung für die doMessage()-Methode, die eine Begrüßungsnachricht auf Englisch ausgibt.

Erstellen der applicationContext.xml-Konfigurationsdatei

In diesem Schritt erstellst du die applicationContext.xml-Konfigurationsdatei, um die oben erstellten JavaBeans zu konfigurieren und die msg-Attributinformationen in der Konfiguration zu übergeben.

1. Erstelle eine neue Datei namens applicationContext.xml im Verzeichnis src/main/resources.
2. Füge innerhalb der Datei die folgende XML-Konfiguration hinzu:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Konfiguration für die chinesische Nachrichtenbean -->
    <bean id="messageCN" class="com.labex.MessageCN">
        <!-- Setze die Eigenschaft 'msg' der MessageCN-bean auf "Labex" -->
        <property name="msg" value="Labex"/>
    </bean>

    <!-- Konfiguration für die englische Nachrichtenbean -->
    <bean id="messageEN" class="com.labex.MessageEN">
        <!-- Setze die Eigenschaft 'msg' der MessageEN-bean auf "Labex" -->
        <property name="msg" value="Labex"/>
    </bean>

</beans>

Diese Konfigurationsdatei konfiguriert die MessageCN- und MessageEN-Beans und initialisiert ihre msg-Eigenschaften mit dem Wert "Labex".

Erstellen der TestGreeting-Klasse

In diesem Schritt erstellst du die Klasse TestGreeting und fügst eine Testmethode namens testGreeting() hinzu, um die Testoperation durchzuführen.

1. Erstelle eine neue Java-Datei namens TestGreeting.java im Paket com.labex.
2. Definiere innerhalb der Datei die Klasse TestGreeting mit dem folgenden Code:

package com.labex;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestGreeting {

    @Test
    public void testGreeting() {
        // Lade den Spring-Anwendungscontext aus der XML-Konfigurationsdatei
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // Hole die Nachrichtenbeans aus dem Kontext
        IMessage messageCN = (IMessage) context.getBean("messageCN"); // Chinesische Nachrichtenbean
        IMessage messageEN = (IMessage) context.getBean("messageEN"); // Englische Nachrichtenbean

        // Rufe die 'doMessage'-Methode auf der chinesischen Nachrichtenbean auf
        messageCN.doMessage();

        // Rufe die 'doMessage'-Methode auf der englischen Nachrichtenbean auf
        messageEN.doMessage();

        context.close();
    }
}

Die TestGreeting-Klasse lädt den Spring-Anwendungscontext aus der applicationContext.xml-Datei, holt die MessageCN- und MessageEN-Beans und ruft dann deren doMessage()-Methoden auf, um die Funktionalität zu testen.

Jetzt hast du alle Schritte zum Erstellen des Projekts zur chinesisch-englischen Informationsumschaltung über IoC abgeschlossen. Du kannst jetzt den Test ausführen und die erwartete Ausgabe sehen.

3. Führe den Test aus:

cd ~/project/SpringGreeting/
mvn test

Der Test sollte erfolgreich sein und du solltest die folgende Ausgabe sehen:

[INFO] -------------------------------------------------------
[INFO] T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.labex.TestGreeting
你好, Labex
Hello, Labex
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.056 s - in com.labex.TestGreeting
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 11.295 s
[INFO] Finished at: 2024-05-10T12:05:55Z
[INFO] ------------------------------------------------------------------------

Zusammenfassung

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