RocketMQ: inicialice el productor de RocketMQ personalizado Producer cuando se inicie el servicio

necesidad

1. Construir RocketMQel productor.
2. Los productores se construyen cuando se inicia el servicio y se destruyen cuando se cierra el servicio.

plantilla de código

clase abstracta

@Slf4j
public abstract class AbstractMqProducer {
    
    

    /**
     *  原生默认mq生产者
     */
    protected DefaultMQProducer producer;

    /**
     * 启动时，构造
     *
     * @throws MQClientException
     */
    @PostConstruct
    public abstract void start() throws MQClientException;

    /**
     * 关闭时，销毁
     */
    @PreDestroy
    public void shutdown() {
    
    
        log.info("AbstractMqProducer shutdown...");
        producer.shutdown();
    }

}

clase de implementación del productor

@Component
@Configuration
@Slf4j
@RequiredArgsConstructor
public class DemoRocketMqProducer extends AbstractMqProducer {
    
    

    /**
     * 参数配置
     */
	@Value("${rocketmq.producer.group}")
	private String producerGroup;
	@Value("${rocketmq.name-server}")
    private String nameServer;
	@Value("${rocketmq.producer.send-message-timeout}")
    private String sendMessageTimeout;
   	@Value("${rocketmq.producer.compress-message-body-threshold}")
	private String compressMessageBodyThreshold;
   	@Value("${rocketmq.producer.max-message-size}")
	private String maxMessageSize;
   	@Value("${rocketmq.producer.retry-times-when-send-failed}")
	private String retryTimesWhenSendFailed;
   	@Value("${rocketmq.producer.retry-times-when-send-async-failed}")
	private String retryTimesWhenSendAsyncFailed;
   	@Value("${rocketmq.producer.retry-next-server}")
	private String retryNextServer;
    /**
     * 启动producer
     *
     * @throws MQClientException
     */
    @Override
    public void start() throws MQClientException {
    
    
        //判空
        if (ObjectUtil.isNull(producer)) {
    
    
            log.info("init DemoRocketMqProducer begin... ...");
            //构建producer
            producer = new DefaultMQProducer(producerGroup);
            //name server地址
            producer.setNamesrvAddr(nameServer);
            //客户端实例名称
            producer.setInstanceName(UtilAll.getPid() + "#" + System.nanoTime());
            //发送消息超时时间，单位毫秒，默认3000
            producer.setSendMsgTimeout(sendMessageTimeout);
            //body超过多大开始压缩，单位字节，默认4096B
            producer.setCompressMsgBodyOverHowmuch(compressMessageBodyThreshold);
            //客户端限制的消息大小，单位字节，默认4194304
            producer.setMaxMessageSize(maxMessageSize);
            //如果消息发送失败，最大重试次数，默认2
            producer.setRetryTimesWhenSendFailed(retryTimesWhenSendFailed);
            //如果消息异步发送失败，最大重试次数，默认2
            producer.setRetryTimesWhenSendAsyncFailed(retryTimesWhenSendAsyncFailed);
            //如果发送消息返回sendResult，但sendStatus != SEND_OK，是否重试其他broker发送，默认false
            producer.setRetryAnotherBrokerWhenNotStoreOK(retryNextServer);
        }
        //启动producer
        producer.start();
        log.info("DemoRocketMqProducer is starting...");
    }

    /**
     * 发送消息
     *
     * @param topic
     * @param tag
     * @param key
     * @param dto
     * @param <T>
     * @return
     */
    public <T> boolean send(String topic, String tag, String key, T dto, String hashKey) {
    
    
        try {
    
    
            //转换dto为String类型
            String body = JSON.toJSONString(dto);
            //构建message
            Message message = new Message(topic, tag, key, body.getBytes("utf-8"));
            //发送消息
            SendResult sendResult = producer.send(message, new SelectMessageQueueByHash(), hashKey);
            log.info("DemoRocketMqProducer 消息生产结果：{}", sendResult);
            return true;
        } catch (Exception e) {
    
    
            //错误日志
            log.error("DemoRocketMqProducer 消息生产失败，错误信息：{}", e);
            //异常处理
            throw new RuntimeException(e.getMessage());
        }
    }

    /**
     * 关闭producer
     */
    @Override
    @PreDestroy
    public void shutdown() {
    
    
        //关闭producer
        producer.shutdown();
        log.warn("DemoRocketMqProducer shutdown...");
    }
}

notas

@PostConstruct

introducir

1. @PostConstructLas anotaciones se utilizan para decorar un método no estático void().
2. @PostConstructEl método anotado se Servletejecutará cuando se cargue el servicio y solo se ejecutará una vez.
3. @PostConstructLas anotaciones init()se ejecutan antes que los métodos y después de los constructores.
4. Secuencia de inicio de contexto:服务加载Servlet->Constructor(构造方法) -> @Autowired(依赖注入) -> @PostConstruct(注解修饰的方法)->init()方法

Escenas a utilizar

  Si desea completar algunas operaciones de inicialización al generar objetos, estas inicializaciones deben depender de alguna inyección de dependencia en este momento, que no se puede implementar en el constructor. En este punto, se puede usar @PostConstructuna anotación para modificar un método para completar la inicialización, @PostConstructy el método modificado por la anotación se llamará automáticamente después de que se complete la inyección de dependencia.

código fuente

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PostConstruct {
    
    
}

@PreDestroy

introducir

1. @PreDestroyLas anotaciones se utilizan para decorar un método no estático void().
2. @PreDestroyEl método anotado se Servletejecutará cuando se desinstale el servicio y solo se ejecutará una vez.
3. @PreDestroyLa anotación se ejecuta Servletantes de la descarga y destroy()después del método.
4. Orden de parada de contexto:destroy()方法 -> @PreDestroy(注解修饰的方法)-> bean销毁->服务卸载Servlet

código fuente

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PreDestroy {
    
    
}

Detalles del archivo de configuración

# rocketmq消息队列
rocketmq:
  # 指定 nameServer
  name-server: 127.0.0.1:9876;127.0.0.1:9877
  # Producer 生产者
  producer:
  	# 生产组
    group: my-group
    # 发送消息超时时间，单位毫秒，默认3000
    send-message-timeout: 3000
    # body超过多大开始压缩，单位字节，默认4096B
    compress-message-body-threshold: 4096
    # 客户端限制的消息大小，单位字节，默认4194304
    max-message-size: 4194304
    # 如果消息发送失败，最大重试次数，默认2
    retry-times-when-send-failed: 2
    # 如果消息异步发送失败，最大重试次数，默认2
    retry-times-when-send-async-failed: 2
    # 如果发送消息返回sendResult，但sendStatus != SEND_OK，是否重试其他broker发送，默认false
    retry-next-server: false