【RocketMq】商用RocketMq和开源RocketMq的兼容问题解决方案

引言

在阿里云的官方网站提供了RocketMq的商用版本，但是个人在项目应用上发现和SpirngBoot以及Spring Cloud（Alibaba）等开源的RocketMQ依赖虽然可以正常兼容，但是依然出现了注解失效、启动报错，商用和开源版本的不兼容导致部分代码要重复编写的蛋疼问题。

这样的兼容问题不是简单加个SDK依赖，切换到商用配置就可以直接使用的（因为个人起初真就是这么想），为了避免后面再遇到这种奇葩的开发测试用开源RocketMq，生产环境需要使用商用集群的RocketMq的混合配置的业务场景，个人花了小半天时间熟读阿里云的接入文档，加上各种尝试和测试，总结出一套可以快速使用的兼容模板方案。

如果不了解阿里云商用RocketMq，可以看最后一个大节的【阿里云商用RocketMq介绍】介绍。个人的兼容方案灵感来自于官方提供的这个DEMO项目：springboot/java-springboot-demo。

注意本方案是基于SpringBoot2.X和 Spring cloud Alibaba 的两个项目环境构建项目基础，在SpringBoot上只做了生产者的配置，而在Spring Cloud Alibaba的Nacos上进行了生产者和消费者的完整兼容方案。

最后注意兼容集成的版本为商用RocketMq使用4.x版本，最近新出的5.X 的版本并未进行测试，不保证正常使用。

兼容关键点

  1. 在沿用SpringBoot的YML基础配置基础上实现商用和开源模式的兼容。
  2. 商用RocketMq需要使用官方提供的依赖包，依赖包可以正常兼容SpringBoot等依赖。
  3. 集成之后便于开发和扩展，并且易于其他开发人员理解。
  4. 两种模式之间互相不会产生干扰。

SpringBoot2.X 兼容

下面先介绍SpringBoot项目的兼容。

SpringBoot项目兼容

开源版本

首先我们观察YAML文件，对于开源版本的RocketMq设置，单机版本可以直接配置一个ip和端口即可，如果是集群则用分号隔开多个NameServer的连接IP地址（NameServ独立部署，内部进行自动同步 ）。

#消息队列
rocketmq:
  # 自定义属性，作用下文将会进行解释
  use-aliyun-rocketSever: false
  name-server: 192.168.58.128:9876 # 192.168.244.128:9876;192.168.244.129:9876;
  producer:
    group: testGroup
    # 本地开发不使用商业版，可以不配置
    secret-key: NONE
    # 本地开发不使用商业版，可以不配置
    access-key: NONE
    # 商用版本请求超时时间，开源版本不使用此参数
    timeoutMillis: NONE

SpringBoot中集成开源的RocketMq非常简单，只需要一个依赖就可以自动完成相关准备：


    org.apache.rocketmq
    rocketmq-spring-boot
    2.2.2

具体的使用通常为封装或者直接使用RocketMqTemplate：


@Autowired
private RocketMQTemplate mqTemplate;

public void sendRocketMqUniqueTextMessage(String topic, String tag, String queueMsg) {
        if (StringUtils.isNotEmpty(topic) && StringUtils.isNotEmpty(tag) && StringUtils.isNotEmpty(queueMsg)) {
            String queueName = topic + ":" + tag;
            //封装消息，分配唯一id
            MessageData messageData = new MessageData();
            messageData.setMsgId(IdUtil.randomUUID());
            messageData.setMsgContent(queueMsg);
            queueMsg = JSON.toJSONString(messageData);
            log.info("线程：{}，向队列：{}，发送消息：{}", Thread.currentThread()
                    .getName(), queueName, queueMsg);
            try {
                mqTemplate.syncSend(queueName, queueMsg);
            } catch (Exception e) {
                log.info("向队列：{}，发送消息出现异常：{}", queueName, queueMsg);
                //出现异常，保存异常信息到数据库
                SaMqMessageFail saMqMessageFail = new SaMqMessageFail();
                // 封装失败消息，调用失效处理Service将失败发送请求入库，或许通过其他方法重试
                saMqMessageFailService.insert(saMqMessageFail);
            }
        }
    }

开源版本的SpringBoot集成RocketMq就是如此简单。

商用版本

商用版本RocketMq我们使用商业版TCP协议SDK（推荐），注意这里用的是4.X版本。商用版本的YAML配置和开源版本显式配置是一样的，但是需要注意参数use-aliyun-rocketSever=true，并且secretKey和accessKey以及name-server都需要配置为阿里云提供的配置，最后设置消息发送超时时间timeoutMillis设置合理时间（单位为毫秒），便于排查问题和防止线程长期占用：

#消息队列
rocketmq:
  use-aliyun-rocketSever: true
  # 使用阿里云提供的endpoint
  name-server: http://xxxxx.aliyuncs.com:8080
  producer:
    group: testGroup
    secret-key: xxx
    access-key: xxxx
    # 商用版本请求超时时间
    timeoutMillis: 15000
  # 如果需要设置消费者，可以按照同样的方式集成
  consumer:
      group: testGroup
    secret-key: xxx
    access-key: xxxx
    # 商用版本请求超时时间 15秒
    timeoutMillis: 15000
注意这里仅仅配置了生产者，读者可以按需设置为消费者，设置方式和生产者同理。

设置YAML之后，我们需要在Maven中引入下面的配置：


    com.aliyun.openservices
    ons-client
    
    1.8.8.1.Final

最后应该如何使用呢？这里就是商用RocketMq比较蛋疼的点了，使用RocketMQTemplate是这种情况下是无法使用商用RocketMq的，我们需要 手动注入商用的SDK依赖ProducerBean，具体的操作如下：

  1. 构建配置类，这里仿照了官方提供的demo增减配置：
/**
阿里云服务配置封装，注意和本地部署的rocketmq配置区分
*/
@Data
@Configuration
@ConfigurationProperties(prefix = "rocketmq")
public class AliyunRocketMqConfig {

    /**
     *鉴权需要的AccessKey ID
     */
    @Value("${rocketmq.use-aliyun-rocketSever:null}")
    private String useAliyunRocketMqServerEnable;
    /**
     *鉴权需要的AccessKey ID
     */
    @Value("${rocketmq.producer.access-key:null}")
    private String accessKey;

    /**
     *鉴权需要的AccessKey Secret
     */
    @Value("${rocketmq.producer.secret-key:null}")
    private String secretKey;

    /**
     * 实例TCP 协议公网接入地址（实际项目，填写自己阿里云MQ的公网地址）
     */
    @Value("${rocketmq.name-server:null}")
    private String nameSrvAddr;

    /**
     * 延时队列group
     */
    @Value("${rocketmq.producer.group:null}")
    private String groupId;

    /**
     * 消息发送超时时间，如果服务端在配置的对应时间内未ACK，则发送客户端认为该消息发送失败。
     */
    @Value("${rocketmq.producer.timeoutMillis:null}")
    private String timeoutMillis;


    //获取Properties
    public Properties getRocketMqProperty() {
        Properties properties = new Properties();
        properties.setProperty(PropertyKeyConst.GROUP_ID,this.getGroupId());
        properties.setProperty(PropertyKeyConst.AccessKey, this.accessKey);
        properties.setProperty(PropertyKeyConst.SecretKey, this.secretKey);
        properties.setProperty(PropertyKeyConst.NAMESRV_ADDR, this.nameSrvAddr);
        properties.setProperty(PropertyKeyConst.SendMsgTimeoutMillis, this.timeoutMillis);
        return properties;
    }

}
  1. 构建商用RocketMq初始化类。这里会遇到比较蛋疼的事情，因为我们的依赖是商用RocketMq与开源的SpringBoot依赖共存的，虽然我们可以商用的RocketMq，但是启动的时候会执行到此类进行初始化，返回NULL会导致SpringBoot项目无法正常启动，这里无奈只能使用一个warn日志进行提示开源版本有可能出现Bean被覆盖问题，实际上使用下来没有特别大的影响。
写的比较丑陋，读者有更优雅的处理方式欢迎指导。笔者目前只想到了使用这种“不管”的方式保证项目不改任何代码的情况正常运行。 
/**
 * 阿里云rocketMq初始化
 **/
@Configuration
@Slf4j
public class AliyunProducerInit {

    @Autowired
    private AliyunRocketMqConfig aliyunRocketMqConfig;

    @Bean(initMethod = "start", destroyMethod = "shutdown")
    public ProducerBean buildProducer() {
        if(!Boolean.valueOf(aliyunRocketMqConfig.getUseAliyunRocketMqServerEnable())){
            log.warn("非商用版本为了兼容依然需要注入此Bean，但是只读取有关nameServ和group信息");
        }
        ProducerBean producer = new ProducerBean();
        // ProducerBean中的properties只有被覆盖的配置会使用自定义配置，其他配置会使用SDK的默认配置。
        producer.setProperties(aliyunRocketMqConfig.getRocketMqProperty());
        return producer;
    }
}

此外这里必须要吐槽一下商用RocketMq的注释居然是全中文的！比如com.aliyun.openservices.ons.api.bean.ProducerBean的注释：

【RocketMq】商用RocketMq和开源RocketMq的兼容问题解决方案_第1张图片

这样是好事还是坏事，大家自行体会。。。。。个人第一次看到的时候着实被震惊了。
  1. 做完上面两步之后，我们就可以实现RocketMqTemplate调用请求，至此完成兼容。

SpringBoot项目兼容小结

这里简单小结一下SpringBoot的兼容过程，可以看到整个步骤仅仅是 在商用RocketMq多做了一步bean注入的操作而已，整体使用上十分简单。但是这里只介绍了生产者的集成，那么消费者如何兼容？稍安勿躁，我们接着看Spring Cloud版本的集成案例。

Spring Cloud Alibaba项目兼容

目前国内使用的比较多的是Spring Cloud Alibaba，注意这些配置都写入到Nacos当中。

开源版本

开源版本的接入方式和SpringBoot是一样的，这里简单回顾：

  1. 开源版本需要设置参数，这里设置了生产者和消费者：
#消息队列 - 开源版本
rocketmq:
  use-aliyun-rocketSever: false
  name-server: 192.168.0.92:9876
  producer:
    group: testGroup
    secret-key: NONE
    access-key: NONE
    timeoutMillis: 15000
    consumeThreadNums: 20
  consumer:
    group: testGroup
    secret-key: NONE
    access-key: NONE
    timeoutMillis: 15000
    consumeThreadNums: 20
  1. 添加依赖：

    org.apache.rocketmq
    rocketmq-spring-boot
    2.2.2
  1. 使用RocketMqTemplate可以进行消息发送，而消费者则需要使用监听器+注解的方式，快速注入一个消费者。大体模板如下：
@Slf4j
@Component
@RocketMQMessageListener(topic = "test_topic", consumerGroup = "testGroup", selectorExpression = "test_tag")
public class QueueRemoteRecoListener implements RocketMQListener {

    @Override
    public void onMessage(MessageExt message) {
        // dosomething
    }

}

商用版本

这节是本文稍微复杂一点的部分，我们按照步骤介绍接入过程：

  1. 在Nacos的配置中加入RocketMq商用所需的配置内容，和开源版本的设置类似：
#消息队列 - 商用版本
rocketmq:
 # 开源RocketMq和商业版RocketMq切换开关
use-aliyun-rocketSever: true
name-server: http://xxxx.mq.aliyuncs.com:80
producer:
# 目前uat借助开发测试使用
  group: testGroup
  secret-key: xxx
  access-key: xxx
  timeoutMillis: 15000
  consumeThreadNums: 20
consumer:
  group: testGroup
  secret-key: xxx
  access-key: xxx
  timeoutMillis: 15000
  consumeThreadNums: 20
  1. 添加商用RocketMq的TCP接入方式需要的依赖包。

    com.aliyun.openservices
    ons-client
    
    1.8.8.1.Final
  1. 新增配置类，和SpringBoot的商用版本方式也是类似的：
/**
 * 
 * rocketmq 阿里云服务配置封装，注意和本地部署的rocketmq配置区分
 **/
@Data
@Configuration
@ConfigurationProperties(prefix = "rocketmq")
public class AliyunCommercialRocketMqConfig {

    /**
     *鉴权需要的AccessKey ID
     */
    @Value("${rocketmq.use-aliyun-rocketSever:null}")
    private String useAliyunRocketMqServerEnable;
    /**
     *鉴权需要的AccessKey ID
     */
    @Value("${rocketmq.consumer.access-key:null}")
    private String accessKey;

    /**
     *
     */
    @Value("${rocketmq.use-aliyun-rocketsever:null}")
    private String useAliyunRocketServer;

    /**
     *鉴权需要的AccessKey Secret
     */
    @Value("${rocketmq.consumer.secret-key:null}")
    private String secretKey;

    /**
     * 实例TCP 协议公网接入地址（实际项目，填写自己阿里云MQ的公网地址）
     */
    @Value("${rocketmq.name-server:null}")
    private String nameSrvAddr;

    /**
     * 延时队列group
     */
    @Value("${rocketmq.consumer.group:null}")
    private String groupId;

    /**
     * 消息发送超时时间，如果服务端在配置的对应时间内未ACK，则发送客户端认为该消息发送失败。
     */
    @Value("${rocketmq.consumer.timeoutMillis:null}")
    private String timeoutMillis;

    /**
     * 将消费者线程数固定为20个 20为默认值
     */
    @Value("${rocketmq.consumer.consumeThreadNums:null}")
    private String consumeThreadNums;



    public Properties getRocketMqProperty() {
        Properties properties = new Properties();
        properties.setProperty(PropertyKeyConst.GROUP_ID,this.getGroupId());
        properties.setProperty(PropertyKeyConst.AccessKey, this.accessKey);
        properties.setProperty(PropertyKeyConst.SecretKey, this.secretKey);
        properties.setProperty(PropertyKeyConst.NAMESRV_ADDR, this.nameSrvAddr);
        properties.setProperty(PropertyKeyConst.SendMsgTimeoutMillis, this.timeoutMillis);
        return properties;
    }

}
  1. 下一步是扩展官方消息订阅类，为啥要这样做？主要是接入实验中发现官方的消息订阅类没有 全量参数的构造器，难以对于消息订阅类静态参数化常量，构造一个订阅消息使用默认方式还需要static代码块设置。所以这里对于官方的消息订阅类进行扩展，子类代码是对于父类拷贝了一遍，没有做其他改动：
/**
对于指定类进行扩展，更容易的初始化
@see com.aliyun.openservices.ons.api.bean.Subscription 被扩展类
 **/
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class AliyunCommercialRocketMqSubscriptionExt extends Subscription {
    /**
     * 主题
     */
    private String topic;
    /**
     * 条件表达式，具体参考rocketmq
     */
    private String expression;

    /**
     * TAG or SQL92
     * 
if null, equals to TAG
     *
     * @see com.aliyun.openservices.ons.api.ExpressionType#TAG
     * @see com.aliyun.openservices.ons.api.ExpressionType#SQL92
     */
    private String type;


    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((topic == null) ? 0 : topic.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        AliyunCommercialRocketMqSubscriptionExt other = (AliyunCommercialRocketMqSubscriptionExt) obj;
        if (topic == null) {
            if (other.topic != null) {
                return false;
            }
        } else if (!topic.equals(other.topic)) {
            return false;
        }
        return true;
    }

}
  1. 接着我们构建静态化的消息订阅类，这个常量类会封装系统需要使用到的消息订阅对象，在后续注册监听器需要使用，这里先提前定义。
/**
 * 队列常规配置，用于启动时候初始化配置，
 * 所有配置均需要放置到此类中对外扩展使用
 **/
public final class AliyunCommercialRocketMqConstants {
    
    public static final String TEST_TOPIC = "test_topic";
    public static final String TEST_TAG = "test_tag";
    
    /**
     * 参考案例，仅仅作为开发验证使用
     */
    public static final AliyunCommercialRocketMqSubscriptionExt QUEUE_TEST = new AliyunCommercialRocketMqSubscriptionExt(RocketMqKey.TEST_TOPIC, RocketMqKey.TEST_TAG, null);
}

为了方便管理，我们可以把这些关键Key在单独放到一个类：

public class RocketMqKey {
    public static final String TEST_TOPIC = "test_topic";
    public static final String TEST_TAG = "test_tag";   
}

/**
 * 队列常规配置，用于启动时候初始化配置，
 * 所有配置均需要放置到此类中对外扩展使用
 **/
public final class AliyunCommercialRocketMqConstants {
    /**
     * 参考案例，仅仅作为开发验证使用
     */
    public static final AliyunCommercialRocketMqSubscriptionExt QUEUE_TEST = new AliyunCommercialRocketMqSubscriptionExt(RocketMqKey.TEST_TOPIC, RocketMqKey.TEST_TAG, null);
}
  1. 做好一系列准备之后，我们开始商用版本生产者兼容，商用版本的发送者可以像是下面这样封装官方提供的demo，也可以使用注入ProducerBean的方式集成：
/**
 * 商用aliyun Rocketmq 工具类封装
 **/
@Component
@Slf4j
public class AliyunCommercialRocketMqSendUtils {

    private static final long KEEP_ALIVE_TIME = 60L;

    private final ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
            KEEP_ALIVE_TIME, TimeUnit.SECONDS,
            new SynchronousQueue<>());

    @Autowired
    private Producer producer;

    @Autowired
    private SaMqMessageFailService saMqMessageFailService;

    @Autowired
    private AliyunRocketMqConfig aliyunRocketMqConfig;

    /**
     * 异步推送，需要调用方手动指定callback
     
     */
    public void singleAsyncSend(String topic, String tag, String msgBody, SendCallback sendCallback) {
        singleAsyncSend(topic, tag, msgBody, null, sendCallback);
    }

    /**
     * 异步推送，需要调用方手动指定callback
     * 如果需要使用callback通知，可以使用下面的代码进行处理
     
         producer.sendAsync(msg, new SendCallback() {
        @Override
        public void onSuccess(final SendResult sendResult) {
            assert sendResult != null;
            System.out.println(sendResult);
        }

        @Override
        public void onException(final OnExceptionContext context) {
            ONSClientException exception = context.getException();
            //                    //出现异常意味着发送失败，为了避免消息丢失，建议缓存该消息然后进行重试。
            log.error("【RocketMq-Commercial】发送失败，消息存储到失败记录表，发送 topic => {}, 发送 tag => {}， msgBody => {}， key => {}（如果设置key，可以使用key查找消息）,商用版需要在RocketMq云服务重试，失败原因为: {}"
            , topic, tag, msgBody, key, exception.getMessage());
            buildMqErrorInfoAndInsertDb(msgBody, exception);
        }
    });
     

     * @param topic 主题
     * @return void
     * @description
     * @param: tag  标签
     * @param: msgBody 推送消息
     * @param: key 方便消息查找的key
     * @param: sendCallback 手动回调
     */
    public void singleAsyncSend(String topic, String tag, String msgBody, String key, SendCallback sendCallback) {
        if(Boolean.FALSE.equals(Boolean.valueOf(aliyunRocketMqConfig.getUseAliyunRocketMqServerEnable()))){
            throw new UnsupportedOperationException("请设置 UseAliyunRocketServer=true 切换到商用rocketMq模式");
        }
        if (StringUtils.isAnyBlank(topic, tag, msgBody)) {
            throw new IllegalArgumentException("topic, tag and msgBody must be not blank");
        }
        //对于使用异步接口，建议设置单独的回调处理线程池，拥有更灵活的配置和监控能力。
        //如下构造线程的方式请求队列为无界仅用作示例，有OOM的风险。
        //更合理的构造方式请参考阿里巴巴Java开发手册： https://github.com/alibaba/p3c
        producer.setCallbackExecutor(THREAD_POOL_EXECUTOR);

        //循环发送消息
        Message msg = new Message( //
                // Message所属的Topic
                topic,
                // Message Tag 可理解为Gmail中的标签，对消息进行再归类，方便Consumer指定过滤条件在MQ服务器过滤
                tag,
                // Message Body 可以是任何二进制形式的数据， MQ不做任何干预
                // 需要Producer与Consumer协商好一致的序列化和反序列化方式
                msgBody.getBytes());
        // 设置代表消息的业务关键属性，请尽可能全局唯一
        // 以方便您在无法正常收到消息情况下，可通过MQ 控制台查询消息并补发
        // 注意：不设置也不会影响消息正常收发
        if (CharSequenceUtil.isNotBlank(key)) {
            msg.setKey(key);
        }
        // 发送消息，只要不抛异常就是成功
        try {
            producer.sendAsync(msg, sendCallback);
        } catch (ONSClientException exception) {
            //出现异常意味着发送失败，为了避免消息丢失，建议缓存该消息然后进行重试。
            log.error("【RocketMq-Commercial】发送失败，消息存储到失败记录表，发送 topic => {}, 发送 tag => {}， msgBody => {}， key => {}（如果设置key，可以使用key查找消息）,商用版需要在RocketMq云服务重试，失败原因为: {}"
                    , topic, tag, msgBody, key, exception.getMessage());
            buildMqErrorInfoAndInsertDb(msgBody, exception);
        }


    }

    /**
     * 阻塞单独推送队列，使用系统默认的Key生成规则
     *
     * @param topic 主题
     * @return void
     * @description 阻塞单独推送队列
     * @param: tag 标签
     * @param: msgBody msgBody内容
     */
    public void singleSyncSend(String topic, String tag, String msgBody) {
        singleSyncSend(topic, tag, msgBody, null);
    }

    /**
     * 阻塞单独推送队列，使用系统默认的Key生成规则
     *
     * @param topic 主题
     * @return void
     * @description 阻塞单独推送队列
     * @param: tag 标签
     * @param: msgBody msgBody内容
     */
    public void singleSyncSend(String topic, String tag, String msgBody, String key) {
        if(!Boolean.valueOf(aliyunRocketMqConfig.getUseAliyunRocketMqServerEnable())){
            throw new UnsupportedOperationException("请设置 UseAliyunRocketServer=true 切换到商用rocketMq模式");
        }
        if (StringUtils.isAnyBlank(topic, tag, msgBody)) {
            throw new IllegalArgumentException("topic, tag and msgBody must be not blank");
        }
        Message msg = new Message( //
                // Message所属的Topic
                topic,
                // Message Tag 可理解为Gmail中的标签，对消息进行再归类，方便Consumer指定过滤条件在MQ服务器过滤
                tag,
                // Message Body 可以是任何二进制形式的数据， MQ不做任何干预
                // 需要Producer与Consumer协商好一致的序列化和反序列化方式
                msgBody.getBytes());
        // 设置代表消息的业务关键属性，请尽可能全局唯一
        // 以方便您在无法正常收到消息情况下，可通过MQ 控制台查询消息并补发
        // 注意：不设置也不会影响消息正常收发
        if (CharSequenceUtil.isNotBlank(key)) {
            msg.setKey(key);
        }
        // 发送消息，只要不抛异常就是成功
        try {
            SendResult sendResult = producer.send(msg);
            log.info("【RocketMq-Commercial】推送成功，singleSyncSend => {}", JSON.toJSONString(sendResult));
        } catch (ONSClientException e) {
            log.error("【RocketMq-Commercial】发送失败，消息存储到失败记录表，发送 topic => {}, 发送 tag => {}， msgBody => {}， key => {}（如果设置key，可以使用key查找消息）,商用版需要在RocketMq云服务重试，失败原因为: {}"
                    , topic, tag, msgBody, key, e.getMessage());
            buildMqErrorInfoAndInsertDb(msgBody, e);
        }

    }

    /**
     * 构建mq错误信息，并且插入到异常推送表
     *
     * @param msgBody
     * @return void
     * @description 构建mq错误信息，并且插入到异常推送表
     * @param: e
     */
    private void buildMqErrorInfoAndInsertDb(String msgBody, ONSClientException e) {
        //出现异常意味着发送失败，为了避免消息丢失，建议缓存该消息然后进行重试。
        //出现异常，保存异常信息到数据库
        SaMqMessageFail saMqMessageFail = new SaMqMessageFail();
        saMqMessageFail.setMqId(IdUtil.randomUUID());
        saMqMessageFail.setQueueName("RocketMq-Commercial");
        saMqMessageFail.setQueueMessage(msgBody);
        // 2 代表失败
        saMqMessageFail.setStatus(2);
        // 1 代表重试次数
        saMqMessageFail.setProcCount(1);
        saMqMessageFail.setFailReason(e.toString());
        saMqMessageFail.setCreateDate(new Date());
        saMqMessageFailService.insert(saMqMessageFail);
    }

}
注入ProductBean的方式可以从上面提到的SpringBoot集成方式处理。
  1. 现在我们解决之前遗留的问题，如果是消费者，应该如何更优雅的接收消息？首先我们需要明白，商用RocketMq注入是需要依靠手动构建监听器，但是我们上面提到SpringBoot提供了注解+ @Component的方式实现队列监听的消费者。此外为了避免和开源版本冲突，我们使用之前参数配置自定义的开关，在遇到开源版本的时候我们返回null（这里返回null Spring会扫描获取SpringBoot的RocketMq依赖，不会出现报错和无法启动的问题，和前面的情况略有不同）防止自动注入商用RocketMq的监听器。

下面是商用版本注入ConsumerBean的代码，订阅商用RocketMq的消费监听器：

/**
 *  阿里云商用Rocketmq 队列接收
 *  商用rocketmqConsumer的所有请求会进入一个入口，需要分发到不同的具体业务处理。
 **/
@Component
@Slf4j
public class AliyunCommercialRocketMqQueueConsumer {

    @Autowired
    private AliyunCommercialRocketMqConfig aliyunCommercialRocketMqConfig;

    // 自定义的监听器
    @Autowired
    private AliyunCommerciaRocketMqTestListener aliyunCommerciaRocketMqTestListener;

    @Bean(initMethod = "start", destroyMethod = "shutdown")
    public ConsumerBean buildConsumer() {
        // 如果开关为false, 则不能注入此对象，否则商用的API会顶替掉 框架诸如的Bean出现异常
        if(!Boolean.valueOf(aliyunCommercialRocketMqConfig.getUseAliyunRocketServer())){
            log.warn("非商用版本不注入商用版本监听器");
            return null;
        }
        ConsumerBean consumerBean = new ConsumerBean();
        //配置文件
        Properties properties = aliyunCommercialRocketMqConfig.getRocketMqProperty();
        properties.setProperty(PropertyKeyConst.GROUP_ID, aliyunCommercialRocketMqConfig.getGroupId());
        //将消费者线程数固定为20个 20为默认值
        properties.setProperty(PropertyKeyConst.ConsumeThreadNums, aliyunCommercialRocketMqConfig.getConsumeThreadNums());
        consumerBean.setProperties(properties);
        //订阅关系
        Map subscriptionTable = new HashMap<>(2);
        // 使用了之前定义的测试用的监听器
        subscriptionTable.put(AliyunCommercialRocketMqConstants.QUEUE_TEST, aliyunCommerciaRocketMqTestListener);
        //订阅多个topic如上面设置

        consumerBean.setSubscriptionTable(subscriptionTable);
        return consumerBean;
    }


}

AliyunCommerciaRocketMqTestListener 自定义监听器为了兼容商用和开源版本做了下面的改变，为了方便理解这里加入了相关注解：

/**
 * 监听器开发模板
 **/
@Slf4j
@Component
// 开源版本可以兼容此注解
@RocketMQMessageListener(topic = RocketMqKey.TEST_TOPIC, consumerGroup = RocketMqKey.TEST_GROUP, selectorExpression = RocketMqKey.TEST_TAG)
// RocketMQListener 属于SpringBoot RocketMq的依赖
// MessageListener 属于商用RocketMq的SDK
public class QueueRemoteReconListener implements RocketMQListener, MessageListener {


    // 开源版本的使用
    @Override
    public void onMessage(MessageExt message) {
        // 开源版本的SpringBoot方式，和上文介绍相同
    }

    /** 
     * @description  
     * @param message 消息类. 一条消息由主题, 消息体以及可选的消息标签, 自定义附属键值对构成.
     * 注意: 我们对每条消息的自定义键值对的长度没有限制, 但所有的自定义键值对, 系统键值对序列化后, 所占空间不能超过32767字节.
     * @param: context 每次消费消息的上下文，供将来扩展使用
     * @return com.aliyun.openservices.ons.api.Action 
     */ 
    @Override
    public Action consume(Message message, ConsumeContext context) {
        // 商用版本要求实现这个方法,Action如下，默认失败重试16次，返回ReconsumeLater会触发重试机制，所以会存在重复消费的问题
        //public enum Action {
            /**
             * 消费成功，继续消费下一条消息
             */
            //CommitMessage,
            /**
             * 消费失败，告知服务器稍后再投递这条消息，继续消费其他消息
             */
            //ReconsumeLater,
        //}

    }
}

以上就是消费者的兼容处理，既可以满足开源版本的注解开发要求，也可以不膨胀类的情况下沿用扩展。

Spring Cloud Alibaba项目兼容小结

从个人的角度来看，在生产者的兼容上比较容易实现，按照官方的demo构建带商用RocketMq的ProducerBean即可，而消费者的集成则要复杂一些，这里为了考虑不重复的设置或者写重复代码，把关键的配置静态化，同时为了官方写的粗糙的消息订阅类做了继承覆盖的操作兼容。此外为了防止开源版本的消费者Bean被商用的监听器覆盖导致失效，使用了简单的开关来进行Bean的注入控制，写的比较粗糙，读者有更好的写法欢迎讨论。

总体来看来说商用版本的RocketMq集成起来略微麻烦，但是还是可以接受。此外也可以看到SDK的兼容性实际上是比较简陋的，很多地方的很像但是又完全是自己重新设计的，感觉就是一个新的团队给老团队做出来的东西做兼容的感觉，不过不就是桥接嘛，我也会，所以最后个人对付消费者兼容就用来多接口实现的兼容写法了。

最终的集成效果是开源版本关闭注入bean的开关，配置为了照顾Properties对于不需要的配置进行占位处理，而商用版本则打开开关，通过自定义注入监听器的方式顶替掉SpringBoot的依赖。

最后的效果是只需要修改RocketMq的配置，启动之后自动连接到相关的RocketMq。

开源版本：

#消息队列 - 开源版本
rocketmq:
  use-aliyun-rocketSever: false
  name-server: 192.168.0.92:9876
  producer:
    group: testGroup
    secret-key: NONE
    access-key: NONE
    timeoutMillis: 15000
    consumeThreadNums: 20
  consumer:
    group: testGroup
    secret-key: NONE
    access-key: NONE
    timeoutMillis: 15000
    consumeThreadNums: 20

商用版本

#消息队列 - 商用版本
rocketmq:
 # 开源RocketMq和商业版RocketMq切换开关
  use-aliyun-rocketSever: true
  name-server: http://xxxx.mq.aliyuncs.com:80
  producer:
# 目前uat借助开发测试使用
    group: testGroup
      secret-key: xxx
      access-key: xxx
      timeoutMillis: 15000
      consumeThreadNums: 20
    consumer:
      group: testGroup
      secret-key: xxx
      access-key: xxx
      timeoutMillis: 15000
      consumeThreadNums: 20

阿里云商用RocketMq简单介绍（4.X版本）

官方介绍：https://help.aliyun.com/product/29530.html

有关RocketMq本身的介绍部分可以阅读：[[【RocketMq】RocketMq 扫盲]]，这里挑了商用版本个人认为需要关注的几个点进行介绍。注意这里使用的商用RocketMq版本为4.X的版本。

计费模式

商用RocketMq主要分为下面几个部分：

  • 主系列：标准版、专业版、铂金版
  • 子系列：单节点版、集群版

个人最后是白嫖了公司的商用集群版RocketMq进行实验，计费的方式分为包年包月和按量付费，前者适用于流量比较大并且固定的情况，使用套餐比较划算，而后者按需付费则适用于RocketMq使用较少（或者不稳定）或者调用量较少的情况，个人学习也比较推荐按量付费模式，比包年包月划算很多。

如果出现欠费，在实例停服7天后两种付费模式均会清除所有的RocketMq数据，而日常欠费则会被自动停用，嘛，和电话卡欠费差不多的道理，这里就不过多拓展了。如果要退订商用RocketMq的服务。按量付费可以随时退订，包年包月也会根据天数进行退订。

PS：看完这一整套计费模式下来，发现还是挺良心的。让我没想到的是包年包月居然可以计算未使用的天数返还，这一点挺不错的，用起来不用担心被套进去。

接入方式

商用RocketMq的接入步骤如下：

【RocketMq】商用RocketMq和开源RocketMq的兼容问题解决方案_第2张图片

官方在快速入门中提供了创建资源的解释视频：https://help.aliyun.com/document_detail/441914.html。有两个点需要注意，第一个点是RAM用户必须要进行账户授权才能正常使用，第二个点是对外访问方式设置，消息队列RocketMQ版支持VPC访问和公网访问。资源创建完成之后就可以使用官方提供的SDK收发消息，在使用之前需要注意下面这些前提：

之后便是在项目中引入JAVA依赖和复制粘贴模板代码验证。

消息队列模型

商用RocketMq的基本使用逻辑如下：

【RocketMq】商用RocketMq和开源RocketMq的兼容问题解决方案_第3张图片

按照消息类型，商用RocketMq提供了下面的消息类型：

SDK接入参考

SDK接入的主页链接如下：

https://help.aliyun.com/document_detail/69111.html

主要介绍了下面几个点，实际参考第二个推荐的接入方式即可。

对于JAVA应用程序建议使用TCP协议SDK，集成的方式也比较简单，为了方便理解，也可以通过以下链接获取相关Demo，里面都有详细的注释解释：

如果是HTTP协议的SDK，则使用下面的依赖包：


    com.aliyun.mq
    mq-http-sdk
    
    1.0.3.2 
    jar-with-dependencies

如果是TCP协议的接入方式，则使用下面的依赖包：


    com.aliyun.openservices
    ons-client
    
    1.8.8.1.Final

接入细节说明

个人在实验的时候发现HTTP协议的版本集成SDK更像是给了一套API工具包，好处是可以不需要依赖Spring框架等单独使用，但是最大的缺点也是这里，很难用于框架当中，如果要实现自动接收消息并且处理，需要依靠手动实现定时任务拉取消息实现自动消费，这一点也比较蛋疼。

这里列举 HTTP的SDK的发送和接受代码，首先是生产者的模板代码，这些代码和开源的RocketMq使用类似：

// 省略大量代码。。。
// 循环发送4条消息。
            for (int i = 0; i < 4; i++) {
                TopicMessage pubMsg;        // 普通消息。
                pubMsg = new TopicMessage(
                // 消息内容。
                "hello mq!".getBytes(),
                // 消息标签。
                "A"
                );
                // 设置消息的自定义属性。
                pubMsg.getProperties().put("a", String.valueOf(i));
                // 设置消息的Key。
                pubMsg.setMessageKey("MessageKey");
               
            // 同步发送消息，只要不抛异常就是成功。
            TopicMessage pubResultMsg = producer.publishMessage(pubMsg);

            // 同步发送消息，只要不抛异常就是成功。
            System.out.println(new Date() + " Send mq message success. Topic is:" + topic + ", msgId is: " + pubResultMsg.getMessageId()
                        + ", bodyMD5 is: " + pubResultMsg.getMessageBodyMD5());
            }
        } catch (Throwable e) {
            // 消息发送失败，需要进行重试处理，可重新发送这条消息或持久化这条数据进行补偿处理。
            System.out.println(new Date() + " Send mq message failed. Topic is:" + topic);
            e.printStackTrace();
        }
// 省略大量代码。。。

而在接收方稍微麻烦一些，官方的案例是使用 死循环不断检查Broker是否有积压消息，如果有则通过主动拉取消息的模式去拉取消息。

实现多线程等待的效果可以写入到Thread继承类的Run方法中。 
 // 在当前线程循环消费消息，建议多开个几个线程并发消费消息。
        do {
            
            // 省略大量代码

// 处理业务逻辑。
            for (Message message : messages) {
                System.out.println("Receive message: " + message);
            }

            // 消息重试时间到达前若不确认消息消费成功，则消息会被重复消费。
            // 消息句柄有时间戳，同一条消息每次消费的时间戳都不一样。
            {
                List handles = new ArrayList();
                for (Message message : messages) {
                    handles.add(message.getReceiptHandle());
                }

                try {
                    consumer.ackMessage(handles);
                } catch (Throwable e) {
                    // 某些消息的句柄可能超时，会导致消息消费状态确认不成功。
                    if (e instanceof AckMessageException) {
                        AckMessageException errors = (AckMessageException) e;
                        System.out.println("Ack message fail, requestId is:" + errors.getRequestId() + ", fail handles:");
                        if (errors.getErrorMessages() != null) {
                            for (String errorHandle :errors.getErrorMessages().keySet()) {
                                System.out.println("Handle:" + errorHandle + ", ErrorCode:" + errors.getErrorMessages().get(errorHandle).getErrorCode()
                                        + ", ErrorMsg:" + errors.getErrorMessages().get(errorHandle).getErrorMessage());
                            }
                        }
                        continue;
                    }
                    e.printStackTrace();
                }
            }
       } while (true);
     // 省略大量代码

写在最后

算是一次个人兼容的笔记。还是要吐槽商用的RocketMq集成真的挺无语的，不过阿里的东西懂的都懂。

你可能感兴趣的:(rocketmq)

  • 单节点canal的介绍和搭建（对接mysql和rocketMQ） 汀风 中间件阿里云mysqljava
    单节点canal-server+canal-admin的介绍和搭建（对接mysql和rocketMQ）一、简介1、Canal1、工作原理2、MySQL主从复制实现3、canal架构4、binarylog1、新增binlog2、更新binglog3、增加字段bin-log4、删除字段bin-log5、修改字段bin-log二、使用2.1安装1、本地安装2、docker安装canal-admincan
  • RocketMQ 架构简析，看这篇就够了！ V搜编程进阶路 Java程序员java-rocketmqrocketmq架构
    生产者组（ProducerGroup）同一类Producer的集合，这类Producer发送同一类消息且发送逻辑一致。如果发送的是事务消息且原始生产者在发送之后崩溃，则Broker服务器会联系同一生产者组的其他生产者实例以提交或回溯消费。消费者组（ConsumerGroup）同一类Consumer的集合，这类Consumer通常消费同一类消息且消费逻辑一致。消费者组使得在消息消费方面，实现负载均衡
  • RocketMQ消息重复消费--一起学习吧之架构 吗喽一只 rocketmq学习架构
    一、定义RocketMQ中的消息重复消费（DuplicateConsumption）指的是在某些情况下，消息可能会被多次消费，从而导致业务逻辑的重复执行。重复消费是MQ中常见的问题，尤其在系统调用频繁的场景下，可能会因为超时重试等原因导致重复消费。在RocketMQ中，重复消费可能由多种原因造成，例如服务端重启后的数据恢复、主从同步offset失败，以及消息处理异常等。二、原因RocketMQ消息
  • 分布式中间件-几个常用的消息中间件 问道飞鱼 分布式技术分布式中间件
    文章目录常见消息中间件1.RabbitMQ2.ApacheKafka3.RedisPub/Sub4.ActiveMQ5.AmazonSimpleNotificationService(SNS)和SimpleQueueService(SQS)6.RocketMQ差异总结消息协议1.AMQP(AdvancedMessageQueuingProtocol)2.STOMP(SimpleTextOrient
  • RocketMQ复习 slh别学了 微服务rocketmq微服务java
    之前写的博客太杂，最近想把RocketMQ的知识点再系统的过一遍，带着自己的理解使用简短的话把一些问题总结一下，尤其是开发中和面试中的高频问题，基础知识点可以参考之前写的一些博客，这篇不再赘述。SpringCloud入门(3)RabbitMQRocketMQ学习(1)快速入门RocketMQ学习(2)深入学习RocketMQ学习(3)秒杀实战目录MQ技术对比基本概念(消费者组、订阅关系等)消费模式
  • python使用rocketmq发送消息_阿里云消息队列RocketMQ使用示例 weixin_39953481
    本文代码示例参见：https://gitee.com/imlichao/RocketMQ-exampleApacheRocketMQ文档：http://rocketmq.apache.org/docs/quick-start/阿里云RocketMQ文档：https://help.aliyun.com/product/29530.html简介消息队列RocketMQ是阿里巴巴集团自主研发的专业消息中
  • python调用rocketmq的api_Python：Rocketmq消息队列使用 weixin_39914868
    rocketmq可以与kafka等一起使用，用于实时消息处理。安装rocketmq：pipinstallrocketmq[-ihttps://pypi.tuna.tsinghua.edu.cn/simple]生产消息producer：fromrocketmq.clientimportProducer,Messageimportjsonproducer=Producer('PID-test')pro
  • Python API操作RocketMQ 京城小筑 #Python编程python
    背景：开发背景:公司相关报表需求需要将订单业务数据同步至RocketMQ中，由于需要保证开发的一致性(多个部门协同开发)，所以采用读取Hive离线数据的方式通过PythonAPI写入RocketMQ中，便于其他开发同事调用~开发环境:本地调试系统MacPython3.7.5rocketmq0.4.4(Python模块)rocketmq-client-python2.0.0(Python模块)服务器
  • python操作rocket-mq AQH~ Python
    1、参考源码看源码，可以修改消息字节长度限制（rocketmq/client.py）2、推送消息fromrocketmq.clientimportProducer,Messageproducer=Producer('PID-001')#随便producer.set_namesrv_addr('ip:port')#ip和端口producer.start()msg=Message('rocket_mq
  • Docker部署RocketMQ5.2.0集群 egzosn docker容器运维
    部署架构说明：(1)Producer：生产者(2)Consumer：消费者(3)NameServer：RockerMQ的注册中心，多个实例组成集群，但相互独立，没有信息交换。每个Broker都向所有NameServer实例注册。(4)Broker：负责存储消息、转发消息。部署模式RocketMQ作为消息中间件，其主要功能为消息的Publish/Subscribe。而Broker担任的消息转发和存储
  • RocketMq解决消息重复消费的问题 壹佰大多 java-rocketmqrocketmqredis
    一、RocketMq解决业务端去重步骤：1、记录下每个消息的msgID2、新消息来的时候，查看该消息的msgID是否已记录，是则抛弃，否则消费二、RocketMq一般用redis进行记录，该msg是否被记录1、消费端接收到消息的时候，调用redis提供的incr自增方法，以msgID作为key（具有唯一性），value则默认从1开始递增。2、当incr返回值为1时，设置其失效时间为两分钟以后（每个
  • RocketMQ 幂等性 (消息重复处理) JAVA代码搬运工 RocketMQjava-rocketmqrocketmq
    RocketMQ无法避免消息重复，所以如果业务对消费重复非常敏感，务必要在业务局面去重，有以下几种去重方式1.将消息的唯一键，可以是msgId，也可以是消息内容中的唯一标识字段，例如订单Id等，消费前判断是否在Db或Tair(全局KV存储)中存在，如果不存在则插入，幵消费，否则跳过。（实际过程要考虑原子性问题，判断是否存在可以尝试插入，如果报主键冲突，则插入失败，直接跳过）msgId一定是全局唯一
  • 【Java】已解决：MQBrokerException: CODE: 1 DESC: create mapped file failed, server is busy or broke 屿小夏 java开发语言
    文章目录一、分析问题背景场景示例：二、可能出错的原因三、错误代码示例错误分析：四、正确代码示例代码改进说明：五、注意事项在分布式消息中间件如ApacheRocketMQ的使用过程中，MQBrokerException是一个开发者可能会遇到的常见异常之一。特别是CODE:1DESC:createmappedfilefailed,serverisbusyorbroke这个错误，通常指示了在消息存储过程
  • ASP.NET Core 入门教学八 集成RocketMQ消息队列 充值内卷 asp.netrocketmq后端
    在ASP.NETCore中集成RocketMQ消息队列，你需要遵循以下步骤：1.安装RocketMQ客户端库首先，你需要在你的ASP.NETCore项目中安装RocketMQ的.NET客户端库。你可以使用NuGet包管理器来完成这个任务。在VisualStudio中，右键点击你的项目，选择“管理NuGet程序包”，然后搜索并安装Apache.RocketMQ.Client包。2.配置RocketM
  • 阿里云RocketMQ_Exception]valid resource owner failed. maybe the resource wswy_tp_test_1 not created fantasyYan2 阿里云recketmq消息中间件
    这是我之前工作时遇到过的一个问题，在网上提供的解决方法都不可用，于是询问了阿里云的工单，终于解决了这个问题，现在把这个可行的解决方法拿出来和大家分享：1.instanceId是否有填，虽然给的demo说默认为空，其实不填就会报这个错，可能是由于mq版本升级的问题2.查看AccessKeyId对应的用户是否有操作mq的权限3.顺序消息类型不支持http请求（本人的项目就是由这个问题引起的，这个阿里云
  • RocketMQ 如何保证消息不丢失？ JinYD2018 #RocketMQjava-rocketmqrocketmqjava
    RocketMQ的消息想要确保不丢失，需要生产者、消费者以及Broker的共同努力，缺一不可。生产者（Producer）1、发送方式：选择同步发送同步发送：发送消息后，需要阻塞等待Broker确认收到消息，生产者才能拿到返回的SendResult异步发送：Producer首先构建一个向broker发送消息的任务，把该任务提交给线程池，等执行完该任务时，回调用户自定义的回调函数，执行处理结果。2、重
  • Kafka、RabbitMQ、RocketMQ 之间的区别是什么 m0_67394230 面试学习路线阿里巴巴android前端后端
    Kafka、RabbitMQ、RocketMQ之间的区别是什么?-知乎Kafka和RabbitMQ的区别:RabbitMQ有这么个特性，它在官方文档就声明了自己是不保证多线程消费同一个队列的消息，一定保证顺序的。而不保证的原因，是因为多线程时，当一个线程消费消息报错的时候，RabbitMQ会把消费失败的消息再入队，此时就可能出现乱序的情况。用RabbitMQ，出现了三个问题：为了实现发布订阅功能，
  • spring使用@Resource 注入map Java知识技术分享 spring技术springjava后端
    spring使用@Resource注入map注入多个Service：/***单笔付款状态MQ消费**@authorzkg*@since2024-09-0616:11:19*/@Slf4j@Component@RocketMQMessageListener(topic=PayGlobalConstants.PAY_APPL_SINGLE_TOPIC,consumerGroup=PayGlobalCo
  • Kafka的事务实现 Mirana_77 消息队列kafkajava分布式
    Kafka的事务Kafka的事务解决的问题和RocketMQ是不太一样的。RocketMQ中的事务，它解决的问题是，确保执行本地事务和发消息这两个操作，要么都成功，要么都失败。并且，RocketMQ增加了一个事务反查的机制，来尽量提高事务执行的成功率和数据一致性。而Kafka中的事务，它解决的问题是，确保在一个事务中发送的多条消息，要么都成功，要么都失败。注意，这里面的多条消息不一定要在同一个主题
  • SpringBoot整合Kafka ITBOY_ITBOX SpringBootkafkaspringbootjava
    安装windows版安装包下载地址：https://kafka.apache.org/downloads下载完毕后得到tgz压缩文件，使用解压缩软件解压缩即可使用，解压后得到如下文件建议使用windows版2.8.1版本。启动服务器kafka服务器的功能相当于RocketMQ中的broker，kafka运行还需要一个类似于命名服务器的服务。在kafka安装目录中自带一个类似于命名服务器的工具，叫做
  • rocketmq 同步复制，异步复制，同步刷盘，异步刷盘详解 husterlichf #RocketMQjava-rocketmqrocketmqjava
    一、刷盘模式同步刷盘：在返回写成功状态时，消息已经被写入磁盘。具体流程是，消息写入内存的PAGECACHE后，立刻通知刷盘线程刷盘，然后等待刷盘完成，刷盘线程执行完成后唤醒等待的线程，返回消息写成功的状态。优点：机器宕机消息也会被保留，缺点：写入速度慢，吞吐量小。异步刷盘：在返回写成功状态时，消息只是被写入了内存的PAGECACHE，这样的好处是写操作的返回快，吞吐量大；当内存里的消息量积累到一定
  • 聊聊rocketmq的PullConsumerImpl go4it
    序本文主要研究一下rocketmq的PullConsumerImplPullConsumerImplio/openmessaging/rocketmq/consumer/PullConsumerImpl.javapublicclassPullConsumerImplimplementsPullConsumer{privatefinalDefaultMQPullConsumerrocketmqPul
  • 使用 Shell 脚本管理 RocketMQ 服务：启动、停止与状态检查 heromps rocketmq
    在分布式系统中，RocketMQ是一个流行的消息队列中间件。在开发和运维过程中，能够高效地启动、停止和检查RocketMQ相关服务的状态非常重要。本文将介绍如何使用Shell脚本来管理RocketMQ的NameServer、Broker和Dashboard服务，并提供相应的脚本示例和说明。安装可以查看这篇博客RocketMQ实战：在macOS上安装与前端访问全流程指南1.脚本概述这个脚本将涵盖以下
  • SpringBoot优雅的封装不同研发环境下（环境隔离）RocketMq自动ack和手动ack 小吴先生666 springbootrocketmq手动ACK和自动ACKMQ环境隔离
    1.RocketMq的maven依赖版本：org.apache.rocketmqrocketmq-spring-boot-starter2.3.02.RocketMq的yml文件：#自定义属性system:environment:#隔离环境名称，拼接到topic后，xxx_topic_tianxin，默认空字符串name:dev#启动隔离，会自动在topic上拼接激活的配置文件，达到自动隔离的效果
  • helm学习第四篇-微服务组件的加入 Wade_Crab java-rocketmq微服务springboot云计算kubernetes
    微服务的组件也放进去—向外扩张要将Nacos服务添加到你已经包含了SpringBoot、Redis、MySQL和RocketMQ的HelmChart中，你可以按照以下步骤操作：注意！！：nacos好像只有helm文件的github仓库，没有helm的包地址仓库。所以一会思路：找到nacos的github仓库：nacos仓库修改values.yaml内容1.添加NacosHelmChart依赖首先，
  • helm学习第三篇--结合 springboot 单做 Wade_Crab java-rocketmqspringbootrediskubernetes
    创建一个springboot项目放到里面去—开山立派要将你的SpringBoot项目代码与Redis、MySQL和RocketMQ组合到同一个HelmChart中，你可以按照以下步骤进行操作：1.准备SpringBoot项目确保你的SpringBoot项目已经打包为Docker镜像。如果还没有创建Docker镜像，可以在SpringBoot项目的根目录下创建一个Dockerfile，并使用以下内容
  • 12306项目学习笔记（框架篇Base） Rainyocode 学习
    首先学习的是基础框架ApplicationContextHolderApplicationContextHolder提供了一种静态方式来访问Spring容器中的Bean，适用于某些特定场景，如工具类和框架集成。在12306项目中由于我们引入了RocketMQ消息队列，这些库的对象通常不是Spring管理的，无法直接使用@Autowired注入，所以需要ApplicationContextHolde
  • 【Rust光年纪】深度解读：Rust语言中各类消息队列客户端库详细对比 friklogff Rust光年纪rust开发语言后端
    选择最佳Rust消息队列客户端库：全面对比与分析前言随着现代应用程序的复杂性不断增加，消息队列成为构建可靠、高性能系统的重要组件。本文将介绍一些用于Rust语言的消息队列客户端库，包括AMQP、ApacheKafka、NSQ、ApachePulsar和RocketMQ，探讨它们的核心功能、使用场景、安装配置以及API概览。欢迎订阅专栏：Rust光年纪文章目录选择最佳Rust消息队列客户端库：全面对
  • 编写组合helm, 组合之前的几个组件 -2 Wade_Crab dockerkubernetes
    刚刚是独立安装，现在要组合他们到一个Chart里面—初入江湖要将Redis、MySQL和RocketMQ组合在一个HelmChart中，并且部署到同一个KubernetesPod或者同一个Helmrelease中，你可以创建一个自定义的HelmChart，将这三个服务作为子Chart来管理。1.创建自定义HelmChart首先，创建一个新的HelmChart：helmcreatemy-stack这
  • RocketMQ顺序消费 葵续浅笑 rocketmqjava
    根据公司项目的一个使用场景，针对实时预警任务，会有同时消费某个设备正常或异常的事件，而这类事件具有时间维度上的先后性，需要符合先进先出（FIFO）原则进行发布和消费，而MQ消费为了吞吐量基本会使用多线程消费，RocketMQ也会分为多个消息队列，会造成消费无序的情况，这时候为了综合兼顾顺序消费+性能的考虑，可以使用分区顺序消息的策略。生产顺序性发送时将ShardingKey相同（例如同一设备）的消
  • LeetCode[位运算] - #137 Single Number II Cwind javaAlgorithmLeetCode题解位运算
    原题链接：#137 Single Number II  要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间   难度：中等   分析： 与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
  • 《JavaScript语言精粹》笔记 aijuans JavaScript
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
  • 你应该更新的Java知识之常用程序库 Kai_Ge java
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 Guava Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
  • HttpClient 120153216 httpclient
    /** * 可以传对象的请求转发，对象已流形式放入HTTP中 */ public static Object doPost(Map<String,Object> parmMap,String url) { Object object = null; HttpClient hc = new HttpClient(); String fullURL
  • Django model字段类型清单 2002wmj django
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段) BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。 Cha
  • 在SQLSERVER中查找消耗CPU最多的SQL 357029540 SQL Server
    返回消耗CPU数目最多的10条语句 SELECT TOP 10    total_worker_time/execution_count AS avg_cpu_cost, plan_handle,    execution_count,    (SELECT SUBSTRING(text, statement_start_of
  • Myeclipse项目无法部署，Undefined exploded archive location 7454103 eclipseMyEclipse
    做个备忘！ 错误信息为：       Undefined exploded archive location 原因：           在工程转移过程中，导致工程的配置文件出错； 解决方法：    
  • GMT时间格式转换 adminjun GMT时间转换
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 1、可以使用 SimpleDateFormat SimpleDateFormat    EEE-三位星期 d-天 MMM-月 yyyy-四位年
  • Oracle数据库新装连接串问题 aijuans oracle数据库
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： Fatal NI connect error 12170.   VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
  • 回顾java数组复制 ayaoxinchao java数组
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
  • java web会话监听并使用spring注入 bewithme Java Web
            在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。        import java.util.ArrayList; import java.ut
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用) bijian1013 redis数据库NoSQL
    一 .Redis常用命令         Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。         a.键值相关命令         b.服务器相关命令 1.键值相关命令       &
  • java枚举序列化问题 bingyingao java枚举序列化
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 1.加一个枚举值 新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 2.删一个枚举值 新机器代码读分布式缓存中老对象，反序列
  • 【Spark七十八】Spark Kyro序列化 bit1129 spark
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 Spark
  • Hybridizing OO and Functional Design bookjovi erlanghaskell
      推荐博文： Tell Above, and Ask Below - Hybridizing OO and Functional Design 文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
  • Java-Collections Framework学习与总结-HashMap BrokenDreams Collections
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。  &nb
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请 * bylijinnan */ abstract class Handler { /*
  • Android中启动外部程序 cherishLC android
    1、启动外部程序 引用自： http://blog.csdn.net/linxcool/article/details/7692374 //方法一 Intent intent=new Intent(); //包名 包名+类名（全路径） intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
  • summary_keep_rate coollyj SUM
    BEGIN /*DECLARE minDate varchar(20) ; DECLARE maxDate varchar(20) ;*/ DECLARE stkDate varchar(20) ; DECLARE done int default -1; /* 游标中 注册服务器地址 */ DE
  • hadoop hdfs 添加数据目录出错 daizj hadoophdfs扩容
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
  • grep 目录级联查找 dongwei_6688 grep
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： grep -n -r "GET" .   上面的命令将会找出当前目录“.”及当前目录中所有下级目录
  • yii 修改模块使用的布局文件 dcj3sjt126com yiilayouts
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如: 'theme'=>'mythm', 那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件； 如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
  • 设计模式之单例模式 come_for_dream 设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。   *********************************
  • 8、数组 豆豆咖啡 二维数组数组一维数组
      一、概念       数组是同一种类型数据的集合。其实数组就是一个容器。   二、好处       可以自动给数组中的元素从0开始编号，方便操作这些元素   三、格式   //一维数组 1,元素类型[] 变量名 = new 元素类型[元素的个数] int[] arr =
  • Decode Ways hcx2013 decode
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 Given an encoded message containing digits, det
  • Spring4.1新特性——异步调度和事件机制的异常处理 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • squid3(高命中率)缓存服务器配置 liyonghui160com
        系统:centos 5.x   需要的软件:squid-3.0.STABLE25.tar.gz 1.下载squid wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz tar zxf squid-3.0.STABLE25.tar.gz &&
  • 避免Java应用中NullPointerException的技巧和最佳实践 pda158 java
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。 　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 Object unk
  • 如何在Swift语言中创建http请求 shoothao httpswift
    概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。 如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 在这里,我将作出一些建议来回答上述问题。常见的
  • Spring事务的传播方式 uule spring事务
    传播方式：        新建事务       required       required_new   - 挂起当前         非事务方式运行       supports   &nbs
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他