【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的注释：

这样是好事还是坏事，大家自行体会。。。。。个人第一次看到的时候着实被震惊了。
  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的接入步骤如下：

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

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

消息队列模型

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

按照消息类型，商用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相同（例如同一设备）的消
  • Hadoop(一) 朱辉辉33 hadooplinux
    今天在诺基亚第一天开始培训大数据，因为之前没接触过Linux，所以这次一起学了，任务量还是蛮大的。 首先下载安装了Xshell软件，然后公司给了账号密码连接上了河南郑州那边的服务器，接下来开始按照给的资料学习，全英文的，头也不讲解，说锻炼我们的学习能力，然后就开始跌跌撞撞的自学。这里写部分已经运行成功的代码吧.    在hdfs下，运行hadoop fs -mkdir /u
  • maven An error occurred while filtering resources blackproof maven报错
    转：http://stackoverflow.com/questions/18145774/eclipse-an-error-occurred-while-filtering-resources   maven报错： maven An error occurred while filtering resources   Maven -> Update Proje
  • jdk常用故障排查命令 daysinsun jvm
    linux下常见定位命令： 1、jps      输出Java进程       -q       只输出进程ID的名称，省略主类的名称；       -m      输出进程启动时传递给main函数的参数；     &nb
  • java 位移运算与乘法运算 周凡杨 java位移运算乘法
      对于 JAVA 编程中，适当的采用位移运算，会减少代码的运行时间，提高项目的运行效率。这个可以从一道面试题说起：     问题： 用最有效率的方法算出2 乘以8 等於几?” 答案：2 << 3 由此就引发了我的思考，为什么位移运算会比乘法运算更快呢？其实简单的想想，计算机的内存是用由 0 和 1 组成的二
  • java中的枚举(enmu) g21121 java
    从jdk1.5开始，java增加了enum(枚举)这个类型，但是大家在平时运用中还是比较少用到枚举的，而且很多人和我一样对枚举一知半解，下面就跟大家一起学习下enmu枚举。先看一个最简单的枚举类型，一个返回类型的枚举： public enum ResultType { /** * 成功 */ SUCCESS, /** * 失败 */ FAIL,
  • MQ初级学习 510888780 activemq
    1.下载ActiveMQ 去官方网站下载：http://activemq.apache.org/ 2.运行ActiveMQ 解压缩apache-activemq-5.9.0-bin.zip到C盘，然后双击apache-activemq-5.9.0-\bin\activemq-admin.bat运行ActiveMQ程序。 启动ActiveMQ以后，登陆：http://localhos
  • Spring_Transactional_Propagation 布衣凌宇 springtransactional
    //事务传播属性 @Transactional(propagation=Propagation.REQUIRED)//如果有事务，那么加入事务，没有的话新创建一个 @Transactional(propagation=Propagation.NOT_SUPPORTED)//这个方法不开启事务 @Transactional(propagation=Propagation.REQUIREDS_N
  • 我的spring学习笔记12-idref与ref的区别 aijuans spring
    idref用来将容器内其他bean的id传给<constructor-arg>/<property>元素，同时提供错误验证功能。例如： <bean id ="theTargetBean" class="..." /> <bean id ="theClientBean" class=&quo
  • Jqplot之折线图 antlove jsjqueryWebtimeseriesjqplot
    timeseriesChart.html <script type="text/javascript" src="jslib/jquery.min.js"></script> <script type="text/javascript" src="jslib/excanvas.min.js&
  • JDBC中事务处理应用 百合不是茶 javaJDBC编程事务控制语句
      解释事务的概念; 事务控制是sql语句中的核心之一;事务控制的作用就是保证数据的正常执行与异常之后可以恢复   事务常用命令:             Commit提交         
  • [转]ConcurrentHashMap Collections.synchronizedMap和Hashtable讨论 bijian1013 java多线程线程安全HashMap
    在Java类库中出现的第一个关联的集合类是Hashtable，它是JDK1.0的一部分。 Hashtable提供了一种易于使用的、线程安全的、关联的map功能，这当然也是方便的。然而，线程安全性是凭代价换来的――Hashtable的所有方法都是同步的。此时，无竞争的同步会导致可观的性能代价。Hashtable的后继者HashMap是作为JDK1.2中的集合框架的一部分出现的，它通过提供一个不同步的
  • ng-if与ng-show、ng-hide指令的区别和注意事项 bijian1013 JavaScriptAngularJS
            angularJS中的ng-show、ng-hide、ng-if指令都可以用来控制dom元素的显示或隐藏。ng-show和ng-hide根据所给表达式的值来显示或隐藏HTML元素。当赋值给ng-show指令的值为false时元素会被隐藏，值为true时元素会显示。ng-hide功能类似，使用方式相反。元素的显示或
  • 【持久化框架MyBatis3七】MyBatis3定义typeHandler bit1129 TypeHandler
    什么是typeHandler? typeHandler用于将某个类型的数据映射到表的某一列上，以完成MyBatis列跟某个属性的映射   内置typeHandler MyBatis内置了很多typeHandler，这写typeHandler通过org.apache.ibatis.type.TypeHandlerRegistry进行注册，比如对于日期型数据的typeHandler，
  • 上传下载文件rz,sz命令 bitcarter linux命令rz
    刚开始使用rz上传和sz下载命令： 因为我们是通过secureCRT终端工具进行使用的所以会有上传下载这样的需求： 我遇到的问题： sz下载A文件10M左右，没有问题 但是将这个文件A再传到另一天服务器上时就出现传不上去，甚至出现乱码，死掉现象，具体问题 解决方法： 上传命令改为;rz -ybe 下载命令改为：sz -be filename 如果还是有问题： 那就是文
  • 通过ngx-lua来统计nginx上的虚拟主机性能数据 ronin47 ngx-lua　统计 解禁ip
    介绍 以前我们为nginx做统计,都是通过对日志的分析来完成.比较麻烦,现在基于ngx_lua插件,开发了实时统计站点状态的脚本,解放生产力.项目主页: https://github.com/skyeydemon/ngx-lua-stats 功能 支持分不同虚拟主机统计, 同一个虚拟主机下可以分不同的location统计. 可以统计与query-times request-time
  • java-68-把数组排成最小的数。一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的。例如输入数组{32, 321}，则输出32132 bylijinnan java
    import java.util.Arrays; import java.util.Comparator; public class MinNumFromIntArray { /** * Q68输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。 * 例如输入数组{32, 321}，则输出这两个能排成的最小数字32132。请给出解决问题
  • Oracle基本操作 ccii Oracle SQL总结Oracle SQL语法Oracle基本操作Oracle SQL
    一、表操作 1. 常用数据类型 NUMBER(p,s)：可变长度的数字。p表示整数加小数的最大位数，s为最大小数位数。支持最大精度为38位 NVARCHAR2(size)：变长字符串，最大长度为4000字节（以字符数为单位） VARCHAR2(size)：变长字符串，最大长度为4000字节（以字节数为单位） CHAR(size)：定长字符串，最大长度为2000字节，最小为1字节，默认
  • [强人工智能]实现强人工智能的路线图 comsci 人工智能
        1：创建一个用于记录拓扑网络连接的矩阵数据表      2:自动构造或者人工复制一个包含10万个连接(1000*1000)的流程图      3：将这个流程图导入到矩阵数据表中      4：在矩阵的每个有意义的节点中嵌入一段简单的
  • 给Tomcat，Apache配置gzip压缩(HTTP压缩)功能 cwqcwqmax9 apache
    背景： HTTP 压缩可以大大提高浏览网站的速度，它的原理是，在客户端请求网页后，从服务器端将网页文件压缩，再下载到客户端，由客户端的浏览器负责解压缩并浏览。相对于普通的浏览过程HTML ,CSS,Javascript , Text ，它可以节省40%左右的流量。更为重要的是，它可以对动态生成的，包括CGI、PHP , JSP , ASP , Servlet,SHTML等输出的网页也能进行压缩，
  • SpringMVC and Struts2 dashuaifu struts2springMVC
    SpringMVC VS Struts2 1: spring3开发效率高于struts 2: spring3 mvc可以认为已经100%零配置 3: struts2是类级别的拦截， 一个类对应一个request上下文， springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应 所以说从架构本身上 spring3 mvc就容易实现r
  • windows常用命令行命令 dcj3sjt126com windowscmdcommand
    在windows系统中，点击开始－运行，可以直接输入命令行，快速打开一些原本需要多次点击图标才能打开的界面，如常用的输入cmd打开dos命令行，输入taskmgr打开任务管理器。此处列出了网上搜集到的一些常用命令。winver 检查windows版本 wmimgmt.msc 打开windows管理体系结构(wmi) wupdmgr windows更新程序 wscrip
  • 再看知名应用背后的第三方开源项目 dcj3sjt126com ios
    知名应用程序的设计和技术一直都是开发者需要学习的，同样这些应用所使用的开源框架也是不可忽视的一部分。此前《 iOS第三方开源库的吐槽和备忘》中作者ibireme列举了国内多款知名应用所使用的开源框架，并对其中一些框架进行了分析，同样国外开发者 @iOSCowboy也在博客中给我们列出了国外多款知名应用使用的开源框架。另外txx's blog中详细介绍了 Facebook Paper使用的第三
  • Objective-c单例模式的正确写法 jsntghf 单例iosiPhone
    一般情况下，可能我们写的单例模式是这样的： #import <Foundation/Foundation.h> @interface Downloader : NSObject + (instancetype)sharedDownloader; @end #import "Downloader.h" @implementation
  • jquery easyui datagrid 加载成功，选中某一行 hae jqueryeasyuidatagrid数据加载
    1.首先你需要设置datagrid的onLoadSuccess $( '#dg' ).datagrid({onLoadSuccess :  function (data){      $( '#dg' ).datagrid( 'selectRow' ,3); }});   2.onL
  • jQuery用户数字打分评价效果 ini JavaScripthtmljqueryWebcss
    效果体验：http://hovertree.com/texiao/jquery/5.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>jQuery用户数字打分评分代码 - HoverTree</
  • mybatis的paramType kerryg DAOsql
    MyBatis传多个参数： 1、采用#{0},#{1}获得参数：    Dao层函数方法：     public User selectUser(String name,String area); 对应的Mapper.xml    <select id="selectUser" result
  • centos 7安装mysql5.5 MrLee23 centos
    首先centos7 已经不支持mysql，因为收费了你懂得，所以内部集成了mariadb，而安装mysql的话会和mariadb的文件冲突，所以需要先卸载掉mariadb，以下为卸载mariadb，安装mysql的步骤。   #列出所有被安装的rpm package rpm -qa | grep mariadb   #卸载 rpm -e mariadb-libs-5.
  • 利用thrift来实现消息群发 qifeifei thrift
               Thrift项目一般用来做内部项目接偶用的，还有能跨不同语言的功能，非常方便，一般前端系统和后台server线上都是3个节点，然后前端通过获取client来访问后台server，那么如果是多太server，就是有一个负载均衡的方法，然后最后访问其中一个节点。那么换个思路，能不能发送给所有节点的server呢，如果能就
  • 实现一个sizeof获取Java对象大小 teasp javaHotSpot内存对象大小sizeof
       由于Java的设计者不想让程序员管理和了解内存的使用，我们想要知道一个对象在内存中的大小变得比较困难了。本文提供了可以获取对象的大小的方法，但是由于各个虚拟机在内存使用上可能存在不同，因此该方法不能在各虚拟机上都适用，而是仅在hotspot 32位虚拟机上，或者其它内存管理方式与hotspot 32位虚拟机相同的虚拟机上 适用。     
  • SVN错误及处理 xiangqian0505 SVN提交文件时服务器强行关闭
    在SVN服务控制台打开资源库“SVN无法读取current” ---摘自网络 写道 SVN无法读取current修复方法 Can't read file : End of file found 文件：repository/db/txn_current、repository/db/current   其中current记录当前最新版本号，txn_current记录版本库中版本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他