2.RabbitMQ的SimpleMessageListenerContainer使用

RabbitMQ的SimpleMessageListenerContainer使用

主要内容

1. SimpleMessageListenerContainer和ChannelAwareMessageListener的使用
2. 并发配置，设置最小和最大消费者数量
3. 设置消息确认机制(NONE、MANUAL、AUTO三种)

正文

maven依赖

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>

    <slf4j.version>1.7.13</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
    <mybatis-spring-boot.version>1.1.1</mybatis-spring-boot.version>
    <mybatis-pagehelper.version>4.1.2</mybatis-pagehelper.version>
    <druid.version>1.0.16</druid.version>
    <mysql.version>5.1.37</mysql.version>
    <okhttp.version>3.1.2</okhttp.version>
    <retrofit.version>2.1.0</retrofit.version>
    <guava.version>19.0</guava.version>
    <java-mail.version>1.6.0</java-mail.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--log start-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>
    <!--log end-->
    <!--spring-mybatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis-spring-boot.version}</version>
    </dependency>
    <!--for page-->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>${mybatis-pagehelper.version}</version>
    </dependency>
    <!--druid-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
    </dependency>
    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
    <!--rabbitmq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
        <version>${parent.version}</version>
    </dependency>
    <!-- okhttp -->
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>${okhttp.version}</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>retrofit</artifactId>
        <version>${retrofit.version}</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>converter-jackson</artifactId>
        <version>${retrofit.version}</version>
    </dependency>
    <!--guava-->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>${guava.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <version>2.1.5.RELEASE</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Spring配置文件application.properties

server.port=9092
server.context-path=/study_mq
#logging
logging.file.path=D:\\logs\\SpringBoot-RabbitMQ
logging.file.name=springboot-rabbitmq-01

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
multipart.max-request-size=20Mb
multipart.max-file-size=10Mb

logging.level.org.springframework = INFO
logging.level.com.fasterxml.jackson = INFO
logging.level.com.debug.steadyjack = DEBUG

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
spring.datasource.initialize=false
spring.jmx.enabled=false

#数据库
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/study_rabbitmq?characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456

#mybatis
mybatis.config-location=classpath:mybatis-config.xml
mybatis.checkConfigLocation = true
mybatis.mapper-locations=classpath:mappers/*.xml

#rabbitmq
spring.rabbitmq.host=39.105.91.158
spring.rabbitmq.port=5672
spring.rabbitmq.username=jack
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/test

# 配置并发是多消费者
# 这个是什么意思目前也没了解清楚?
spring.rabbitmq.listener.concurrency=10
# 最多有多少个消费者
spring.rabbitmq.listener.max-concurrency=20
# 每个消费者预处理多少个数据
spring.rabbitmq.listener.prefetch=50

# 自定义属性变量
mq.env=local
basic.info.mq.exchange.name=${mq.env}:basic:info:mq:exchange
basic.info.mq.routing.key.name=${mq.env}:basic:info:mq:routing:key
basic.info.mq.queue.name=${mq.env}:basic:info:mq:queue

配置类-对RabbitMQ进行设置以及创建和绑定Queue、Exchange

初始化了SimpleMessageListenerContainer对象，并对队列和队列的监听器进行设置

@Configuration
public class RabbitmqConfig {
    private static final Logger log= LoggerFactory.getLogger(RabbitmqConfig.class);
    @Autowired
    private Environment env;
    @Autowired
    private CachingConnectionFactory connectionFactory;
    @Autowired
    private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 单一消费者
     * @return
     */
    @Bean(name = "singleListenerContainer")
    public SimpleRabbitListenerContainerFactory listenerContainer(){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        factory.setConcurrentConsumers(1);
        factory.setMaxConcurrentConsumers(1);
        factory.setPrefetchCount(1);
        factory.setTxSize(1);
        return factory;
    }

    /**
     * 多个消费者
     * @return
     */
    @Bean(name = "multiListenerContainer")
    public SimpleRabbitListenerContainerFactory multiListenerContainer(){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factoryConfigurer.configure(factory,connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);
        factory.setConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.concurrency",int.class));
        factory.setMaxConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.max-concurrency",int.class));
        factory.setPrefetchCount(env.getProperty("spring.rabbitmq.listener.prefetch",int.class));
        return factory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(){
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMandatory(true);
        // 设置消息发送到rabbitMQ,rabbitMQ接收到这个消息后的回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                log.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
            }
        });
        // 设置消息发送到rabbitMQ,rabbitMQ找不到对应的队列发送这个消息时 将消息返回给生产者的回调
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
            }
        });
        return rabbitTemplate;
    }

    // 创建队列
    @Bean
    public DirectExchange basicExchange() {
        return new DirectExchange(env.getProperty("basic.info.mq.exchange.name"), true, false);
    }
    // 创建交换机
    @Bean
    public Queue basicQueue() {
        return new Queue(env.getProperty("basic.info.mq.queue.name"), true, false, false);
    }
    // 将队列和交换机进行绑定
    @Bean
    public Binding basicBind() {
        return BindingBuilder.bind(basicQueue()).to(basicExchange()).with(env.getProperty("basic.info.mq.routing.key.name"));
    }
    //TODO：并发配置-消息确认机制-listener
    @Bean
    public Queue simpleQueue() {
        return new Queue(env.getProperty("simple.mq.queue.name"));
    }
    @Bean
    public TopicExchange simpleExchange() {
        return new TopicExchange(env.getProperty("simple.mq.exchange.name"));
    }
    @Bean
    public Binding simpleBinding() {
        return BindingBuilder.bind(simpleQueue()).to(simpleExchange()).with(env.getProperty("simple.mq.routing.key.name"));
    }

    @Autowired
    private SimpleListener simpleListener;
    
    // 初始化SimpleMessageListenerContainer，并对队列进行一些设置
    @Bean
    public SimpleMessageListenerContainer simpleContainer(@Qualifier("simpleQueue") Queue simpleQueue) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.setMessageConverter(new Jackson2JsonMessageConverter());
        Integer min = Integer.valueOf(env.getProperty("spring.rabbitmq.listener.concurrency"));
        Integer max = Integer.valueOf(env.getProperty("spring.rabbitmq.listener.max-concurrency"));
        Integer prefetch = Integer.valueOf(env.getProperty("spring.rabbitmq.listener.prefetch"));
        //TODO：并发配置(消费者最小和最大个数)
        container.setConcurrentConsumers(min);
        container.setMaxConcurrentConsumers(max);
        container.setPrefetchCount(prefetch);
        //TODO：消息确认-确认机制种类(消息确认机制有:NONE、MANUAL、AUTO三种，一般比较推荐MANUAL手动确认方式.)
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        // 将要设置的队列和container进行关联
        container.setQueues(simpleQueue);
        // 将队列的Listener和container进行关联
        container.setMessageListener(simpleListener);
        return container;
    }
}    

发送的数据对象

public class User implements Serializable{
    private Integer id;
    private String userName;
    private String name;

    public User(Integer id, String userName, String name) {
        this.id = id;
        this.userName = userName;
        this.name = name;
    }

    public User() {
    }
    
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

发送消息

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jack.dto.User;
import com.jack.response.BaseResponse;
import com.jack.response.StatusCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author cwl
 * @description: TODO
 * @date 2020/9/1 7:13
 */
@RestController
public class AcknowledgeController {
    private static final Logger log= LoggerFactory.getLogger(AcknowledgeController.class);
    private static final String Prefix="ack";

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private Environment env;

    @RequestMapping(value = Prefix+"/user/info",method = RequestMethod.GET)
    public BaseResponse ackUser() {
        try {
            User user = new User(1, "张三", "张");
            rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
            rabbitTemplate.setExchange(env.getProperty("simple.mq.exchange.name"));
            rabbitTemplate.setRoutingKey(env.getProperty("simple.mq.routing.key.name"));
            Message msg = MessageBuilder.withBody(objectMapper.writeValueAsBytes(user)).build();
            rabbitTemplate.convertAndSend(msg);
            log.info("发送消息成功...");
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return new BaseResponse(StatusCode.Success);
    }
}

监听和消费

• 通过实现ChannelAwareMessageListener接口，来对SimpleMessageListenerContainer设置的队列进行监听消费

import com.fasterxml.jackson.databind.ObjectMapper;
import com.jack.dto.User;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @author cwl
 * @description: TODO
 * @date 2020/8/31 21:36
 */
@Component
public class SimpleListener implements ChannelAwareMessageListener {
    private static final Logger log= LoggerFactory.getLogger(SimpleListener.class);

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            byte[] body = message.getBody();
            User user = objectMapper.readValue(body, User.class);
            log.info("简单消息监听确认机制监听到消息： {} ",user);
            // 消费消息时，出现异常，没有返回ack给rabbitmq，则这个消息的状态会变为unacked
            // 等该程序与rabbitmq都断开连接时 这个unacked的消息会重入队列
            // int a = 1 / 0;
            channel.basicAck(deliveryTag, false);
        } catch (IOException e) {
            log.error("简单消息监听确认机制发生异常：",e.fillInStackTrace());
            channel.basicReject(deliveryTag,false);
        }
    }
}