整合篇3：Spring Boot整合Rabbit MQ

1.pom依赖引入：

<!--RabbitMQ -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.6.1</version>
</dependency>

2.yml配置文件：

#rabbitMq 配置
spring:
 rabbitmq:
  # 主机
  host: 182.92.153.8
  # 端口
  port: 5672
  # 用户名
  username: admin
  # 密码
  password: admin
  # 虚拟host
  virtual-host: /

3.RabbitMQConfig配置类：

package com.zhigong.heavenearth.config;

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * @author 田治功 
 * @description RabbitMQ配置类
 * @date 2021-10-31 1:36
 */
@Configuration
public class RabbitMQConfig {


    @Value("${spring.rabbitmq.host}")
    private String selfHost;

    @Value("${spring.rabbitmq.port}")
    private Integer selfPort;

    @Value("${spring.rabbitmq.username}")
    private String selfUsername;

    @Value("${spring.rabbitmq.password}")
    private String selfPassword;

    @Value("${spring.rabbitmq.virtual-host}")
    private String selfVirtualHost;

    /**
     * 自我设置连接工厂参数并创建连接，随着配置文件的改变，而相应改变
     * 标记为@Primary，将优先被注入
     *
     * @return
     */
    @Bean(name = "selfConnectionFactory")
    @Primary
    public ConnectionFactory selfConnectionFactory() {
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
        cachingConnectionFactory.setHost(selfHost);
        cachingConnectionFactory.setPort(selfPort);
        cachingConnectionFactory.setUsername(selfUsername);
        cachingConnectionFactory.setPassword(selfPassword);
        cachingConnectionFactory.setVirtualHost(selfVirtualHost);
        return cachingConnectionFactory;
    }

    /**
     * 自我配置简单的消息监听连接
     *
     * @param connectionFactory
     * @return
     */
    @Bean(name = "selfRabbitListenerContainerFactory")
    public RabbitListenerContainerFactory selfRabbitListenerContainerFactory(@Qualifier("selfConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory = new SimpleRabbitListenerContainerFactory();
        simpleRabbitListenerContainerFactory.setConnectionFactory(connectionFactory);
        return simpleRabbitListenerContainerFactory;
    }

    /**
     * 自我配置简单的接受发送模板
     *
     * @param connectionFactory
     * @return
     */
    @Bean(name = "selfRabbitTemplate")
    public RabbitTemplate selfRabbitTemplate(@Qualifier("selfConnectionFactory") ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        return rabbitTemplate;
    }


    /**
     * 自我配置便携式AMQP管理操作
     *
     * @param connectionFactory
     * @return
     */
    @Bean(name = "selfRabbitAdmin")
    public RabbitAdmin selfRabbitAdmin(@Qualifier("selfConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }

}

4.生产者：

package com.zhigong.heavenearth.service;


import cn.hutool.json.JSONUtil;
import com.zhigong.heavenearth.common.Result;
import com.zhigong.heavenearth.mapper.SkillStudyPlanMapper;
import com.zhigong.heavenearth.dto.SkillStudyPlanDTO;
import com.zhigong.heavenearth.pojo.SkillStudyPlan;
import com.zhigong.heavenearth.pojo.UserInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * @author 田治功 
 * @description 技术学习规划表Service类
 * @date 2021-12-14
 */

@Slf4j
@Service
public class SkillStudyPlanService {

    @Resource
    private SkillStudyPlanMapper skillStudyPlanMapper;

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private RabbitTemplate rabbitTemplate;

    /**
     * 插入技术学习规划
     *
     * @param skillStudyPlanDTO
     * @return
     */
    public Result insertPlan(SkillStudyPlanDTO skillStudyPlanDTO) {


        return Result.success();
    }

    /**
     * 查询所有技术学习规划
     *
     * @return
     */
    public void selectAll() {
        
        //普通消息方式
        rabbitTemplate.convertAndSend("TEST_MESSAGE", "测试");

        UserInfo userInfo = new UserInfo();
        userInfo.setAccountId("1");
        userInfo.setRemark("test");
        
        //发送对象实体方式
        rabbitTemplate.convertAndSend("TEST_BEAN", userInfo);

        //已JSON序列化方式
        rabbitTemplate.convertAndSend("TEST_BEAN_JSON", JSONUtil.toJsonStr(userInfo));
       
    }
}

5.消费者：

package com.zhigong.heavenearth.listener;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.zhigong.heavenearth.pojo.UserInfo;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/** 
 * @author 田治功 
 *
 * @description MQ消息监听类 
 * @date 2021-12-14 
 */
@Component
public class RabbitMQListener {


    /*
    queues：使用时，要确保该队列必须存在，手动绑定
    queuesToDeclare：使用时无需存在该队列，默认的交换机是用队列名作为路由键
     */
    @RabbitListener(queues = ("TEST_MESSAGE"))
    public void processMessage(Message message) {
        String msg = new String(message.getBody());
        System.out.println(msg);
    }

    @RabbitListener(queuesToDeclare = @Queue("TEST_BEAN"))
    public void processMessageBean(UserInfo userInfo) {
        System.out.println(userInfo);
    }

    @RabbitListener(queuesToDeclare = @Queue("TEST_BEAN_JSON"))
    public void processMessageJson(Message message) {
        System.out.println(message);
        String msg = new String(message.getBody());
        System.out.println(msg);
        UserInfo userInfo = JSONUtil.toBean(msg, UserInfo.class);
        System.out.println(userInfo);
    }
}