阿里RoceketMQ使用

一、配置文件

#该应用是否启用生产者
rocketmq:
  producer:
    isOnOff: on
    #发送同一类消息的设置为同一个group，保证唯一,默认不需要设置，rocketmq会使用ip@pid(pid代表jvm名字)作为唯一标示
    groupName: ${spring.application.name}
    #mq的nameserver地址
    namesrvAddr: 127.0.0.1:9876
    #消息最大长度 默认1024*4(4M)
    maxMessageSize: 4096
    #发送消息超时时间,默认3000
    sendMsgTimeout: 3000
    #发送消息失败重试次数，默认2
    retryTimesWhenSendFailed: 2

  ###consumer
  ##该应用是否启用消费者
  consumer:
    isOnOff: on
    groupName: ${spring.application.name}
    #mq的nameserver地址
    namesrvAddr: 127.0.0.1:9876
    #该消费者订阅的主题和tags("*"号表示订阅该主题下所有的tags),格式：topic~tag1||tag2||tag3;topic2~*;
    topics: futaotopic~*;
    consumeThreadMin: 20
    consumeThreadMax: 64
    #设置一次消费消息的条数，默认为1条
    consumeMessageBatchMaxSize: 1
#失败重试次数
reConsumerTimes: 3

二、生产者配置

/**
 * @program: wx-job
 * @description: RoceketMQ
 * @author: pengyd
 * @create: 2019-10-10 14:44
 **/
@Configuration
@Slf4j
public class MQProducerConfig {

    @Value("${rocketmq.producer.groupName}")
    private String producerGroupName;

    @Value("${rocketmq.producer.namesrvAddr}")
    private String producerNameSrvAddr;

    @Value("${rocketmq.producer.maxMessageSize}")
    private int maxMessageSize;

    @Value("${rocketmq.producer.sendMsgTimeout}")
    private int sendMsgTimeout;

    @Value("${rocketmq.producer.retryTimesWhenSendFailed}")
    private int retryTimesWhenSendFailed;


    @Bean
    public DefaultMQProducer producer(){
        if (this.producerGroupName.isEmpty()) {
            throw new RuntimeException("producerGroupName  isEmpty ");
        }
        if (this.producerNameSrvAddr.isEmpty()) {
            throw  new RuntimeException("producerNameSrvAddr  isEmpty ");
        }
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer(producerGroupName);
        defaultMQProducer.setNamesrvAddr(producerNameSrvAddr);
        defaultMQProducer.setMaxMessageSize(maxMessageSize);
        defaultMQProducer.setSendMsgTimeout(sendMsgTimeout);
        defaultMQProducer.setVipChannelEnabled(false);
        //消息发送到mq服务器失败重试次数
        defaultMQProducer.setRetryTimesWhenSendFailed(retryTimesWhenSendFailed);
        try {
            defaultMQProducer.start();
            log.info("rocketMq Producer start success; nameServer:{},producerGroupName:{}", producerNameSrvAddr, producerGroupName);
        } catch (Exception e) {
            log.error("rocketMq Producer start fail;{}", e.getMessage(), e);
        }
        return defaultMQProducer;
    }


}

 三、消费者配置

/**
 * @program: wx-job
 * @description: RoceketMQ
 * @author: pengyd
 * @create: 2019-10-10 14:44
 **/
@Configuration
@Slf4j
public class MQConsumerConfig {

    @Value("${rocketmq.consumer.namesrvAddr}")
    private String consumerNamesrvAddr;

    @Value("${rocketmq.consumer.groupName}")
    private String consumerGroupName;

    @Value("${rocketmq.consumer.consumeThreadMin}")
    private int consumeThreadMin;

    @Value("${rocketmq.consumer.consumeThreadMax}")
    private int consumeThreadMax;

    @Value("${rocketmq.consumer.topics}")
    private String topics;

    @Value("${rocketmq.consumer.consumeMessageBatchMaxSize}")
    private int consumeMessageBatchMaxSize;

    private static final String TOPIC = "test";

    private static final String TAG = "test";


    @Bean
    public DefaultMQPushConsumer consumer() {
        if (this.consumerGroupName.isEmpty()) {
            throw new RuntimeException("consumerGroupName  isEmpty ");
        }
        if (this.consumerNamesrvAddr.isEmpty()) {
            throw new RuntimeException("consumerNamesrvAddr  isEmpty ");
        }
        if (this.topics.isEmpty()) {
            throw new RuntimeException("topics  isEmpty ");
        }
        try {
            //DefaultMQPushConsumer DefaultMQPullConsumer
            DefaultMQPushConsumer defaultMQPushConsumer = new DefaultMQPushConsumer(consumerGroupName);
            defaultMQPushConsumer.setNamesrvAddr(consumerNamesrvAddr);
            defaultMQPushConsumer.setConsumeThreadMin(consumeThreadMin);
            defaultMQPushConsumer.setVipChannelEnabled(false);
//            defaultMQPushConsumer.createTopic();
            defaultMQPushConsumer.setConsumeThreadMax(consumeThreadMax);
            //消费模式 集群还是广播，默认为集群(自动负载均衡)
            //广播消费： 消息会发给Consume Group中的每一个消费者进行消费,如果设置为广播消息会导致NOT_ONLINE异常,https://github.com/apache/rocketmq/issues/296
            defaultMQPushConsumer.setMessageModel(MessageModel.CLUSTERING);
            //设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费
            //如果非第一次启动，那么按照上次消费的位置继续消费
            defaultMQPushConsumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
            //设置一次消费消息的条数，默认为1条
            defaultMQPushConsumer.setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
            //订阅topic
            defaultMQPushConsumer.subscribe(TOPIC, TAG);
            //defaultMQPushConsumer.registerMessageListener(mqMessageListenerProcessor)
            defaultMQPushConsumer.registerMessageListener(new MessageListenerConcurrently() {
                @Override
                public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                    MessageExt msg = list.get(0);
                    System.out.println("接收到的消息为：" + new String(msg.getBody(), StandardCharsets.UTF_8));
                    if (msg.getTopic().equals(TOPIC) && msg.getTags().equals(TAG)) {
                        //判断该消息是否重复消费（RocketMQ不保证消息不重复，如果你的业务需要保证严格的不重复消息，需要你自己在业务端去重）
                        //获取该消息重试次数
                        if (msg.getReconsumeTimes() >= 3) {
                            //消息已经重试了3次，如果不需要再次消费，则返回成功
                            //TODO("如果重试了三次还是失败则执行对于失败的业务逻辑")
                            log.error("消息重试消费失败：{}", msg);
                            System.out.println(ConsumeConcurrentlyStatus.CONSUME_SUCCESS);
                        } else {
                            //如果失败重试次数还没到三次则继续重试
                            System.out.println(ConsumeConcurrentlyStatus.RECONSUME_LATER);
                        }
                        //TODO("开始正常的业务逻辑")
                        System.out.println("开始正常的业务逻辑:" + new String(msg.getBody(), StandardCharsets.UTF_8));
                    }
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                }
            });
            defaultMQPushConsumer.start();
            log.info("rocketMq Consumer start success; namesrvAddr:{},groupName:{},topics:{}", consumerNamesrvAddr, consumerGroupName, topics);
            return defaultMQPushConsumer;
        } catch (Exception e) {
            log.error("rocketMq Consumer start fail;{}", e.getMessage(), e);
            return new DefaultMQPushConsumer();
        }
    }

 四、简单使用

/**
 * FileName: MQController
 * Author: pengyd
 * Date: 2019/12/26
 * function:
 */
@RequestMapping("/mq")
@Controller
public class MQController {
    private static Logger logger = LoggerFactory.getLogger(MQController.class);

    @Resource
    private DefaultMQProducer producer;


    @RequestMapping("/mqSend")
    @ResponseBody
    public String mqSend() {
        logger.info("开始发送rocketmq");
        //组装消息内容
        Message message = new Message("test",
                "test",
                (new Date().toString() + "这是测试mq").getBytes());
        try {
            producer.send(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "success";
    }

}

五、over