RocketMQ的生产者和消费者

RocketMQ的生产者和消费者

本文简单介绍RocketMQ的生产者和消费者在项目中的基本用法。

一、pom引入依赖

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

二、基本用法

1. RocketMQ的生产消息

//  1.创建消息生产者，并设置生产组名
        DefaultMQProducer producer = new DefaultMQProducer("product-group");
        // 2.为生产者设置NameServer的地址
        producer.setNamesrvAddr("192.168.100.84:9876");
        // 3.启动生产者
        producer.start();
        // 4.构建消息对象，主要是设置消息的主题 标签 内容
        Message message = new Message("topic", "tag", ("i am message".getBytes()));
        // 5.发送消息，超时时间
        SendResult result = producer.send(message, 10000);
        System.out.println(result);
        // 6.关闭生产者
        producer.shutdown();

2. RocketMQ的消费消息基本用法

//  1.创建消息消费者，并设置生产组名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer-group");
        // 2.为消费者设置NameServer的地址
        consumer.setNamesrvAddr("192.168.100.84:9876");

        // 3.指定消费者订阅的主题和标签
        consumer.subscribe("topic","*");
        // 4.设置一个回调函数，并在函数中编写接收到的消息之后的处理办法
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                // 消费逻辑
                System.out.println("message=====> " + list);
                // 返回消费成功状态
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        // 3.启动生产者
        consumer.start();
        System.out.println("启动消费者成功了");
        // 6.关闭生产者
//        consumer.shutdown();

3. RocketMQ的同步发送

public void testSynSend(){
        // topic:tag  messageBody timeout
       SendResult result = rocketMQTemplate.syncSend("testSynSend-topic:tag","这是一条同步消息",100000);
    }

4. RocketMQ的异步发送

public void testAsynSend() throws InterruptedException{
        // topic:tag  messageBody  callback
        rocketMQTemplate.asyncSend("testSynSend-topic:tag", "这是一条同步消息", new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                System.out.println(sendResult);
            }

            @Override
            public void onException(Throwable throwable) {
                System.out.println(throwable);
            }
        });
        // 因为主线程跑完了就接收不到回调了，所以这些这些休眠，确保能接受到回调信息
        Thread.sleep(30000000);
    }

5. RocketMQ的单向发送

public void testOneWay() throws Exception{
        // topic:tag  messageBody
        rocketMQTemplate.sendOneWay("testSynSend-topic:tag","这是一条同步消息");
    }

6. RocketMQ的顺序发送消息

/**
     * 顺序发送消息
     */
    public void testOrderly() throws Exception{
        // 第三个参数为排序的依据，只要haskey一直，就会在统一消息队列上进行发送
        rocketMQTemplate.sendOneWayOrderly("testSynSend-topic:tag","这是一条同步消息","aa");

        SendResult result = rocketMQTemplate.syncSendOrderly("testSynSend-topic:tag1","这是一条同步消息","bb");
    }

7. RocketMQ的事务消息
   

@Service
public class RocketMQTransactionService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 创建半事务
     * @param orderPO
     */
    public void createOrderBefore(OrderPO orderPO){
        String txId = UUID.randomUUID().toString();
        rocketMQTemplate.sendMessageInTransaction(
                "tx_order_group",
                "order_topic",
                MessageBuilder.withPayload(orderPO).setHeader("txId",txId).build(),
                orderPO);
    }

}

@Service
@RocketMQTransactionListener(txProducerGroup = "tx_order_group")
public class OrderServiceListener implements RocketMQLocalTransactionListener {

    @Autowired
    private OrderService orderService;
    @Autowired
    private TxLogService txLogService;

    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        try {
            OrderPO order = (OrderPO) o;
            String txId = message.getHeaders().get("txId").toString();
            // 执行本地事务
            orderService.save(order,txId);
            return RocketMQLocalTransactionState.COMMIT;
        }catch (Exception e){
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }

    /**
     * 事务回查
     * @param message
     * @return
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        // 查询本地事务是否保存成功
        String txId = message.getHeaders().get("txId").toString();
        TxLogPO txLogPO = txLogService.getTxLogByTxId(txId);
        if (txLogPO !=null){
            return RocketMQLocalTransactionState.COMMIT;
        } else {
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private TxLogService txLogService;

    @Transactional
    public void save(OrderPO order,String txId){
        // 保存订单
        orderMapper.insert(order);

        //保存事务记录
        TxLogPO txLogPO = new TxLogPO();
        txLogPO.setId(UUID.randomUUID().toString());
        txLogPO.setCreateDate(new Date());
        txLogPO.setTxId(txId);
        txLogPO.setOrderNum(order.getOrderNum());
        txLogService.save(txLogPO);
    }

}