Stringboot配置rabbitmq完整代码

jar

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

yml 配置文件

spring:
  rabbitmq:
  	# rabbitmq 地址
    host: 192.168.10.1
    # 端口
    port: 30002
    username: rabbitmq
    password: rabbitmq

生产者

配置类

import lombok.extern.slf4j.Slf4j;
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;

/**
 * @Description: RebbitMQ配置
 * @Title: MQConfig
 * @date 2019/9/25 9:37
 */
@Slf4j
@Configuration
public class RabbitMQConfig {

    /**
     * 交换机 - 广播模式  用于数据中心数据变更推送给业务系统使用.
     */
    public static final String EXCHANGE_FANOUT_PUSH = "exchange_fanout_push_data";
    /**
     * 更新插入队列.
     */
    public final static String UPDATE = "queryUpdate";
    /**
     * 删除队列.
     */
    public final static String DELETE = "queryDelete";
    /**
     * 推送业务系统数据更新. 
     */
    public final static String PUSH_MESSAGE = "pushMessage";

    /**
     * 推送业务系统数据更新. 
     */
    public final static String PUSH_MESSAGE_SCC = "pushMessageScc";

    /**
     * 推送业务系统数据更新. 
     */
    public final static String PUSH_DATA_OPEN = "pushDataOpen";

    /**
     Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
     Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
     Queue:消息的载体,每个消息都会被投到一个或多个队列。
     Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
     Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
     vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
     Producer:消息生产者,就是投递消息的程序.
     Consumer:消息消费者,就是接受消息的程序.
     Channel:消息通道,在客户端的每个连接里,可建立多个channel.
     */

    /**
     * 声明 广播模式交换机
     * @return
     */
    @Bean
    public FanoutExchange EXCHANGE_FANOUT_PUSH() {
        log.info("广播模式交换机实例创建成功");
        return new FanoutExchange(EXCHANGE_FANOUT_PUSH);
    }

    /**
     *  声明 队列
     * @return
     */
    @Bean(UPDATE)
    public Queue queryUpdate() {
        return new Queue(UPDATE,true);
    }
    @Bean(DELETE)
    public Queue queryDelete() {
        return new Queue(DELETE,true);
    }
    @Bean(PUSH_MESSAGE)
    public Queue PUSH_MESSAGE() {
        log.info("交换机-路由创建成功");
        return new Queue(PUSH_MESSAGE,true);
    }
    @Bean(PUSH_DATA_OPEN)
    public Queue PUSH_DATA_OPEN() {
        log.info("交换机-路由 PUSH_DATA_OPEN 创建成功");
        return new Queue(PUSH_DATA_OPEN,true);
    }

    @Bean(PUSH_MESSAGE_SCC)
    public Queue PUSH_MESSAGE_SCC() {
        log.info("交换机-路由PUSH_MESSAGE_SCC创建成功");
        return new Queue(PUSH_MESSAGE_SCC,true);
    }

    /**
     * 绑定exchange & queue & routekey.
     * 调用rabbitMQ方式 直连就可以
     * @return
     */
    @Bean
    public Binding pushMessageZSGToExchange() {
        log.info("【【【绑定队列一到交换机成功 PUSH_MESSAGE】】】");
        return BindingBuilder.bind(PUSH_MESSAGE()).to(EXCHANGE_FANOUT_PUSH());
    }
    @Bean
    public Binding pushMessageSCCToExchange() {
        log.info("【【【绑定队列一到交换机成功 PUSH_MESSAGE_SCC】】】");
        return BindingBuilder.bind(PUSH_MESSAGE_SCC()).to(EXCHANGE_FANOUT_PUSH());
    }
    @Bean
    public Binding pushDataOpenToExchange() {
        log.info("【【【绑定队列一到交换机成功 PUSH_DATA_OPEN】】】");
        return BindingBuilder.bind(PUSH_DATA_OPEN()).to(EXCHANGE_FANOUT_PUSH());
    }
}

推送类

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.scheduling.annotation.Async;
import org.zsdy.RabbitMQ.RabbitMQConfig;
import org.zsdy.data.api.model.PushMessageDTO;

import javax.annotation.Resource;



@Slf4j
public class PushSenderController {

    
    @Resource
    AmqpTemplate rabbitmqTemplate;
    
    /**
    * PushMessageDTO:自定义一个消息类就可以，或者字符串
    */
    @Async
    public void pushMessage(PushMessageDTO pushMessage){
        if(pushMessage!=null){
            String message = JSONObject.toJSONString(pushMessage);
            log.info("【开始推送业务数据】 ={}",message);
            rabbitmqTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_FANOUT_PUSH,"",message);
        }
    }
}

消费类

@Slf4j
@Component
public class Receiver {
	@RabbitListener(queues = RabbitMQConfig.PUSH_MESSAGE )
    public void pushMessage(String messageJsonStr) {
    	log.info("接收变动事件【{}】", messageJsonStr);
        }
    }
}