Verwendung von HornetQ für die Nachrichtenverarbeitung in der Java-API-Entwicklung

Verwendung von HornetQ für die Nachrichtenverarbeitung in der Java-API-Entwicklung

Mit der rasanten Entwicklung des Internets ist eine große Anzahl von Informationsinteraktionen entstanden, und Nachrichtenwarteschlangen sind zu einem wichtigen Mittel zur Lösung von Problemen wie hoher Parallelität, hoher Verfügbarkeit und Asynchronität geworden Verarbeitung. HornetQ ist eine leistungsstarke und hochverfügbare Open-Source-Messaging-Middleware, die auf dem von JBoss entwickelten JMS-Protokoll basiert. In diesem Artikel wird erläutert, wie HornetQ für die Nachrichtenverarbeitung in der Java-API-Entwicklung verwendet wird.

1. Schnellstart

1. HornetQ herunterladen

Die offizielle Website von HornetQ (http://hornetq.apache.org/downloads.html) bietet Download-Pakete in verschiedenen Formaten. Wählen Sie hier HornetQ-2.4.0. Final -bin.tar.gz.

2. Installieren Sie HornetQ

Nachdem der Download abgeschlossen ist, entpacken Sie HornetQ-2.4.0.Final-bin.tar.gz in einen lokalen Ordner.

3. HornetQ starten

Geben Sie das bin-Verzeichnis von HornetQ ein und führen Sie den folgenden Befehl aus:

　　./run.sh

Die folgenden Protokollinformationen zeigen an, dass der HornetQ-Dienst erfolgreich gestartet wurde:

　　11:14:21,867 INFO [ServerImpl] HornetQ Server wird gestartet
　11:14:21,986 INFO [JournalStorageManager] NIO Journal wird verwendet
　11:14:22,626 INFO [NettyAcceptor] Netty Acceptor Version #{version} gestartet
　11:14:22,697 INFO [HornetQServerImpl] HornetQ Server Version #{version} [${name}] gestartet

4. HornetQ-Konsole bereitstellen

Legen Sie hornetq-console.war von HornetQ in das Webapps-Verzeichnis von Tomcat, starten Sie Tomcat und greifen Sie über http://localhost:8080/hornetq- auf HornetQ zu. Konsole Konsole.

2. Verwendung von HornetQ

1. Nachrichten veröffentlichen und empfangen

Das Veröffentlichungs- und Abonnementmodell von HornetQ basiert auf dem Thema, und mehrere Empfänger können dieses Thema gleichzeitig abonnieren Es können Nachrichten empfangen werden, die von mehreren Herausgebern veröffentlicht wurden.

(1) Nachrichtenherausgeber

Erstellen Sie zunächst einen Herausgeber (Publisher), um die Nachricht zu senden. Der Code lautet wie folgt:

public class Publisher {

    public static void main(String[] args) throws Exception {

        // 初始化连接工厂等配置信息
        ConnectionFactory connectionFactory = HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(NettyConnectorFactory.class.getName()));
        JMSContext jmsContext = connectionFactory.createContext();

        // 发送消息
        JMSProducer producer = jmsContext.createProducer();
        Destination destination = HornetQJMSClient.createTopic("exampleTopic");
        producer.send(destination, "Hello, HornetQ!");

        // 关闭连接
        jmsContext.close();
    }
}

(2) Nachrichtenempfänger

Erstellen Sie dann einen Empfänger (Abonnent), um die Nachricht zu empfangen und zu senden Drucken Sie die Nachricht aus. Der Code lautet wie folgt:

public class Subscriber {

    public static void main(String[] args) throws Exception {

        // 初始化连接工厂等配置信息
        ConnectionFactory connectionFactory = HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(NettyConnectorFactory.class.getName()));
        JMSContext jmsContext = connectionFactory.createContext();

        // 创建消费者
        Destination destination = HornetQJMSClient.createTopic("exampleTopic");
        JMSConsumer consumer = jmsContext.createConsumer(destination);

        // 接收消息并打印
        String message = null;
        do {
            message = consumer.receiveBody(String.class, 1000);
            System.out.println("Received message: " + message);
        } while (message != null);

        // 关闭连接
        jmsContext.close();
    }
}

Nachdem Sie den Herausgeber und den Empfänger ausgeführt haben, können Sie die vom Herausgeber gesendete Nachricht auf der HornetQ-Konsole anzeigen, wie in der folgenden Abbildung dargestellt:

2. Nachrichtenpersistenz

HornetQ unterstützt die Nachrichtenverarbeitung Persistente Speicherung, was bedeutet, dass Nachrichten garantiert nicht verloren gehen, selbst wenn HornetQ ausfällt.

(1) Sender

Wir müssen die Persistenz der Nachricht auf DeliveryMode.PERSISTENT einstellen, wie unten gezeigt:

public class Publisher {

    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(NettyConnectorFactory.class.getName()));
        JMSContext jmsContext = connectionFactory.createContext();

        // 设定持久性
        JMSProducer producer = jmsContext.createProducer();
        destination = HornetQJMSClient.createTopic("exampleTopic");
        producer.setDeliveryMode(DeliveryMode.PERSISTENT);

        // 发送消息
        producer.send(destination, "Hello, HornetQ!");

        jmsContext.close();
    }
}

(2) Receiver

HornetQ hat die Nachricht standardmäßig persistiert, daher besteht keine Notwendigkeit dazu Um eine bestimmte Konfiguration auf der Clientseite durchzuführen, verwenden Sie einfach weiterhin die Subscriber-Klasse aus dem vorherigen Abschnitt.

3. Cluster-Modus

HornetQ bietet hohe Verfügbarkeit und kann im Cluster-Modus ausgeführt werden, um Nachrichtenzuverlässigkeit und hohe Parallelität sicherzustellen. Im Folgenden sind die Schritte zum Implementieren des HornetQ-Clustermodus aufgeführt:

(1) Kopieren Sie das HornetQ-Verzeichnis und erstellen Sie einen neuen Ordner.

Kopieren Sie das HornetQ-Verzeichnis und benennen Sie es in HornetQ2 um. Erstellen Sie dann einen neuen Ordner mit dem Namen „Cluster“ und ändern Sie den Ordner darunter Das HornetQ2-Verzeichnis. Kopieren Sie alle Datenverzeichnisse, Protokollverzeichnisse, TMP-Verzeichnisse und andere Ordner in den Cluster-Ordner.

(2) Ändern Sie die Konfigurationsdatei

Kopieren Sie im Ordner „examples/configs/clustered Configuration“ im HornetQ-Verzeichnis die Datei „hq-configuration.xml“ und die Ordner „server0“ und „server1“ in das HornetQ2-Verzeichnis und ändern Sie sie wie folgt: Hornetq -configuration.xml-Datei im Server0-Ordner:

　 (a) Ändern Sie den Knotennamen in server0

　 (b) Ändern Sie den Server-Benutzernamen und das Server-Passwort in Clusterverbindungen in „guest“

　 (c) Ändern Sie die Connector-Adresse zur lokalen IP-Adresse, z. B. 192.168.1.1

　 (d) Setzen Sie use-ha unter jms-configuration auf true

　 wie unten gezeigt:

<configuration xmlns="urn:hornetq"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="urn:hornetq /schema/hornetq-configuration.xsd">
    <cluster-password>guest</cluster-password>
    <paging-directory>${data.dir:../data}/paging</paging-directory>
    <bindings-directory>${data.dir:../data}/bindings</bindings-directory>
    <journal-directory>${data.dir:../data}/journal</journal-directory>
    <large-messages-directory>${data.dir:../data}/large-messages</large-messages-directory>
    <journal-type>NIO</journal-type>
    <journal-datasync>true</journal-datasync>
    <journal-min-files>2</journal-min-files>
    <journal-pool-files>10</journal-pool-files>
    <journal-file-size>10240</journal-file-size>
    <journal-buffer-timeout>28000</journal-buffer-timeout>
    <journal-max-io>1</journal-max-io>
    <disk-scan-period>5000</disk-scan-period>
    <max-disk-usage>90</max-disk-usage>
    <critical-analyzer>true</critical-analyzer>
    <critical-analyzer-timeout>120000</critical-analyzer-timeout>
    <critical-analyzer-check-period>60000</critical-analyzer-check-period>
    <critical-analyzer-policy>HALT</critical-analyzer-policy>
    <page-sync-timeout>1628000</page-sync-timeout>
    <global-max-size>100Mb</global-max-size>
    <connectors>
        <connector name="netty">
            <factory-class>org.hornetq.core.remoting.impl.netty.NettyConnectorFactory</factory-class>
            <param key="host" value="192.168.1.1"/>
            <param key="port" value="5445"/>
        </connector>
    </connectors>
    <acceptors>
        <acceptor name="netty">
            <factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory</factory-class>
            <param key="host" value="192.168.1.1"/>
            <param key="port" value="5545"/>
        </acceptor>
    </acceptors>
    <cluster-connections>
        <cluster-connection name="my-cluster">
            <address>jms</address>
            <connector-ref>netty</connector-ref>
            <retry-interval>500</retry-interval>
            <use-duplicate-detection>true</use-duplicate-detection>
            <forward-when-no-consumers>true</forward-when-no-consumers>
            <max-hops>1</max-hops>
            <discovery-group-ref discovery-group-name="my-discovery-group"/>
            <static-connectors>
                <connector-ref>netty</connector-ref>
            </static-connectors>
        </cluster-connection>
    </cluster-connections>
    <ha-policy>
        <replication>
            <slave>
                <allow-failback>true</allow-failback>
                <failback-delay>5000</failback-delay>
                <max-saved-replicated-journals-size>1000000</max-saved-replicated-journals-size>
                <restart-backup>true</restart-backup>
            </slave>
        </replication>
    </ha-policy>
</configuration>

Ändern Sie dann den Ordner server1 auf die gleiche Weise wie hornetq-configuration. xml-Datei, in der server0 in server1 geändert wird.

(3) Starten Sie HornetQ

Führen Sie den Befehl run.sh im bin-Verzeichnis von HornetQ und HornetQ2 aus, um den HornetQ-Prozess zu starten. Zu diesem Zeitpunkt bilden die beiden HornetQ-Knoten einen Cluster, der über die HornetQ-Konsole angezeigt werden kann.

3. Zusammenfassung

Durch die Einführung dieses Artikels haben wir etwas über die grundlegende Verwendung von HornetQ und die Konfigurationsmethode des Cluster-Modus gelernt. Mit HornetQ kann das Problem der Nachrichteninteraktion leicht gelöst und die Robustheit und Parallelität des Systems verbessert werden. Gleichzeitig unterstützt HornetQ auch mehrere Messaging-Modi, umfangreiche Mechanismen zur Nachrichtenpersistenz, Erweiterungs-Plug-Ins und andere Funktionen, die entsprechend den tatsächlichen Anforderungen ausgewählt und konfiguriert werden können.

Das obige ist der detaillierte Inhalt vonVerwendung von HornetQ für die Nachrichtenverarbeitung in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!