Springboot整合rabbitmq

最新推荐文章于 2024-08-19 18:45:29 发布

this is 小疯子

最新推荐文章于 2024-08-19 18:45:29 发布

阅读量129

点赞数

分类专栏： SpringBoot 文章标签： rabbitmq

本文链接：https://blog.csdn.net/zengqifeng1997/article/details/118420525

版权

SpringBoot 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1、依赖及配置文件

依赖

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

配置文件

# mq配置
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin

#交换机定义(交换机解析：[岸桥].[作业].[交换机].[交换机类型)   直连交换机
rabbit.exchange=A.Work.Exchange.Direct
#交换机定义(交换机解析：[岸桥].[作业].[交换机].[交换机类型].[后台服务广播到WEB])  广播交换机
rabbit.exchange.serviceToWeb=A.Work.Exchange.Fanout.ServiceToWeb

# 队列定义(队列解析：[系统].[发起对象].[数据类型].[数据场地])
#[前端采集程序发给数据服务的作业数据队列名，发送端为采集程序，消费者为数据服务]        作业队列
rabbit.queue.workData=A.Collect.WorkData.NICT
#[前端采集程序发给数据服务的车号预识别数据队列名，发送端为采集程序，消费者为数据服务]   车号预识别队列
rabbit.queue.plateData=A.Collect.PlateData.NICT
#[前端采集程序发给数据服务的设备维护数据队列名，发送端为采集程序，消费者为数据服务]     设备监控队列
rabbit.queue.equipmentData=A.Collect.EquipmentData.NICT

2、声明交换机和队列并进行绑定


import net.pingfang.jiaxing.config.Config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * @title: rabbitMQ配置类 
 * @package com.rabbit.producer.util 
 * @description: TODO
 * @author: lzl
 * @date: 2020年9月2日 下午2:31:42 
 * @version: 1.0  
 */

@Configuration
public class RabbitMQConfig {
	
	//此配置文件请自己书写
	@Resource
	private Config config;
	
    //配置一个Direct类型交换机  直连
	@Bean
	public DirectExchange directExchange() {
		return new DirectExchange(config.getDirectExchange());
	}

	//配置一个Fanout类型交换机  广播
	@Bean
	public FanoutExchange fanoutExchange() {
		return new FanoutExchange(config.getServiceToWebFanoutExchange());
	}
	
	//设置一个队列，作业报文
	@Bean
	public Queue workDataQueue() {
		return new Queue(config.getWorkDataQueue());
	}
	
	//设置一个队列，硬件装备报文。
	@Bean
	public Queue equipmentDataQueue() {
		return new Queue(config.getEquipmentDataQueue());
	}

	//车号预识别队列
	@Bean
	public Queue plateDataQueue() {
		return new Queue(config.getPlateDataQueue());
	}

	//广播测试队列  测试用1
	@Bean
	public Queue fanoutToWebTestQueue1() {
		return new Queue("fanoutToWebTestQueue1");
	}
	//广播测试队列  测试用2
	@Bean
	public Queue fanoutToWebTestQueue2() {
		return new Queue("fanoutToWebTestQueue2");
	}


	/**
	 * 配置一个队列和交换机绑定
	 * directQueue 需要绑定队列的对象，参数名必须和某个@Bean的方法名完全相同，这样就会自动进行注入
	 * directExchange  需要绑定交换机的对象，参数名必须和某个@Bean的方法名完全相同，这样就会自动进行注入
	 */
	@Bean
	public Binding workDataQueueBind(Queue workDataQueue,DirectExchange directExchange) {
		return BindingBuilder.bind(workDataQueue).to(directExchange).with(config.getWorkDataQueue());
	}
	
	@Bean
	public Binding equipmentDataQueueBind(Queue equipmentDataQueue,DirectExchange directExchange) {
		return BindingBuilder.bind(equipmentDataQueue).to(directExchange).with(config.getEquipmentDataQueue());
	}

	@Bean
	public Binding plateDataQueueBind(Queue plateDataQueue,DirectExchange directExchange) {
		return BindingBuilder.bind(plateDataQueue).to(directExchange).with(config.getPlateDataQueue());
	}


	//广播测试1
	@Bean
	public Binding fanoutToWebTestQueue1Bind(Queue fanoutToWebTestQueue1,FanoutExchange fanoutExchange) {
		return BindingBuilder.bind(fanoutToWebTestQueue1).to(fanoutExchange);
	}

	//广播测试2
	@Bean
	public Binding fanoutToWebTestQueue2Bind(Queue fanoutToWebTestQueue2,FanoutExchange fanoutExchange) {
		return BindingBuilder.bind(fanoutToWebTestQueue2).to(fanoutExchange);
	}
}

3、消息生产和消费

生产者服务


import lombok.extern.slf4j.Slf4j;
import net.pingfang.jiaxing.config.Config;
import org.json.JSONObject;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @Author zengqifeng
 * @CreateTime 2021/7/1 17:54
 * @Description
 */
@Slf4j
@Component
public class MqSendService {

    @Resource
    private AmqpTemplate amqpTemplate;

    @Resource
    private Config config;

    /**
     * 此处message必须是json格式的字符串  否则广播失败 {  }
     * 向web前端广播
     * @param msgType
     * @param message
     */
    public void sendFanoutMessageToWeb(String msgType, String message) {
        try {
            JSONObject messageJson = new JSONObject(message);
            messageJson.put("msgType", msgType);
            Message tempMessage = new Message(messageJson.toString().getBytes(),new MessageProperties());
            amqpTemplate.convertAndSend(config.getServiceToWebFanoutExchange(),"fanout", tempMessage);
            log.info("广播成功！");
        } catch (Exception e) {
            log.info("广播失败："+e.getMessage());
        }

    }

    public void sendDirectMessage(String message,String routingKey) {
        //amqpTemplate.convertAndSend(config.getDirectExchangeName(), routingKey, message);
    }

}

消费者服务


import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import net.pingfang.jiaxing.constants.MessageTypeEnum;
import net.pingfang.jiaxing.entity.equipment.EmCrane;
import net.pingfang.jiaxing.entity.licensePlate.LicensePlateJson;
import net.pingfang.jiaxing.entity.work.WorkJson;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 *
 * mq消息消费服务
 *
 * @Author zengqifeng
 * @CreateTime 2021/7/1 15:34
 * @Description
 */
@Slf4j
@Component
public class MqReceiveService {

    @Resource
    private MessageService messageService;


    /**
     * 作业队列消息监听（03作业识别报文  02作业结束报文）
     */
    @RabbitListener(queues = "${rabbit.queue.workData}")
    @RabbitHandler
    private void message03or02Handler(byte[] data) {
        String message = new String(data);
        WorkJson workJson = JSON.parseObject(message, WorkJson.class);
        String message_type = workJson.getMessage_type();

        if (MessageTypeEnum.MESSAGE_TYPE_02.getCode().equals(message_type)) {
            log.info("mq监听到02号报文，报文内容 = {}", message);
            messageService.messageHandler02(workJson);
        }else if (MessageTypeEnum.MESSAGE_TYPE_03.getCode().equals(message_type)) {
            //如果是03号报文 转成对象处理
            log.info("mq监听到03号报文，报文内容 = {}", message);
            messageService.messageHandler03(workJson);
        }

    }

    /**
     * 设备监控报文（06号设备监控报文）
     */
    @RabbitListener(queues = "${rabbit.queue.equipmentData}")
    @RabbitHandler
    private void message06Handler(byte[] data) {
        String message = new String(data);
        log.info("mq监听到06号报文，报文内容 = {}", message);
        EmCrane emCrane = JSON.parseObject(message, EmCrane.class);
        messageService.messageHandler06(emCrane);
    }

    /**
     * 车号预识别消息监听（16号车号预识别报文）
     */
    @RabbitListener(queues = "${rabbit.queue.plateData}")
    @RabbitHandler
    private void message16Handler(byte[] data) {
        String message = new String(data);
        log.info("mq监听到16号报文，报文内容 = {}", message);
        LicensePlateJson licensePlateJson = JSON.parseObject(message, LicensePlateJson.class);
        messageService.messageHandler16(licensePlateJson);
    }


    /**
     * 广播  测试
     */
    @RabbitListener(queues = "fanoutToWebTestQueue1")
    @RabbitHandler
    private void fanoutToWebTestQueue1(byte[] data) {
        String message = new String(data);
        log.info("监听到队列1广播的消息，报文内容 = {}", message);
    }

    /**
     * 广播  测试
     */
    @RabbitListener(queues = "fanoutToWebTestQueue2")
    @RabbitHandler
    private void fanoutToWebTestQueue2(byte[] data) {
        String message = new String(data);
        log.info("监听到队列2广播的消息，报文内容 = {}", message);
    }

}