springboot + RocketMQ

pom

 <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

 

生产者

 

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * 生产者，发送消息给MQ
 */
@RestController
@RequestMapping(value = "sms", produces = MediaType.APPLICATION_JSON_VALUE)
public class ProducerController {
    @Value("${rocketmq.producer.group}")
    private String topic;
    @Value("${rocketmq.consumer.group}")
    private String consumerGroup;

    private  String tags= "sms-tags";
    @Resource
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 异步发送消息
     *
     * @param msg
     */
    @GetMapping("/asyncSend")
    public void snedMsg(String msg) {
        Message message = new Message(topic, tags, msg.getBytes());
        SendCallback callback = new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println("异步消息发送成功");
            }

            @Override
            public void onException(Throwable throwable) {
                System.out.println("异步消息发送失败");
            }
        };
        rocketMQTemplate.asyncSend(topic+":async", message, callback);
        System.out.println("发送了异步消息 " + message);
    }

    /**
     * 同步发送消息
     *
     * @param msg
     */
    @GetMapping("/syncSend")
    public void syncSend(String msg) {
        Message message = new Message(topic, tags, msg.getBytes());
        SendResult result = rocketMQTemplate.syncSend(topic+":sync", message);
        System.out.println("发送了同步消息 " + message);
        System.out.println("发送了同步消息结果 " + result);
    }

    /**
     * 单向发送消息，只管发送，其他不管
     *
     * @param msg
     */
    @GetMapping("/sendOneWay")
    public void sendOneWay(String msg) {
        Message message = new Message(topic, tags, msg.getBytes());
        rocketMQTemplate.sendOneWay(topic+":sendOneWay", message);
        System.out.println("发送了单向消息 " + message);
    }

    /**
     * 发送延迟消息
     *
     * @param msg
     */
    @GetMapping("/sendDelay")
    public void sendDelay(String msg) {
        org.springframework.messaging.Message<String> message = MessageBuilder.withPayload(msg).build();
        //RocketMQ并不支持任意时间的延迟，需要设置几个固定的延时等级，从1s到2h共18个等级
        //messageDelayLevel: 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
        rocketMQTemplate.syncSend(topic+":sendDelay", message, 1 * 1000L, 3);
        System.out.println("发送了延时消息 " + message);
    }
}

 

 

消费者

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消费者，监听消息,消费消息
 * 监听组：监听topic：监听tag（默认监听topic下所有）
 * 监听消费模式：默认负载均衡：CLUSTRRING（每个消息只发给一个消费者）、广播模式：BROADCASTING（发给所有消费者）
 */
@Component
@RocketMQMessageListener(topic = "${rocketmq.producer.group}", consumerGroup = "${rocketmq.consumer.group}")
public class Consumer implements RocketMQListener<String> {


    @Override
    public void onMessage(String s) {
        System.out.println("消费者监听到消息：>>> :" + s);
    }
}

 

yaml

server:
  port: 8090

spring:
  application:
    name: boot-rocketmq

rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: MQ-GROUP
    send-message-timeout: 3000
  consumer:
    group: MQ-GROUP