Docker安装RabbitMq及java对接

最新推荐文章于 2024-05-15 04:57:00 发布

风学者

最新推荐文章于 2024-05-15 04:57:00 发布

阅读量831

点赞数 1

本文链接：https://blog.csdn.net/qq_34758475/article/details/105240517

版权

java 同时被 3 个专栏收录

9 篇文章 0 订阅

订阅专栏

docker

2 篇文章 0 订阅

订阅专栏

RabbitMq

1 篇文章 0 订阅

订阅专栏

一、安装一个RabbitMq服务节点

1.1 安装环境

系统环境:CentOS Linux release 7.7.1908 (Core)

Docker安装版本:19.03.5

1.2 使用docker下载镜像

# docker pull docker.io/rabbitmq:management

1.3 运行镜像

# docker run -d --restart=always -p 15672:15672 --name shop-rabbitmq -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest -v /var/lib/rabbitmq:/var/lib/rabbitmq rabbitmq:management

参数说明：

-d ##后台运行容器

--name ##指定容器名称

-p ##暴露服务运行的端口(15672:控制台Web端口号)

-e 指定环境变量(RABBITMQ_DEFAULT_USER：默认的用户名；RABBITMQ_DEFAULT_PASS：默认用户名的密码)

rabbitmq配置文件在/etc/rabbitmq/rabbitmq.conf(这是容器内位置)

RabbitMQ默认端口：

4369 -- erlang发现端口

5672 --client端通信端口，应用访问端口

15672 -- 管理界面ui端口，控制台Web端口号

25672 -- server间内部通信端口

二、安装RabbitMq集群

2.1 安装环境

系统环境:CentOS Linux release 7.7.1908 (Core)

Docker安装版本:19.03.5

2.2 使用docker下载镜像源

# docker pull rabbitmq:3.6.15-management

2.3 安装RabbitMQ容器

# docker run -d --hostname rabbit1 --name myrabbit1 -p 15672:15672 -p 5672:5672 -e RABBITMQ_ERLANG_COOKIE='rabbitcookie' rabbitmq:3.6.15-management

# docker run -d --hostname rabbit2 --name myrabbit2 -p 5673:5672 --link myrabbit1:rabbit1 -e RABBITMQ_ERLANG_COOKIE='rabbitcookie' rabbitmq:3.6.15-management

# docker run -d --hostname rabbit3 --name myrabbit3 -p 5674:5672 --link myrabbit1:rabbit1 --link myrabbit2:rabbit2 -e RABBITMQ_ERLANG_COOKIE='rabbitcookie' rabbitmq:3.6.15-management

具体的参数含义，参见上文“启动RabbitMQ”部分。

注意点：

多个容器之间使用“--link”连接，此属性不能少；
Erlang Cookie值必须相同，也就是RABBITMQ_ERLANG_COOKIE参数的值必须相同，原因见下文“配置相同Erlang Cookie”部分；

2.4 加入RabbitMQ节点到集群

2.4.1 设置节点1

[root@docker ~]# docker exec -it myrabbit1 bash
root@rabbit1:/# rabbitmqctl stop_app
Stopping rabbit application on node rabbit@rabbit1
root@rabbit1:/# rabbitmqctl reset   
Resetting node rabbit@rabbit1
root@rabbit1:/# rabbitmqctl start_app
Starting node rabbit@rabbit1
root@rabbit1:/# exit
exit

2.4.2 设置节点2,并加入集群

[root@docker ~]# docker exec -it myrabbit2 bash
root@rabbit2:/# rabbitmqctl stop_app
Stopping rabbit application on node rabbit@rabbit2
root@rabbit2:/# rabbitmqctl reset
Resetting node rabbit@rabbit2
root@rabbit2:/# rabbitmqctl join_cluster --ram rabbit@rabbit1
Clustering node rabbit@rabbit2 with rabbit@rabbit1
root@rabbit2:/# rabbitmqctl start_app
Starting node rabbit@rabbit2
root@rabbit2:/# exit
exit

参数“--ram”表示设置为内存节点，忽略次参数默认为磁盘节点。

2.4.3 设置节点3,加入到集群:

[root@docker ~]# docker exec -it myrabbit3 bash
root@rabbit3:/# rabbitmqctl stop_app
Stopping rabbit application on node rabbit@rabbit3
root@rabbit3:/# rabbitmqctl reset   
Resetting node rabbit@rabbit3
root@rabbit3:/# rabbitmqctl join_cluster --ram rabbit@rabbit1
Clustering node rabbit@rabbit3 with rabbit@rabbit1
root@rabbit3:/# rabbitmqctl start_app
Starting node rabbit@rabbit3
root@rabbit3:/# exit
exit

设置好之后，使用http://本机ip:15672 进行访问了，默认账号密码是guest/guest，效果如下图：

启动了3个节点，1个磁盘节点和2个内存节点。

2.5 配置相同Erlang Cookie

有些特殊的情况，比如已经运行了一段时间的几个单个物理机，我们在之前没有设置过相同的Erlang Cookie值，现在我们要把单个的物理机部署成集群，实现我们需要同步Erlang的Cookie值。

因为RabbitMQ是用Erlang实现的，Erlang Cookie相当于不同节点之间相互通讯的秘钥，Erlang节点通过交换Erlang Cookie获得认证。

要想知道Erlang Cookie位置，首先要取得RabbitMQ启动日志里面的home dir路径，作为根路径。使用：“docker logs 容器名称”查看，如下图：

现将节点1的cookie值复制到本地:

[root@docker ~]# docker cp e03570e49ab75435da40a9b0f3d7a7ab54f3b09e291f79d5859403bf660dab26:/var/lib/rabbitmq/.erlang.cookie  /root/.erlang.cookie

然后将本地的cookie值复制到节点2和3的服务器:

[root@docker ~]# docker cp /root/.erlang.cookie  36213791a6d6961d7ff1013428db7c40270a73feaa6115f4a3229d632e5245db:/var/lib/rabbitmq/.erlang.cookie 
[root@docker ~]# docker cp /root/.erlang.cookie  659b56ce16e72e17b000b1d73670e3e8da0f0372854fbc735bc19b01f4d2907b:/var/lib/rabbitmq/.erlang.cookie

三、使用java连接RabbitMQ(直连型交换机)

3.1 使用docker运行RabbitMQ

[root@docker ~]# docker run -d --restart=always -p 15672:15672 -p 5672:5672 -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest rabbitmq:management

注意点：

-d：表示后台运行容器

--restart=always：表示随着docker重启服务

-p 15672:15672 -p 5672:5672：表示映射端口，以便其他电脑访问

-e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest：表示设置RabbitMQ的用户名以及密码

rabbitmq:management：表示运行的镜像以及版本

3.2 使用springboot创建RabbitMq的生产者

3.2.1 创建rabbitmqprovider(生产者项目),项目目录如下:

3.2.2 配置pom.xml文件以及application.yml文件

pom.xml文件配置

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

application.yml文件配置

server:
  port: 8021
spring:
  #给项目来个名字
  application:
    name: rabbitmq-provider
  #配置rabbitMq 服务器
  rabbitmq:
    host: 192.168.183.146
    port: 5672
    username: guest
    password: guest
    #虚拟host 可以不设置,使用server默认host
    virtual-host: /

注意点:virtual-host:配置的主机名一定要与控制台的Admin配置相同,否则会出现An unexpected connection driver error occured的报错:

3.2.3 创建DirectRabbitConfig类,创建direct exchange(直连型交换机)

package com.qhr.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 9:13
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqprovider
 */
@Configuration
public class DirectRabbitConfig {
    //队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirectQueue() {
        return new Queue("TestDirectQueue",true);  //true 是否持久
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
        return new DirectExchange("TestDirectExchange");
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }

}

3.2.4 创建SendMessageController类,用于消息推送

package com.qhr.rabbitmqprovider.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 9:16
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqprovider
 */
@RestController
public class SendMessageController {

    @Autowired
    RabbitTemplate rabbitTemplate;  //使用RabbitTemplate,这提供了接收/发送等等方法

    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

}

3.2.5 运行rabbitmqprovider项目

把rabbitmqprovider项目运行，调用下接口:

因为我们目前还没弄消费者 rabbitmqconsumer，消息没有被消费的，我们去rabbitMq管理页面看看，是否推送成功：

再看看队列:

如图所示,消息已经推送成功了.

3.3 创建rabbitmqconsumer(消费者)项目

3.3.1 创建rabbitmqconsumer(消费者)项目,项目目录如下:

3.3.2 配置pom.xml文件以及application.yml文件

配置pom.xml文件

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

配置application.yml文件

server:
  port: 8022
spring:
  #给项目来个名字
  application:
    name: rabbitmq-consumer
  #配置rabbitMq 服务器
  rabbitmq:
    host: 192.168.183.146
    port: 5672
    username: guest
    password: guest
    #虚拟host 可以不设置,使用server默认host
    virtual-host: /

注意点:virtual-host:配置的主机名一定要与控制台的Admin配置相同,否则会出现An unexpected connection driver error occured的报错:

3.3.3 创建DirectRabbitConfig类

package com.qhr.rabbitmqconsumer.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 9:13
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Configuration
public class DirectRabbitConfig {

    //队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirectQueue() {
        return new Queue("TestDirectQueue",true);
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
        return new DirectExchange("TestDirectExchange");
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }
}

3.3.4 创建DirectReceiver类,用于接收生产发送的消息

package com.qhr.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 10:52
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
    }

}

3.3.5 运行rabbitmqconsumer项目

并且比较RabbitMq的控制台页面

之前rabbitmqprovider发送的信息,已经被接收,队列里已经没有消息在等待处理了.然后可以再继续调用rabbitmq-provider项目的推送消息接口，可以看到消费者即时消费消息：

四、配置主题交换机

4.1 配置生产者项目：

4.1.1 在rabbitmqprovider项目里面创建TopicRabbitConfig.java：

package com.qhr.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 11:28
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqprovider
 */
public class TopicRabbitConfig {
    //绑定键
    public final static String man = "topic.man";
    public final static String woman = "topic.woman";

    @Bean
    public Queue firstQueue() {
        return new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(TopicRabbitConfig.woman);
    }

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


    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
    //这样只要是消息携带的路由键是topic.man,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }

    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }

}

4.1.2 然后添加多2个接口，用于推送消息到主题交换机：

@GetMapping("/sendTopicMessage1")
public String sendTopicMessage1() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: M A N ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> manMap = new HashMap<>();
    manMap.put("messageId", messageId);
    manMap.put("messageData", messageData);
    manMap.put("createTime", createTime);
    rabbitTemplate.convertAndSend("topicExchange", "topic.man", manMap);
    return "ok";
}

@GetMapping("/sendTopicMessage2")
public String sendTopicMessage2() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: woman is all ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> womanMap = new HashMap<>();
    womanMap.put("messageId", messageId);
    womanMap.put("messageData", messageData);
    womanMap.put("createTime", createTime);
    rabbitTemplate.convertAndSend("topicExchange", "topic.woman", womanMap);
    return "ok";
}

4.1.3 生产者配置完成的项目目录：

配置完成，暂时不要运行项目。

4.2 配置消费者项目：

4.2.1 在rabbitmqconsumer项目上，创建TopicManReceiver.java：

package com.qhr.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 11:30
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "topic.man")
public class TopicManReceiver {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicManReceiver消费者收到消息  : " + testMessage.toString());
    }

}

4.2.2 再创建一个TopicTotalReceiver.java：

package com.qhr.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 11:32
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicTotalReceiver消费者收到消息  : " + testMessage.toString());
    }

}

4.2.3 同样，加主题交换机的相关配置，TopicRabbitConfig.java：

package com.qhr.rabbitmqconsumer.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 11:34
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Configuration
public class TopicRabbitConfig {
    //绑定键
    public final static String man = "topic.man";
    public final static String woman = "topic.woman";

    @Bean
    public Queue firstQueue() {
        return new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(TopicRabbitConfig.woman);
    }

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


    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
    //这样只要是消息携带的路由键是topic.man,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }

    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }

}

4.2.4 消费者配置完成的项目目录

4.3 然后把rabbitmqprovider，rabbitmqconsumer两个项目都跑起来

4.3.1 调用sendTopicMessage1接口：

然后看消费者rabbitmq-consumer的控制台输出情况：

TopicManReceiver监听队列1，绑定键为：topic.man

TopicTotalReceiver监听队列2，绑定键为：topic.#

而当前推送的消息，携带的路由键为：topic.man

4.3.2 调用sendTopicMessage2接口

然后看消费者rabbitmq-consumer的控制台输出情况：

TopicManReceiver监听队列1，绑定键为：topic.man

TopicTotalReceiver监听队列2，绑定键为：topic.#

而当前推送的消息，携带的路由键为：topic.woman

运行结果：

4.4 总结

主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。

简单地介绍下规则：

* (星号) 用来表示一个单词 (必须出现的)

# (井号) 用来表示任意数量（零个或多个）单词

通配的绑定键是跟队列进行绑定的，举个小例子

队列Q1 绑定键为 *.TT.* 队列Q2绑定键为 TT.#

如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；

如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到；

五、Fanout Exchang 扇型交换机

5.1 配置生产者项目

5.1.1 先在rabbitmqprovIder项目上创建FanoutRabbitConfig.java：

package com.qhr.rabbitmqprovider.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 14:32
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqprovider
 */
@Configuration
public class FanoutRabbitConfig {

    /**
     *  创建三个队列 ：fanout.A   fanout.B  fanout.C
     *  将三个队列都绑定在交换机 fanoutExchange 上
     *  因为是扇型交换机, 路由键无需配置,配置也不起作用
     */


    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC() {
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }

}

5.1.2 在SendMessageController类中，添加一个接口用于推送消息

@GetMapping("/sendFanoutMessage")
public String sendFanoutMessage() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: testFanoutMessage ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("fanoutExchange", null, map);
    return "ok";
}

5.1.3 生产者配置完成的项目目录：

5.2 配置消费者项目

5.2.1 在rabbitmqconsumer项目上创建FanoutReceiverA、FanoutReceiverB、FanoutReceiverC三个类

FanoutReceiverA类：

package com.qhr.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 14:45
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverA消费者收到消息  : " +testMessage.toString());
    }
}

FanoutReceiverB类：

package com.qhr.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 14:47
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverB消费者收到消息  : " +testMessage.toString());
    }

}

FanoutReceiverC类：

package com.qhr.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 14:54
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverC消费者收到消息  : " +testMessage.toString());
    }
}

5.2.2 创建FanoutRabbitConfig类

package com.qhr.rabbitmqconsumer.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 14:59
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
public class FanoutRabbitConfig {
    /**
     *  创建三个队列 ：fanout.A   fanout.B  fanout.C
     *  将三个队列都绑定在交换机 fanoutExchange 上
     *  因为是扇型交换机, 路由键无需配置,配置也不起作用
     */


    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC() {
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }

}

5.2.3 由于扇形交换机不需要传递键值，所以没有自动加入队列，我们必须手动在RabbitMQ网页控制台手动添加，如下图所示

注：若无添加队列会报Failed to declare queue(s):[XXX]错误

5.2.4 消费者配置完成项目目录

5.3 然后把rabbitmqprovider，rabbitmqconsumer两个项目都跑起来

调用sendFanoutMessage ：

查看rabbitmqconsumer项目控制台:

六、消息确认回调函数

6.1 在rabbitmq-provider项目的application.yml文件上，加上消息确认的配置项后：

server:
  port: 8021
spring:
  #给项目来个名字
  application:
    name: rabbitmq-provider
  #配置rabbitMq 服务器
  rabbitmq:
    host: 192.168.183.146
    port: 5672
    username: test
    password: qhr7788995201314.
    #虚拟host 可以不设置,使用server默认host
    virtual-host: demo

    #消息确认配置项
    #确认消息已发送到交换机(Exchange)
    publisher-confirms: true
    #确认消息已发送到队列(Queue)
    publisher-returns: true

6.2 配置相关的消息确认回调函数，RabbitConfig.java：

package com.qhr.rabbitmqprovider.config;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : 邱杭锐
 * @Date :  2020/1/9 15:52
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqprovider
 */
@Configuration
public class RabbitConfig {
    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("ConfirmCallback:     "+"相关数据："+correlationData);
                System.out.println("ConfirmCallback:     "+"确认情况："+ack);
                System.out.println("ConfirmCallback:     "+"原因："+cause);
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("ReturnCallback:     "+"消息："+message);
                System.out.println("ReturnCallback:     "+"回应码："+replyCode);
                System.out.println("ReturnCallback:     "+"回应信息："+replyText);
                System.out.println("ReturnCallback:     "+"交换机："+exchange);
                System.out.println("ReturnCallback:     "+"路由键："+routingKey);
            }
        });

        return rabbitTemplate;
    }

}

到这里，生产者推送消息的消息确认调用回调函数已经完毕。

可以看到上面写了两个回调函数，一个叫 ConfirmCallback ，一个叫 RetrunCallback；

那么以上这两种回调函数都是在什么情况会触发呢？

先从总体的情况分析，推送消息存在四种情况：

①消息推送到server，但是在server里找不到交换机

②消息推送到server，找到交换机了，但是没找到队列

③消息推送到sever，交换机和队列啥都没找到

④消息推送成功

那么我先写几个接口来分别测试和认证下以上4种情况，消息确认触发回调函数的情况：

6.2.1 消息推送到server，但是在server里找不到交换机:

在SendMessageController中添加接口:

public String TestMessageAck() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: non-existent-exchange test message ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("non-existent-exchange", "TestDirectRouting", map);
    return "ok";
}

结果:

结论:

这种情况触发的是 ConfirmCallback 回调函数。

6.2.2 消息推送到server，找到交换机了，但是没找到队列:

在DirectRabbitConfig类中添加:

@Bean
DirectExchange lonelyDirectExchange() {
    return new DirectExchange("lonelyDirectExchange");
}

在SendMessageController中添加接口:

@GetMapping("/TestMessageAck2")
public String TestMessageAck2() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: lonelyDirectExchange test message ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("lonelyDirectExchange", "TestDirectRouting", map);
    return "ok";
}

结果:

结论:

    这种情况触发的是 ConfirmCallback和RetrunCallback两个回调函数.

6.2.3 消息推送到sever，交换机和队列啥都没找到

在SendMessageController中添加接口:

@GetMapping("/TestMessageAck3")
public String TestMessageAck3() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: non-existent-exchange test message ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("non-existent-exchange", "non-existent-routing", map);
    return "ok";
}

结果：

结论:

    这种情况与①一样触发的是 ConfirmCallback 回调函数。

6.2.4 消息推送成功

直接调用sendDirectMessage接口

结果:

结论:

     这种情况触发的是 ConfirmCallback 回调函数。

七、消息确认机制

7.1 三种模式

①自动确认， 这也是默认的消息确认情况。AcknowledgeMode.NONE

RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）中立即认为本次投递已经被正确处理，不管消费者端是否成功处理本次投递。

所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息。

一般这种情况我们都是使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数据再做后续处理。

② 不确认，这个不做介绍

③ 手动确认 ，这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。

消费者收到消息后，手动调用basic.ack/basic.nack/basic.reject后，RabbitMQ收到这些消息后，才认为本次投递成功。

basic.ack用于肯定确认

basic.nack用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）

basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息 

消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理，但是basic.nack,basic.reject表示没有被正确处理，但是RabbitMQ中仍然需要删除这条消息。

7.2 在rabbitmqconsumer项目创建MessageListenerConfig.java

package com.qhr.rabbitmqconsumer.config;

import com.qhr.rabbitmqconsumer.receiver.DirectReceiver;
import com.qhr.rabbitmqconsumer.receiver.FanoutReceiverA;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : qhr520
 * @Date :  2020/1/9 16:29
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Configuration
public class MessageListenerConfig {
    @Autowired
    private CachingConnectionFactory connectionFactory;
    @Autowired
    private DirectReceiver directReceiver;//Direct消息接收处理类
    //@Autowired
    //FanoutReceiverA fanoutReceiverA;//Fanout消息接收处理类A
    @Autowired
    DirectRabbitConfig directRabbitConfig;
    //@Autowired
    //FanoutRabbitConfig fanoutRabbitConfig;
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息
        container.setQueues(directRabbitConfig.TestDirectQueue());
        container.setMessageListener(directReceiver);
        //container.addQueues(fanoutRabbitConfig.queueA());
        //container.setMessageListener(fanoutReceiverA);
        return container;
    }

}

7.3 修改DirectReceiver.java类

package com.qhr.rabbitmqconsumer.receiver;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author : 邱杭锐
 * @Date :  2020/1/9 10:52
 * @Version : 01
 * @Description :
 * @ProjectName : rabbitmqconsumer
 */
@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            String[] msgArray = msg.split("'");//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            Map<String, String> msgMap = mapStringToMap(msgArray[1].trim());
            String messageId=msgMap.get("messageId");
            String messageData=msgMap.get("messageData");
            String createTime=msgMap.get("createTime");
            System.out.println("messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
            channel.basicAck(deliveryTag, true);
//       channel.basicReject(deliveryTag, true);//为true会重新放回队列
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }

    //{key=value,key=value,key=value} 格式转换成map
    private Map<String, String> mapStringToMap(String str) {
        str = str.substring(1, str.length() - 1);
        String[] strs = str.split(",");
        Map<String, String> map = new HashMap<String, String>();
        for (String string : strs) {
            String key = string.split("=")[0].trim();
            String value = string.split("=")[1];
            map.put(key, value);
        }
        return map;
    }

}

7.4 然后现在将rabbitmqprovider 、rabbitmqconsumer两个项目跑起来，调用下/sendDirectMessage接口往直连型交换机推送一条消息，看看监听到的消息结果：

风学者

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Docker安装RabbitMq及java对接

一、安装一个RabbitMq服务节点1.1安装环境系统环境:CentOS Linux release 7.7.1908 (Core)Docker安装版本:19.03.51.2使用docker下载镜像# docker pull docker.io/rabbitmq:management1.3运行镜像# docker run -d --restart=alwa...
复制链接

扫一扫