SpringBoot+ActiveMQ-发布订阅模式（消费端）

最新推荐文章于 2024-04-11 15:32:03 发布
最新推荐文章于 2024-04-11 15:32:03 发布
阅读量664 收藏 5
点赞数
分类专栏： SpringBoot+Demo 文章标签： java-activemq activemq spring boot activemq发布订阅 activemq topic Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myyhtw/article/details/128769671
版权

ActiveMQ消息中间件的发布订阅模式 主题 topic

topic生产端案例(配合topic消费端测试)：SpringBoot+ActiveMQ Topic 生产端

ActiveMQ版本：apache-activemq-5.16.5

案例源码:SpringBoot+ActiveMQ-发布订阅Demo

SpringBoot集成ActiveMQ Topic消费端的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 http://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.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>boot.example.topic.customer</groupId>
    <artifactId>boot-example-topic-demo-customer-2.0.5</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot-example-topic-demo-customer-2.0.5</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>boot.example.demo.entity</groupId>
            <artifactId>boot-example-demo-entity-2.0.5</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- activeMQ依赖组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- spring.activemq.pool.enabled=true -->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
            <version>5.16.5</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 打包成一个可执行jar -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

server.port=8044


spring.activemq.broker-url=tcp://127.0.0.1:61616
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.in-memory=false
spring.activemq.packages.trust-all=true
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=6
spring.activemq.pool.idle-timeout=30000
spring.activemq.pool.expire-timeout=0
spring.jms.pub-sub-domain=true

topic消费端启动类AppTopicCustomer

package boot.example.topic.customer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jms.annotation.EnableJms;

/**
 *
 * 蚂蚁舞
 */
@SpringBootApplication
@EnableJms
public class AppTopicCustomer {
    public static void main( String[] args ) {
        SpringApplication.run(AppTopicCustomer.class, args);
        System.out.println( "Hello World!" );
    }
}

ActiveMqConfig

package boot.example.topic.customer.config;

import javax.jms.ConnectionFactory;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;

@EnableJms
@Configuration
public class ActiveMqConfig {

    // topic模式的ListenerContainer
    @Bean
    public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ConnectionFactory activeMQConnectionFactory) {
        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
        // pubSubDomain 表示开启发布订阅域
        bean.setPubSubDomain(true);
        bean.setConnectionFactory(activeMQConnectionFactory);
        return bean;
    }

}

ActiveMQConstant

package boot.example.topic.customer.config;

import boot.example.queue.entity.BootProvider;

import java.util.LinkedList;
import java.util.List;


/**
 *  消息消费者（订阅方式）消费该消息
 *  消费生产者将发布到topic中，同时有多个消息消费者（订阅）消费该消息
 *  这种方式和点对点方式不同，发布到topic的消息会被所有订阅者消费
 *
 *  当生产者发布消息，不管是否有消费者，都不会保存消息
 *  蚂蚁舞
 */
public class ActiveMQConstant {

    //  默认Topic
    public static final String defaultTopic = "myw_topic";

    //  指定Topic
    public static final String stringTopic = "stringTopic";

    //  指定list<String>
    public static final String stringListTopic = "stringListTopic";

    //  指定Object
    public static final String objTopic = "objTopic";

    //  指定List<Object>
    public static final String objListTopic = "objListTopic";


    //  简单存储默认topic消费端收到的消息
    public static List<String> defaultList = new LinkedList<>();

    public static List<String> stringTopicList = new LinkedList<>();

    public static List<List<String>> stringListTopicList = new LinkedList<>();

    public static List<BootProvider> objTopicList = new LinkedList<>();

    public static List<List<BootProvider>> objListTopicList = new LinkedList<>();





}

DefaultTopicConsumerService

package boot.example.topic.customer.service;


import boot.example.topic.customer.config.ActiveMQConstant;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;

import javax.jms.JMSException;
import javax.jms.TextMessage;

/**
 *  蚂蚁舞
 */
@Service
public class DefaultTopicConsumerService {

    @JmsListener(destination = ActiveMQConstant.defaultTopic)
    public void message(TextMessage textMessage) throws JMSException {
        if(textMessage == null || textMessage.getText() == null){
            return;
        }
        System.out.println("默认消费者:"+textMessage.getText());
        ActiveMQConstant.defaultList.add(textMessage.getText());
    }


}

ATopicConsumerService

package boot.example.topic.customer.service;

import boot.example.queue.entity.BootProvider;
import boot.example.topic.customer.config.ActiveMQConstant;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;

import javax.jms.ObjectMessage;
import java.util.List;


/**
 * 蚂蚁舞
 */
@Service
public class ATopicConsumerService {

    @JmsListener(destination = ActiveMQConstant.stringTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveStringTopic(String msg) {
        System.out.println("A-TopicConsumer接收到消息...." + msg);
        ActiveMQConstant.stringTopicList.add(msg);
    }

    @JmsListener(destination = ActiveMQConstant.stringListTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveStringListTopic(List<String> list) {
        System.out.println("A-TopicConsumer接收到集合主题消息...." + list);
        ActiveMQConstant.stringListTopicList.add(list);
    }

    @JmsListener(destination = ActiveMQConstant.objTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveObjTopic(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("A-TopicConsumer接收到对象主题消息...." + objectMessage.getObject());
        BootProvider bootProvider = (BootProvider) objectMessage.getObject();
        ActiveMQConstant.objTopicList.add(bootProvider);
    }

    @SuppressWarnings("unchecked")
    @JmsListener(destination = ActiveMQConstant.objListTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveObjListTopic(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("A-TopicConsumer接收到的对象集合主题消息..." + objectMessage.getObject());
        List<BootProvider> list = (List<BootProvider>) objectMessage.getObject();
        ActiveMQConstant.objListTopicList.add(list);
    }

}

BTopicConsumerService

package boot.example.topic.customer.service;

import boot.example.queue.entity.BootProvider;
import boot.example.topic.customer.config.ActiveMQConstant;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;

import javax.jms.ObjectMessage;
import java.util.List;


@Service
public class BTopicConsumerService {

    @JmsListener(destination = ActiveMQConstant.stringTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveStringTopic(String msg) {
        System.out.println("B-TopicConsumer接收到消息...." + msg);
        ActiveMQConstant.stringTopicList.add(msg);
    }

    @JmsListener(destination = ActiveMQConstant.stringListTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveStringListTopic(List<String> list) {
        System.out.println("B-TopicConsumer接收到集合主题消息...." + list);
        ActiveMQConstant.stringListTopicList.add(list);
    }

    @JmsListener(destination = ActiveMQConstant.objTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveObjTopic(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("B-TopicConsumer接收到对象主题消息...." + objectMessage.getObject());
        BootProvider bootProvider = (BootProvider) objectMessage.getObject();
        ActiveMQConstant.objTopicList.add(bootProvider);
    }

    @SuppressWarnings("unchecked")
    @JmsListener(destination = ActiveMQConstant.objListTopic, containerFactory = "jmsListenerContainerTopic")
    public void receiveObjListTopic(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("B-TopicConsumer接收到的对象集合主题消息..." + objectMessage.getObject());
        List<BootProvider> list = (List<BootProvider>) objectMessage.getObject();
        ActiveMQConstant.objListTopicList.add(list);
    }

}

BootDefaultTopicCustomerController

package boot.example.topic.customer.controller;


import boot.example.topic.customer.config.ActiveMQConstant;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * 蚂蚁舞
 */
@RestController
@RequestMapping(value="/customer")
public class BootDefaultTopicCustomerController {

    @GetMapping(value="/myw_topic")
    public List<String> myw_topic() {
        return ActiveMQConstant.defaultList;
    }


}

BootTopicCustomerController

package boot.example.topic.customer.controller;


import boot.example.queue.entity.BootProvider;
import boot.example.topic.customer.config.ActiveMQConstant;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * 蚂蚁舞
 */
@RestController
@RequestMapping(value="/customer")
public class BootTopicCustomerController {
    
    @GetMapping(value="/stringTopicList")
    public List<String> stringTopicList() {
        return ActiveMQConstant.stringTopicList;
    }

    @GetMapping(value="/stringListTopicList")
    public List<List<String>> stringListTopicList() {
        return ActiveMQConstant.stringListTopicList;
    }

    @GetMapping(value="/objTopicList")
    public List<BootProvider> objTopicList() {
        return ActiveMQConstant.objTopicList;
    }

    @GetMapping(value="/objListTopicList")
    public List<List<BootProvider>> objListTopicList() {
        return ActiveMQConstant.objListTopicList;
    }



}

SwaggerConfig UI测试

package boot.example.topic.customer.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 *  蚂蚁舞
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
                .paths(Predicates.not(PathSelectors.regex("/error.*")))
                .paths(PathSelectors.regex("/.*"))
                .build().apiInfo(apiInfo());
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("demo")
                .description("demo接口")
                .version("0.01")
                .build();
    }

    /**
     * http://localhost:XXXX/doc.html  地址和端口根据实际项目查看
     */


}

测试使用的对象BootProvider

package boot.example.queue.entity;
 
import java.io.Serializable;
import java.util.Date;
 
/**
 *  用在activeMq消息，必须保证package一致，不然序列化后反序列化要出错
 *  蚂蚁舞
 */
public class BootProvider implements Serializable {
 
    private int id;
 
    private String name;
 
    private Date date = new Date();
 
    public BootProvider() {
    }
 
    public BootProvider(int id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Date getDate() {
        return date;
    }
 
    public void setDate(Date date) {
        this.date = date;
    }
 
    @Override
    public String toString() {
        return "BootProvider{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", date=" + date +
                '}';
    }
}

代码结构

├─boot-example-demo-entity-2.0.5
│  │  pom.xml
│  │  
│  ├─src
│  │  └─main
│  │      └─java
│  │          └─boot
│  │              └─example
│  │                  └─queue
│  │                      └─entity
│  │                              BootProvider.java                                  
├─boot-example-topic-demo-customer-2.0.5
│  │  pom.xml
│  ├─src
│  │  ├─main
│  │  │  ├─java
│  │  │  │  └─boot
│  │  │  │      └─example
│  │  │  │          └─topic
│  │  │  │              └─customer
│  │  │  │                  │  AppTopicCustomer.java
│  │  │  │                  │  
│  │  │  │                  ├─config
│  │  │  │                  │      ActiveMqConfig.java
│  │  │  │                  │      ActiveMQConstant.java
│  │  │  │                  │      SwaggerConfig.java
│  │  │  │                  │      
│  │  │  │                  ├─controller
│  │  │  │                  │      BootDefaultTopicCustomerController.java
│  │  │  │                  │      BootTopicCustomerController.java
│  │  │  │                  │      
│  │  │  │                  └─service
│  │  │  │                          ATopicConsumerService.java
│  │  │  │                          BTopicConsumerService.java
│  │  │  │                          DefaultTopicConsumerService.java
│  │  │  │                          
│  │  │  └─resources
│  │  │          application.properties
│  │  │          
│  │  └─test
│  │      └─java
│  │          └─boot
│  │              └─example
│  │                  └─topic
│  │                      └─customer
│  │                              AppTest.java

启动后访问（ActiveMQ必须提前启动）

http://localhost:8044/doc.html

与topic发送端联合交互测试topic订阅 (不是持久化)

发送端发送

订阅端查看临时数据(不是持久化的，因此接收数据需要先启动的)

再看控制台a和b都收到了数据

持久化订阅

持久化订阅在springboot activemq里需要配置

我这里新建了一个发布端 两个订阅端 topic_client1 topic_client2 topic = myw_topic_p

    // topic模式的ListenerContainer
    @Bean
    public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ConnectionFactory activeMQConnectionFactory) {
        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
        // pubSubDomain 表示开启发布订阅域
        bean.setPubSubDomain(true);
        // 开启持久订阅。即下线后重新上线依然能继续接收Topic消息
        bean.setSubscriptionDurable(true);
        // 持久订阅的Client端标识(多个端持久订阅需要保证唯一性，否则可能会出现问题)
        bean.setClientId("topic_client1");
        bean.setConnectionFactory(activeMQConnectionFactory);

        return bean;
    }
    // topic模式的ListenerContainer
    @Bean
    public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ConnectionFactory activeMQConnectionFactory) {
        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
        // pubSubDomain 表示开启发布订阅域
        bean.setPubSubDomain(true);
        // 开启持久订阅。即下线后重新上线依然能继续接收Topic消息
        bean.setSubscriptionDurable(true);
        // 持久订阅的Client端标识(多个端持久订阅需要保证唯一性，否则可能会出现问题)
        bean.setClientId("topic_client2");
        bean.setConnectionFactory(activeMQConnectionFactory);
        return bean;
    }
    public static final String defaultTopic = "myw_topic_p";

代码目录

把三个应用分别启动我用了swagger UI因此可以在浏览器里访问到

发送端
http://localhost:8045/doc.html

订阅端1
http://localhost:8046/doc.html

订阅端2
http://localhost:8047/doc.html

在这里发送端发送消息，订阅端1和订阅端2都可以收到消息的

发送消息三条

蚂蚁舞1
蚂蚁舞2
蚂蚁舞3

订阅端1和订阅端2的控制台输出，表示都收到了三条消息，那么发布订阅模式是可以的

持久化测试一，订阅端1关停，此时订阅端2能正常收到发送端的消息

蚂蚁舞4
蚂蚁舞5
蚂蚁舞6

订阅端2的控制台

在ActiveMQ上

此时启动订阅端1，测试持久化,可以看到之前发送的(蚂蚁舞4 蚂蚁舞5 蚂蚁舞6都收到了)

持久化测试二，订阅端1和订阅端2都关停，先发送三条消息到ActiveMQ上,然后把ActiveMQ给关停后启动(重启，验证ActiveMQ有没有保存消息)

蚂蚁舞7
蚂蚁舞8
蚂蚁舞9

关停重启

启动订阅端1和启动订阅端2

订阅端1

订阅端2

可以看到订阅端1和订阅端2都收到了蚂蚁舞7 8 9三条消息

蚂蚁舞
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ActiveMQ Artemis-发布/订阅模式
不务正业的猿
10-13 684
ActiveMQ Artemis-发布/订阅模式的Java案例。
java之activeMQ
weixin_43679491的博客
10-23 2325
文章目录一、activeMQ默认已经安装完毕队列点对点模式服务提供方服务消消费方(一)服务消消费方(二)主题服务提供方服务消费方(一)服务消费方(二)手动签收事物总结springboot 整合activemq点对点坐标yml创建一个Queue（队列）服务提供方启动类服务消费方发布订阅 一、activeMQ 默认已经安装完毕 启动，进入activemq目录下的bin目录，启动，./activemq start 关闭防火前或者打开端口 activemq监听的是61616,我们访要查看消息队列的状态时访问816
java实现连接ActiveMQ-Topic发布订阅模式
qq_40712111的博客
11-30 777
上一篇博文介绍了JMS是什么，JMS架构，基于JMS规范使用ActiveMQ实现的系统之间的通信，P2P模式下生产者与消费者的实现见上一篇博文JMS规范 java实现连接消息中间件ActiveMQ-P2P模式 本文实现发布订阅模式（PUB/SUB）即JMS的Destination为Topic的发布者与订阅者 PUB/SUB-发布者【与P2P模式的区别就在于Destination由Queue变为了Topic】 package activemq_topic; import org.apache.activ
学习ActiveMQ(三)：发布/订阅模式(topic)演示
qq_38097573的博客
10-29 695
1.在这个项目中新增两个java类，主题生产者和主题消费者： 　　2.和点对点的代码差别并不大，所以将消费者和生产者的分别代码拷入新增的java类中，再修改就好了。 appProducerTopic代码：黑色字体是做出了修改，由创建队列改为了创建主题。 package com.liu.jms; import org.apache.activemq.ActiveMQConnectionFactory; import javax.jms.*; public class appProduc
Springboot集成activemq（发布订阅模式topic）
SmileTimLi的博客
05-15 2816
Springboot集成activemq（发布订阅模式topic） 一、docker安装activemq 1、查询镜像 docker search activemq 2、拉取镜像 docker pull webcenter/activemq 3、查询是否拉取成功 docker images 4、运行activemq镜像 docker run -d --name my...
SpringBoot整合ActiveMQ+websocket.docx
08-05
Queue模式下，消息被一个消费者接收并删除，而Topic模式下，消息可以被多个订阅者接收。在这个例子中，我们使用了Queue，通过设置`spring.jms.pub-sub-domain: false`来指定。 4. **队列生成者（Producer）**：在`...
详解Springboot整合ActiveMQ（Queue和Topic两种模式）
08-19
Topic是一种发布/订阅模式，一个消息可以被多个消费者接收。创建Topic生产者和消费者类似，但需使用`pubSubDomain`属性： 生产者（发布消息）： ```java @Autowired private JmsTemplate jmsTemplate; public void...
Springboot整合ActiveMQ（Queue和Topic两种模式）
12-21
Topic模式基于发布/订阅模式，一个消息可以被多个消费者接收，适合一对多的消息广播场景，如新闻推送。 1. **topic生产者** 生产者发布消息到特定的主题，与队列模式类似，使用`JmsTemplate`。 2. **topic消费者*...
springboot-activemq
03-15
4. **消息模型**: ActiveMQ支持点对点（Queue）和发布/订阅（Topic）两种消息模型。Queue适用于一对一通信，而Topic适用于一对多广播式通信。 5. **消息持久化**: ActiveMQ可以配置消息持久化，即使在服务器重启后...
activemq生产消费的Demo
04-02
java整合activemq的demo，生产者和消费者两个方法。结合自带的工具http://192.168.1.106:8161。来查看消息传递情况
Spring Boot 2.X - Spring Boot整合JMS之ActiveMQ（发布订阅模式）
XUDC的程序人生
04-16 3070
文章目录Spring Boot 2.X - Spring Boot整合JMS之ActiveMQ1.修改配置2.订阅者3.修改接口4.启动测试5.问题？6.点对点和发布订阅共存解决6.1 新建配置类6.2 修改配置6.3 修改订阅者6.4 启动测试7.发现另一种方法7.1 修改配置7.2 注释掉配置类7.3 修改订阅者7.4 修改点对点调用方法7.5 启动测试 Spring Boot 2.X - S...
[分布式][高并发]消息队列的使用场景、概念、常见问题及解决方案
疯一样的女子
02-21 1440
MQ（消息队列）在软件架构中是经常被使用的，特别是在分布式系统中也是使用频率很高的组件。   以下从消息队列的使用场景、概念、常见问题及解决方案来详细讲解。     一、消息队列使用场景   1.1 常见的使用场景   系统解耦 在分布式环境下，系统间的相互依赖，最终会会导致整个依赖关系混乱，特别在微服务环境下，会出现相互依赖，甚至是循环依赖的情况，对后期系统的拆分和优化都带来...
ActiveMQ发布订阅模式
知性人 -- 的博客
07-01 326
Topic主题发布和订阅消息 根据前文介绍的消息传递都是点对点的消息，即一个生产者发送的一条消息只能被一个消费者消费，然后就移除了。 而topic模式一条消息可以被多个消费者订阅，关系如下: 定义生产者 public class TopicPublisherDemo { //创建 activemq 的连接账号 private static String userName = ...
ActiveMQ入门案例（queue模式和topic模式）
最新发布
weixin_39941298的博客
04-11 1501
有些业务不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。。在任何重要的系统中，都会有需要不同的处理时间的元素。消息队列通过一个缓冲层来帮助任务最高效率的执行，该缓冲有助于控制和优化数据流经过系统的速度。以调节系统响应时间。。降低工程间的强依赖程度，针对异构系统进行适配。在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。
ActiveMQ持久订阅设置
十步杀一人-千里不留行
06-29 2875
在JMS中,Topic实现publish和subscribe语义。一条消息被publish时,它将发到所有感兴趣的订阅者,所以零到多个subscriber将接收到消息的一个拷贝。但是在消息代理接收到消息时,只有激活订阅的subscriber能够获得消息的一个拷贝。     JMS Queue执行load balancer语义。一条消息仅能被一个consumer收到。如果在message发送的时候
ActiveMQ发布/订阅模式实例
LI_AINY的博客
04-15 623
1. 发送端 package com.ainy.demo; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.TextMessage; import javax.j...
spring boot整合activeMQ，实现queue和topic两者消息模式
eumenides_的博客
10-26 7981
如何下载安装MQ我就不说了，百度一大把，老规矩先上一下项目目录结构： 先看一下配置文件，主要是中间件的配置： ps：1.主要注意的是activeMQ默认提供ptp模式，若要使用topic模式需要假如最后一个配置为truespring.activemq.broker-url=tcp://localhost:61616 spring.activemq.in-memory=true spring.
springboot +activemq实现
07-08
Spring Boot与ActiveMQ的集成可以实现消息队列的功能。以下是实现步骤： 1. 配置ActiveMQ依赖：在项目的pom.xml文件中添加ActiveMQ的依赖。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> ``` 2. 配置ActiveMQ连接信息：在项目的application.properties（或application.yml）文件中配置ActiveMQ的连接信息。 ```properties spring.activemq.broker-url=tcp://localhost:61616 spring.activemq.user=admin spring.activemq.password=admin ``` 3. 创建消息发送者：编写一个消息发送者类，使用JmsTemplate发送消息到ActiveMQ队列。 ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jms.core.JmsTemplate; import org.springframework.stereotype.Component; @Component public class MessageSender { @Autowired private JmsTemplate jmsTemplate; public void sendMessage(String message) { jmsTemplate.convertAndSend("myQueue", message); } } ``` 4. 创建消息接收者：编写一个消息接收者类，使用@JmsListener注解监听ActiveMQ队列，并处理接收到的消息。 ```java import org.springframework.jms.annotation.JmsListener; import org.springframework.stereotype.Component; @Component public class MessageReceiver { @JmsListener(destination = "myQueue") public void receiveMessage(String message) { System.out.println("Received message: " + message); // 处理接收到的消息 } } ``` 5. 发送和接收消息：在需要发送消息的地方，通过调用消息发送者的sendMessage方法发送消息；在消息接收者类中，使用@JmsListener注解监听到消息后进行处理。 通过以上步骤，你就可以在Spring Boot应用中使用ActiveMQ实现消息队列的功能了。记得在启动应用之前，确保你已经启动了ActiveMQ服务器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值