In Spring Boot eingebettete ActiveMQ Artemis-Brokerverbindung

php-Editor Banana stellt Ihnen die in Spring Boot eingebettete ActiveMQ Artemis-Proxy-Verbindung vor. ActiveMQ Artemis ist ein leistungsstarker, skalierbarer Nachrichtenbroker, der häufig zum Aufbau zuverlässiger Messagingsysteme verwendet wird. Spring Boot bietet eine einfache und bequeme Möglichkeit, ActiveMQ Artemis zu integrieren. Durch eingebettete Verbindungen können wir ActiveMQ Artemis ohne zusätzliche Konfiguration und Bereitstellung direkt in Spring Boot-Anwendungen verwenden. Diese Verbindungsmethode vereinfacht nicht nur den Entwicklungsprozess, sondern bietet auch eine höhere Leistung und Zuverlässigkeit, wodurch die Nachrichtenübermittlung effizienter und stabiler wird. Unabhängig davon, ob Sie Echtzeitanwendungen, Nachrichtenwarteschlangen oder asynchrone Kommunikation entwickeln, ist die in Spring Boot eingebettete ActiveMQ Artemis-Brokerverbindung eine Option, die es wert ist, erkundet zu werden.

Frageinhalt

Ich habe eine sehr einfache Spring Boot 2.7.6 ActiveMQ Artemis-Anwendung, die auf Nachrichten wartet.

package hello;

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.annotation.bean;
import org.springframework.jms.annotation.jmslistener;
import org.springframework.jms.annotation.enablejms;
import org.springframework.jms.config.defaultjmslistenercontainerfactory;
import org.springframework.boot.autoconfigure.jms.defaultjmslistenercontainerfactoryconfigurer;
import javax.jms.connectionfactory;
import org.springframework.jms.config.jmslistenercontainerfactory;

@springbootapplication
@enablejms
public class application {

    @bean
    public jmslistenercontainerfactory<?> myfactory(connectionfactory connectionfactory,
                            defaultjmslistenercontainerfactoryconfigurer configurer) {
      defaultjmslistenercontainerfactory factory = new defaultjmslistenercontainerfactory();
      // this provides all auto-configured defaults to this factory, including the message converter
      configurer.configure(factory, connectionfactory);
      // you could still override some settings if necessary.
      return factory;
    }

    public static void main(string[] args) {
       springapplication.run(application.class, args);
    }

    @jmslistener(destination = "my-queue-1")
    public void listen(string in) {
       system.out.println(in);
    }
}

Dies ist der Code zum Konfigurieren des eingebetteten Proxys. Ich rate nur, indem ich mehrere Empfänger hinzufüge. In verschiedenen Beiträgen wurde darauf verwiesen addconnectorconfiguration, aber bisher scheint keiner davon zu funktionieren.

package hello;

import org.apache.activemq.artemis.api.core.transportconfiguration;
import org.apache.activemq.artemis.core.remoting.impl.netty.nettyacceptorfactory;
import org.apache.activemq.artemis.core.remoting.impl.netty.nettyconnectorfactory;
import org.springframework.boot.autoconfigure.jms.artemis.artemisconfigurationcustomizer;
import org.springframework.context.annotation.configuration;


@configuration
public class artemisconfig implements artemisconfigurationcustomizer {
    @override
    public void customize(org.apache.activemq.artemis.core.config.configuration configuration) {
      configuration.addacceptorconfiguration("remote", "tcp://0.0.0.0:61616");
    }
}

Durch dieses einfache application.properties:

spring.artemis.mode=embedded
spring.artemis.embedded.server-id=54321
spring.artemis.embedded.queues=my-queue-1
spring.artemis.embedded.enabled=true

Dann habe ich eine andere Spring-Boot-Anwendung, die Nachrichten generiert und an die Proxy-Adresse sendet.

package broker.producer;

import org.apache.activemq.artemis.jms.client.activemqconnectionfactory;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.beans.factory.annotation.value;
import org.springframework.context.annotation.bean;
import org.springframework.jms.core.jmstemplate;
import org.springframework.jms.support.destination.jndidestinationresolver;
import org.springframework.stereotype.service;

@service
public class jmsproducer {

  @value("${spring.jms.template.default-destination}")
  private string defaultdestination;

  logger log = loggerfactory.getlogger(jmsproducer.class);

  @bean
  public activemqconnectionfactory activemqconnectionfactory() {
      activemqconnectionfactory activemqconnectionfactory = new activemqconnectionfactory("tcp://localhost:61616");

      return activemqconnectionfactory;
  }

  @bean
  public jndidestinationresolver jndidestinationresolver() {
    return new jndidestinationresolver();
  }

  @bean
  public jmstemplate jmstemplate() {
    jmstemplate template = new jmstemplate();
    template.setconnectionfactory(activemqconnectionfactory());
    template.setpubsubdomain(false); // false for a queue, true for a topic
    template.setdefaultdestinationname(defaultdestination);

    return template;
  }


  public void send(string message) {
    jmstemplate jmstemplate = jmstemplate();

    log.info("sending message='{}'", message);
    jmstemplate.convertandsend(message);
    log.info("sent message='{}'", message);
  }
}

Dann starte ich jede Anwendung und versuche, die Sendemethode aufzurufen, aber ich kann aufgrund dieses Fehlers keine Verbindung zum Broker von der Produzentenanwendung aus herstellen:

2024-01-16 10:25:00.596 ERROR 30486 --- [nio-8080-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.jms.UncategorizedJmsException: Uncategorized exception occurred during JMS processing; nested exception is javax.jms.JMSException: Failed to create session factory; nested exception is ActiveMQNotConnectedException[errorType=NOT_CONNECTED message=AMQ219007: Cannot connect to server(s). Tried with all available servers.]] with root cause

Die Producer-Anwendung kann problemlos eine Verbindung zur Docker-Instanz von activemq artemis herstellen.

Derzeit laufen beide Anwendungen auf derselben Maschine, aber in der Produktion möchte ich, dass jede Anwendung in einem separaten Pod läuft.

Workaround

Ich habe ein sehr einfaches Projekt als Proof of Concept zusammengestellt, um sicherzustellen, dass das, was Sie tun, möglich ist und bei mir alles gut funktioniert. Der eingebettete Agent wird gestartet und akzeptiert Verbindungen von Remote-Clients auf Port 61616.

Das ist application.java:

package hello;

import javax.jms.connectionfactory;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.boot.autoconfigure.jms.defaultjmslistenercontainerfactoryconfigurer;
import org.springframework.context.annotation.bean;
import org.springframework.jms.annotation.enablejms;
import org.springframework.jms.annotation.jmslistener;
import org.springframework.jms.config.defaultjmslistenercontainerfactory;
import org.springframework.jms.config.jmslistenercontainerfactory;

@springbootapplication
@enablejms
public class application {

    @bean
    public jmslistenercontainerfactory<?> myfactory(connectionfactory connectionfactory,
                                                                    defaultjmslistenercontainerfactoryconfigurer configurer) {
        defaultjmslistenercontainerfactory factory = new defaultjmslistenercontainerfactory();
        // this provides all auto-configured defaults to this factory, including the message converter
        configurer.configure(factory, connectionfactory);
        // you could still override some settings if necessary.
        return factory;
    }

    public static void main(string[] args) {
        springapplication.run(application.class, args);
    }

    @jmslistener(destination = "my-queue-1")
    public void listen(string in) {
        system.out.println(in);
    }
}

Das ist artemisconfig.java:

package hello;

import org.springframework.boot.autoconfigure.jms.artemis.artemisconfigurationcustomizer;
import org.springframework.context.annotation.configuration;


@configuration
public class artemisconfig implements artemisconfigurationcustomizer {
    @override
    public void customize(org.apache.activemq.artemis.core.config.configuration configuration) {
       try {
          configuration.addacceptorconfiguration("remote", "tcp://0.0.0.0:61616");
       } catch (exception e) {
          e.printstacktrace();
       }
    }
}

Das ist meins application.properties:

spring.artemis.mode=embedded
spring.artemis.embedded.server-id=54321
spring.artemis.embedded.queues=my-queue-1
spring.artemis.embedded.enabled=true

Endlich gehört das mir pom.xml:

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelversion>4.0.0</modelversion>
   <parent>
      <groupid>org.springframework.boot</groupid>
      <artifactid>spring-boot-starter-parent</artifactid>
      <version>2.7.6</version>
      <relativepath/>
   </parent>
   <groupid>com.example</groupid>
   <artifactid>spring-boot-customized-activemq-artemis</artifactid>
   <version>0.0.1-snapshot</version>
   <properties>
      <java.version>17</java.version>
      <spring.version>2.7.6</spring.version>
      <activemq.artemis.version>2.19.1</activemq.artemis.version>
   </properties>

   <dependencies>
      <dependency>
         <groupid>org.springframework.boot</groupid>
         <artifactid>spring-boot-starter-artemis</artifactid>
      </dependency>
      <dependency>
         <groupid>org.apache.activemq</groupid>
         <artifactid>artemis-jms-server</artifactid>
     <version>${activemq.artemis.version}</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-maven-plugin</artifactid>
        <version>${spring.version}</version>
         </plugin>
      </plugins>
   </build>
</project>

Ich starte die App so:

mvn spring-boot:run

Ich sehe Protokolleinträge wie diesen:

...
... AMQ221020: Started EPOLL Acceptor at 0.0.0.0:61616 for protocols [CORE]
... AMQ221007: Server is now live
...

Ich kann von einer anderen Anwendung aus eine Nachricht an den Agenten senden und jmslistenerdie Nachricht wird empfangen.

Ich habe das Projekt auf Github hochgeladen.

Das obige ist der detaillierte Inhalt vonIn Spring Boot eingebettete ActiveMQ Artemis-Brokerverbindung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!