springboot整合第三方技术：消息

最新推荐文章于 2024-04-11 16:15:24 发布

Ferry.

最新推荐文章于 2024-04-11 16:15:24 发布

阅读量861

点赞数 23

文章标签： spring boot 后端 java

本文链接：https://blog.csdn.net/weixin_44522680/article/details/136366464

版权

文章目录

ActiveMQ
- springboot整合ActiveMQ
RabbitMQ
- springboot整合RabbitMQ(direct模式)
- springboot整合RabbitMQ(topic模式)
RocketMQ
Kafka

消息发送方：生产者。
消息接收方：消费者。

企业级应用中广泛使用的三种异步消息传递技术：JMS、AMQP、MQTT。

JMS（Java Message Service）：一个规范，等同于JDBC规范，提供了与消息服务相关的API接口。
JMS消息模型：
peer-2-peer：点对点模型，消息发送到一个队列中，队列保存消息。队列的消息只能被一个消费者消费，或超时。
publish-subscribe：发布订阅模型，消息可以被多个消费者消费，生产者和消费者完全独立，不需要感知对方的存在。
JMS消息种类：TextMessage、MapMessage、BytesMessage、StreamMessage、ObjectMessage、Message （只有消息头和属性）。
JMS实现：ActiveMQ、Redis、HornetMQ、RabbitMQ、RocketMQ（没有完全遵守JMS规范）。

AMQP（advanced message queuing protocol）：一种协议（高级消息队列协议，也是消息代理规范），规范了网络交换的数据格式，兼容JMS。
优点：具有跨平台性，服务器供应商，生产者，消费者可以使用不同的语言来实现。
AMQP消息模型：direct exchange、fanout exchange、topic exchange、headers exchange、system exchange。
AMQP消息种类：byte[]。
AMQP实现：RabbitMQ、StormMQ、RocketMQ。

Kafka，一种高吞吐量的分布式发布订阅消息系统，提供实时消息功能。

ActiveMQ

启动服务,win64文件夹下的activemq.bat

activemq.bat

访问服务器

http://127.0.0.1:8161/

服务端口：61616，管理后台端口：8161
用户名&密码：admin

springboot整合ActiveMQ

1.导入SpringBoot整合ActiveMQ的坐标

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

2.配置ActiveMQ(采用默认配置）

spring:
  activemq:
    broker-url: tcp://localhost:61616

  jms:
    template:
      default-destination: itheima

3.生产与消费信息（使用默认消息存储队列）

@Service
public class MessageServiceActivemqImpl implements MessageService {

    @Autowired
    private JmsMessagingTemplate messagingTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列,id:"+ id);
        messagingTemplate.convertAndSend("order.queue.id",id);//指定消息存储队列
    }

    @Override
    public String doMessage() {
        String id = messagingTemplate.receiveAndConvert("order.queue.id",String.class);
        System.out.println("已完成短信发送业务，id："+ id);
        return id;
    }
}

4.使用消息监听器对消息队列监听

@Component
public class MessageListener {

    @JmsListener(destination = "order.queue.id")
    @SendTo("order.other.queue.id")//流程性业务消息消费完转入下一个消息队列
    public String receive(String id){
        System.out.println("已完成短信发送业务，id："+ id);
        return "new" +id;
    }
}

RabbitMQ

启动服务
rabbitmq-service.bat start
关闭服务
rabbitmq-service.bat stop
查看服务状态
rabbitmqctl status
服务管理可视化（插件形式）
查看已安装的插件列表
rabbitmq-plugins.bat list
开启服务管理插件
rabbitmq-plugins.bat enable rabbitmq_management
访问服务器
http://localhost:15672                      用户名&密码：guest

springboot整合RabbitMQ(direct模式)

类似于JMS消息模型中的点对点
1.导入坐标

<!--Rabbitmq-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2.配置Rabbitmq

spring:
  rabbitmq:
    host: localhost
    port: 5672

3.定义消息队列

@Configuration
public class RabbitConfigDirect {

    @Bean
    public Queue directQueue(){
        return new Queue("direct_queue",true,true,true);
    }

    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }

    @Bean
    public Binding bindingDirect(){
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("direct");
    }
}

4.生产消息(direct)

@Service
public class MessageServiceRabbitmqDirectImpl implements MessageService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列(Rabbitmq direct),id:"+ id);
        amqpTemplate.convertAndSend("directExchange","direct",id);
    }

    @Override
    public String doMessage() {
        return null;
    }
}

5.使用消息监听器对小心队列监听(direct)

@Component
public class MessageListener {

    @RabbitListener(queues = "direct_queue")
    public void receive(String id){
        System.out.println("已完成短信发送业务(Rabbitmq direct)，id："+ id);
    }
}

springboot整合RabbitMQ(topic模式)

类似于JMS消息模型中的发布订阅
1.定义消息队列(topic)

@Configuration
public class RabbitConfigTopic {

    @Bean
    public Queue topicQueue(){
        return new Queue("topic_queue",true,true,true);
    }

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    @Bean
    public Binding bindingTopic(){
        return BindingBuilder.bind(topicQueue()).to(topicExchange()).with("topic.*.*");
    }
}

2.绑定键匹配规则
在这里插入图片描述

3.生产与消费消息（topic）

@Service
public class MessageServiceRabbitmqTopicImpl implements MessageService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入处理队列(Rabbitmq topic),id:"+ id);
        amqpTemplate.convertAndSend("topicExchange","topic.order.id",id);
    }

    @Override
    public String doMessage() {
        return null;
    }
}

4.使用消息监听器对消息队列监听（topic）

@Component
public class MessageListener {

    @RabbitListener(queues = "topic_queue")
    public void receive(String id){
        System.out.println("已完成短信发送业务(Rabbitmq topic)，id："+ id);
    }
}

RocketMQ

默认服务端口：9876。
环境变量配置：ROCKETMQ_HOME、PATH、NAMESRV_ADDR （建议）： 127.0.0.1:9876。
启动命名服务器：mqnamesrv
启动broker：mqbroker

服务器功能测试：生产者
tools org.apache.rocketmq.example.quickstart.Producer
服务器功能测试：消费者
tools org.apache.rocketmq.example.quickstart.Consumer

1.导入springboot整合RocketMQ坐标

<!--Rocketmq-->
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.2.1</version>
</dependency>

2.配置RocketMQ(采用默认配置)

rocketmq:
  name-server: localhost:9876
  producer:
    group: group_rocketmq

3.生产消息

@Service
public class MessageServiceRocketmqImpl implements MessageService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Override
    public void sendMessage(String id) {
        rocketMQTemplate.convertAndSend("order_sm_id",id);
        System.out.println("使用Rabbitmq将待发送短信的订单纳入处理队列，id："+id);
    }
}

4.生产异步消息

@Service
public class MessageServiceRocketmqImpl implements MessageService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    @Override
    public void sendMessage(String id) {
        SendCallback callback = new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println("消息发送成功");
            }
            @Override
            public void onException(Throwable throwable) {
                System.out.println("消息发送失败！！！！！！！！！！！");
            }
        };
        System.out.println("使用Rabbitmq将待发送短信的订单纳入处理队列，id："+id);
        rocketMQTemplate.asyncSend("order_sm_id",id,callback);
    }

    @Override
    public String doMessage() {
        return null;
    }
}

5.使用消息监听器对消息队列监听

@Component
@RocketMQMessageListener(topic="order_sm_id",consumerGroup = "group_rocketmq")
class RocketmqMessageListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String id) {
        System.out.println("已完成短信发送业务，id："+id);
    }
}

Kafka

启动zookeeper，默认端口：2181   zookeeper-server-start.bat ..\..\config\zookeeper.properties

启动kafka，默认端口：9092  kafka-server-start.bat ..\..\config\server.properties

创建topic:kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic itheima

查看topic:kafka-topics.bat --zookeeper 127.0.0.1:2181 --list

删除topic:kafka-topics.bat --delete --zookeeper localhost:2181 --topic itheima

生产者功能测试:kafka-console-producer.bat --broker-list localhost:9092 --topic itheima

消费者功能测试:kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic itheima --from-beginning

springboot整合Kafka导入坐标

<dependency>    
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

配置Kafka(采用默认配置）

spring:  
  kafka:
    bootstrap-servers: localhost:9092    
    consumer:      
      group-id: order

生产消息

@Service
public class MessageServiceKafkaImpl implements MessageService {    
    @Autowired    
    private KafkaTemplate<String ,String> kafkaTemplate;   
    
    @Override    
    public void sendMessage(String id) {        
        System.out.println("使用Kafka将待发送短信的订单纳入处理队列，id："+id);        
        kafkaTemplate.send("kafka_topic",id);    
    }
}

使用消息监听器对消息队列进行监听

@Component
public class KafkaMessageListener{    
    @KafkaListener(topics = {"kafka_topic"})    
    public void onMessage(ConsumerRecord<?, ?> record) {        
        System.out.println("已完成短信发送业务，id："+record.value());    
    }
}

Ferry.

关注

23
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
springboot整合第三方技术：消息

消息发送方：生产者。消息接收方：消费者。企业级应用中广泛使用的三种传递技术：JMS、AMQP、MQTT。JMS（Java Message Service）：一个规范，等同于JDBC规范，。JMS消息模型：peer-2-peer：点对点模型，消息发送到一个队列中，队列保存消息。队列的消息只能被一个消费者消费，或超时。：发布订阅模型，消息可以被多个消费者消费，生产者和消费者完全独立，不需要感知对方的存在。JMS消息种类：TextMessage、MapMessage、
复制链接

扫一扫