docker安装rabbitmq并在java项目集成使用

docker安装rabbitmq

首先拉取rabbitmq的镜像

docker pull rabbitmq:management

查看拉取的rabbitmq镜像

docker images

运行rabbitmq，注意端口映射，15672是web管理端端口，5672是后台项目需要配置的端口

docker run -d -p 15672:15672 -p 5672:5672 rabbitmq:management

运行之后docker ps查看运行情况

现在我们去浏览器输入http://linux主机ip:15672查看我们的web管理端能否正常访问

默认账号和密码都是guest

登录进去就是这个样子

至此rabbitmq安装启动就没什么问题了

springboot项目整合rabbitmq

消息发送端配置

首先引入发送端rabbitmq配置

<!--rabbitmq消息队列-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

在yml文件中添加rabbitmq配置

spring:  
  rabbitmq:
    host: 填你自己的linux主机ip
    port: 5672   
    username: guest
    password: guest
    publisher-confirm-type: CORRELATED
    publisher-returns: true
    listener:
      simple:
        prefetch: 1
        concurrency: 3
        acknowledge-mode: manual

添加配置类MQConfig和MQProducerAckConfig

@Configuration
public class MQConfig {
    //mq消息转换器   !!默认是字符转换器
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

@Component
public class MQProducerAckConfig implements RabbitTemplate.ReturnCallback,RabbitTemplate.ConfirmCallback {
    //  我们发送消息使用的是 private RabbitTemplate rabbitTemplate; 对象
    //  如果不做设置的话 当前的rabbitTemplate 与当前的配置类没有任何关系！
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //  设置 表示修饰一个非静态的void方法，在服务器加载Servlet的时候运行。并且只执行一次！
    @PostConstruct
    public void init(){
        rabbitTemplate.setReturnCallback(this);
        rabbitTemplate.setConfirmCallback(this);
    }

    /**
     * 表示消息是否正确发送到了交换机上
     * @param correlationData   消息的载体
     * @param ack   判断是否发送到交换机上
     * @param cause 原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if(ack){
            System.out.println("消息发送成功！");
        }else {
            System.out.println("消息发送失败！"+cause);
        }
    }

    /**
     * 消息如果没有正确发送到队列中，则会走这个方法！如果消息被正常处理，则这个方法不会走！
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("消息主体: " + new String(message.getBody()));
        System.out.println("应答码: " + replyCode);
        System.out.println("描述：" + replyText);
        System.out.println("消息使用的交换器 exchange : " + exchange);
        System.out.println("消息使用的路由键 routing : " + routingKey);
    }
}

创建RabbitService封装发送消息的方法

@Service
public class RabbitService {

    //引入rabbitmq的模板
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息
     * @param exchange  交换机
     * @param routingKey    路由键
     * @param message   消息
     * @return
     */
    public boolean sendMessage(String exchange,String routingKey, Object message){
        //  调用发送数据的方法
        rabbitTemplate.convertAndSend(exchange,routingKey,message);
        return true;
    }

    /**
     * 发送延迟消息的方法
     * @param exchange  交换机
     * @param routingKey    路由键
     * @param message   消息内容
     * @param delayTime 延迟时间
     * @return
     */
    public boolean sendDelayMessage(String exchange,String routingKey, Object message, int delayTime){

        //  在发送消息的时候设置延迟时间
        rabbitTemplate.convertAndSend(exchange, routingKey, message, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //  设置一个延迟时间
                message.getMessageProperties().setDelay(delayTime*1000);
                return message;
            }
        });
        return true;
    }
}

现在消息发送只需要注入RabbitService 对象调用相应方法即可发送

消息接受端配置

引入rabbitmq依赖

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

然后yml如上相同配置即可

测试使用

发送端调用sendMessage，填写（交换机，路由键，消息）

rabbitService.sendMessage(交换机，路由器，消息);

接收端在所需要接收消息的方法上添加如下注解

//参数与发送端相对应
@RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = 路由键, durable = "true"),
            exchange = @Exchange(value = 交换机),
            key = {路由键}))
 public void upperSku(消息类型 消息, Message message, Channel channel) throws IOException {
        if(消息!= null){
            skuService.upperSku(消息);
        }
        /**
         * 第一个参数：表示收到的消息的标号
         * 第二个参数：如果为true表示可以签收多个消息
         */
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    }