RocketMQ(二)：基础API

Spring源码系列文章

RocketMQ(一)：基本概念和环境搭建

RocketMQ(二)：基础API

目录

  • 一、RocketMQ快速入门
    • 1、生产者发送消息
    • 2、消费者接受消息
    • 3、代理者位点和消费者位点
  • 二、消费模型特点
    • 1、同一个消费组的不同消费者，订阅主题必须相同
    • 2、不同消费者组订阅同一主题，都会收到一份消息
    • 3、消费者组内负载均衡模式，消费者固定队列接收消息
    • 4、消费模式
  • 三、发送不同类型消息
    • 1、发送同步消息
    • 2、发送异步消息
    • 3、发送单向消息
    • 4、发送延迟消息
    • 5、发送批量消息
    • 6、发送顺序消息
    • 7、发送带标签的消息
    • 8、发送带key的消息

一、RocketMQ快速入门

pom.xml

<!-- 原生的api   -->
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.9.2</version>
</dependency>

1、生产者发送消息

@Test
public void simpleProducer() throws Exception {
    // 创建一个生产者  (制定一个组名)
    DefaultMQProducer producer = new DefaultMQProducer("test-producer-group");
    // 连接namesrv
    producer.setNamesrvAddr("localhost:9876");
    // 启动
    producer.start();
    // 创建一个消息
    Message message = new Message("testTopic", "我是一个简单的消息".getBytes());
    // 发送消息
    SendResult sendResult = producer.send(message);
    // 这是个同步消息，所以这里可以拿到消息的消费状态
    System.out.println(sendResult.getSendStatus());
    // 关闭生产者
    producer.shutdown();
}
  • dashboard客户端界面，查看主题界面可以看到刚刚创建的testTopic主题

在这里插入图片描述

  • 如下状态按钮进入的页面，默认四个队列，目前队列1有一条消息未消费

在这里插入图片描述

  • 如下CONSUMER(消费者)管理按钮进入的页面，目前还没创建消费者

在这里插入图片描述

2、消费者接受消息

  • 消费监听MessageListenerConcurrently是多线程消费，默认20个线程
  • 返回消费状态RECONSUME_LATER、报错、null
    • 消息会重新回到队列，之后重试发送给消费者
@Test
public void testConsumer() throws Exception {
    // 创建默认消费者组
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("test-consumer-group");
    // 设置nameServer地址
    consumer.setNamesrvAddr("localhost:9876");
    // 订阅一个主题来消费   *表示没有过滤参数 表示这个主题的任何消息
    consumer.subscribe("testTopic", "*");
    // 注册一个消费监听 MessageListenerConcurrently 是多线程消费，默认20个线程，可以参看consumer.setConsumeThreadMax()
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                        ConsumeConcurrentlyContext context) {
            System.out.println(Thread.currentThread().getName() + "----" + msgs);
            // 返回消费的状态 如果是CONSUME_SUCCESS 则成功，若为RECONSUME_LATER则该条消息会被重回队列，重新被投递
            // 重试的时间为messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
            // 也就是第一次1s 第二次5s 第三次10s  ....  如果重试了18次 那么这个消息就会被终止发送给消费者
			// return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    // 这个start一定要写在registerMessageListener下面
    consumer.start();
    System.in.read();
}
  • 状态栏这里记录的是生产者发送的条数，所以这里没有变化

在这里插入图片描述

  • CONSUMER(消费者)管理栏记录消费的情况

在这里插入图片描述

3、代理者位点和消费者位点

  • 生产者发送10条消息，消费者还没接受，则是如下

在这里插入图片描述

  • 以队列2为例
  • 在队列中，生产者发送一个消息，代理者位点，向左移动一位
  • 消费者接收一个消息，消费者位点，向左移动一位，如果消费者异常，则不移动，之后还会给消费者再发此消息
  • 差值则是代理者位点减去消费者位点，也就是等待发送给消费者的消息数量

在这里插入图片描述

  • 开启消费者将消息全部接收后，差值为0

在这里插入图片描述

二、消费模型特点

1、同一个消费组的不同消费者，订阅主题必须相同

  • 如果订阅主题不同，那么两个消费者将接收不到来自不同主题的的消息
  • 只有关闭其中一个消费者，另外一个消费者就能正常运行了

在这里插入图片描述

2、不同消费者组订阅同一主题，都会收到一份消息

  • 订阅的消费者组一定会收到消息，但是具体的消费者不一样可以收到
  • 消费者组的策略
    • 负载均衡模式：同一组内消费者轮训获取到消息
    • 广播模式：同一组内消费者都能获取到消息

在这里插入图片描述

3、消费者组内负载均衡模式，消费者固定队列接收消息

  • 如果有c1/c2两个消费者，4个通道，那么c1只接收0/1队列的消息，c2只接收2/3队列的消息
  • 也就是系统会给消费者尽量平均分配可以接收的队列，没有分配的队列消息不会接收
  • 如果消费者多，那么多出来的消费者永远接收不到消息

在这里插入图片描述

4、消费模式

  • MQ的消费模式可以大致分为两种，一种是推Push，一种是拉Pull
  • Push是服务端【MQ】主动推送消息给客户端
    • 优点是及时性较好
    • 但如果客户端没有做好流控，一旦服务端推送大量消息到客户端时，就会导致客户端消息堆积甚至崩溃
  • Pull是客户端需要主动到服务端取数据
    • 优点是客户端可以依据自己的消费能力进行消费
    • 但拉取的频率也需要用户自己控制，拉取频繁容易造成服务端和客户端的压力，拉取间隔长又容易造成消费不及时
  • Push模式也是基于Pull模式的，只是客户端内部封装了api（长轮训方式）
    • 一般场景下，上游消息生产量小或者均速的时候，选择push模式
    • 在特殊场景下，例如电商大促，抢优惠券等场景可以选择pull模式

三、发送不同类型消息

1、发送同步消息

  • 上面的快速入门就是发送同步消息
  • 发送过后会有一个返回值，也就是mq服务器接收到消息后返回的一个确认
  • 这种方式非常安全，但是性能上并没有这么高
  • 而且在mq集群中，也是要等到所有的从机都复制了消息以后才会返回
  • 针对重要的消息可以选择这种方式

在这里插入图片描述

2、发送异步消息

  • 异步消息通常用在对响应时间敏感的业务场景
  • 即发送端不能容忍长时间地等待Broker的响应
  • 发送完以后会有一个异步消息通知
    • 与同步发送相比，send方法没有返回值
    • 通过回调接口SendCallback获取发送成功还是失败
@Test
public void asyncProducer() throws Exception {
    DefaultMQProducer producer = new DefaultMQProducer("async-producer-group");
    producer.setNamesrvAddr("localhost:9876");
    producer.start();
    Message message = new Message("asyncTopic", "我是一个异步消息".getBytes());
    producer.send(message, new SendCallback() {
        @Override
        public void onSuccess(SendResult sendResult) {
            System.out.println("发送成功");
        }

        @Override
        public void onException(Throwable e) {
            System.err.println("发送失败:" + e.getMessage());
        }
    });
    System.out.println("我先执行");
    System.in.read();
}

执行结果：

我先执行
发送成功
  • 因为是异步，所以发送消息后，不论成功失败，继续往下走，执行“我先发送”
  • 之后消费发送成功，回调函数执行“发送成功”

3、发送单向消息

  • 这种方式主要用在不关心发送结果的场景
  • 这种方式吞吐量很大，但是存在消息丢失的风险
  • 例如日志信息的发送
@Test
public void onewayProducer() throws Exception {
    DefaultMQProducer producer = new DefaultMQProducer("oneway-producer-group");
    producer.setNamesrvAddr("localhost:9876");
    producer.start();
    Message message = new Message("onewayTopic", "日志xxx".getBytes());
    producer.sendOneway(message);
    System.out.println("成功");
    producer.shutdown();
}

4、发送延迟消息

  • 消息放入mq后，过一段时间，才会被监听到，然后消费
  • 比如抢票业务
    • 一个人抢到票，无论付款与否，都发送一个延时消息（车票id，此时状态为占用）
    • 15分钟后， 去处理这里车票id
    • 通过车票id判断是否付款，如果付款则什么都不处理
    • 如果没有付款则将此车票id状态修改位未占用
@Test
public void msProducer() throws Exception {
    DefaultMQProducer producer = new DefaultMQProducer("ms-producer-group");
    producer.setNamesrvAddr(MqConstant.NAME_SRV_ADDR);
    producer.start();
    Message message = new Message("orderMsTopic", "订单号，座位号".getBytes());
    // 给消息设置一个延迟时间
    message.setDelayTimeLevel(3);
    // 发延迟消息
    producer.send(message);
    producer.shutdown();
}
  • 通过message对象设置延迟对象，如下等级对应延迟时间
  • 当然以后springboot项目也可以通过配置文件属性delayTimeLevel自定义时间

在这里插入图片描述

5、发送批量消息

  • 可以一次性发送一组消息
@Test
public void testBatchProducer() throws Exception {
    // 创建默认的生产者
    DefaultMQProducer producer = new DefaultMQProducer("batch-producer-group");
    // 设置nameServer地址
    producer.setNamesrvAddr("localhost:9876");
    // 启动实例
    producer.start();
    List<Message> msgs = Arrays.asList(
            new Message("batchTopic", "我是一组消息的A消息".getBytes()),
            new Message("batchTopic", "我是一组消息的B消息".getBytes()),
            new Message("batchTopic", "我是一组消息的C消息".getBytes())
    );
    SendResult send = producer.send(msgs);
    System.out.println(send);
    // 关闭实例
    producer.shutdown();
}
  • 一组消息都在同一个队列里，排队消费

在这里插入图片描述

  • 一组3个消息，多线程一次消费了三个消息
@Test
public void testBatchConsumer() throws Exception {
    // 创建默认消费者组
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("batch-producer-group");
    // 设置nameServer地址
    consumer.setNamesrvAddr("localhost:9876");
    // 订阅一个主题来消费   表达式，默认是*
    consumer.subscribe("batchTopic", "*");
    // 注册一个消费监听 MessageListenerConcurrently是并发消费
    // 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax()
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs,
                                                        ConsumeConcurrentlyContext context) {
            // 这里执行消费的代码 默认是多线程消费
            System.out.println(Thread.currentThread().getName() + "----" + new String(msgs.get(0).getBody()));
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    consumer.start();
    System.in.read();
}

执行结果：

ConsumeMessageThread_3----我是一组消息的C消息
ConsumeMessageThread_1----我是一组消息的A消息
ConsumeMessageThread_2----我是一组消息的B消息

6、发送顺序消息

  • 消息有序指的是可以按照消息的发送顺序来消费
  • 虽然队列FIFO先入先出，但RocketMQ的broker有四个queue
    • 默认的情况下消息发送会采取轮询方式把消息发送到不同的queue
    • 而消费消息的时候从多个queue上拉取消息
    • 这种情况发送和消费是不能保证顺序
  • 但是如果控制发送的顺序消息只依次发送到同一个queue中
    • 消费的时候只从这个queue上依次拉取，则就保证了顺序
  • 当发送和消费参与的queue只有一个，则是全局有序
  • 如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的

发送顺序消息

  • 两组订单，110订单和120订单
  • 每组需要保证顺序：下订单->物流->签收
  • 发送消息的send方法需要传一个MessageQueueSelector的实现类
  • 实现select方法，返回MessageQueue对象（当前send消息放入哪个队列）
@Test
public void testOrderlyProducer() throws Exception {
    // 创建默认的生产者
    DefaultMQProducer producer = new DefaultMQProducer("test-group");
    // 设置nameServer地址
    producer.setNamesrvAddr("localhost:9876");
    // 启动实例
    producer.start();
    List<Order> orderList = Arrays.asList(
            new Order(1, 110, "下订单"),
            new Order(2, 110, "物流"),
            new Order(3, 110, "签收"),
            
            new Order(4, 120, "下订单"),
            new Order(5, 120, "物流"),
            new Order(6, 120, "拒收")
    );
    // 循环集合开始发送
    orderList.forEach(order -> {
        Message message = new Message("TopicTest", order.toString().getBytes());
        try {
            // 发送的时候 相同的订单号选择同一个队列
            producer.send(message, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    // 当前主题有多少个队列
                    int queueNumber = mqs.size();
                    // 这个arg就是后面传入的 order.getOrderNumber()
                    Integer i = (Integer) arg;
                    // 用这个值去%队列的个数得到一个队列
                    int index = i % queueNumber;
                    // 返回选择的这个队列即可 ，那么相同的订单号 就会被放在相同的队列里 实现FIFO了
                    return mqs.get(index);
                }
            }, order.getOrderNumber());
        } catch (Exception e) {
            System.out.println("发送异常");
        }
    });
    // 关闭实例
    producer.shutdown();
}

接收顺序消息

  • 因为要顺序消费，所以不能用默认的MessageListenerConcurrently多线程消费
  • 这里需要用到MessageListenerOrderly单线程消费
@Test
public void testOrderlyConsumer() throws Exception {
    // 创建默认消费者组
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer-group");
    // 设置nameServer地址
    consumer.setNamesrvAddr("localhost:9876");
    // 订阅一个主题来消费   *表示没有过滤参数 表示这个主题的任何消息
    consumer.subscribe("TopicTest", "*");
    // 注册一个消费监听 MessageListenerOrderly 是顺序消费 单线程消费
    consumer.registerMessageListener(new MessageListenerOrderly() {
        @Override
        public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
            MessageExt messageExt = msgs.get(0);
            System.out.println(new String(messageExt.getBody()));
            return ConsumeOrderlyStatus.SUCCESS;
        }
    });
    consumer.start();
    System.in.read();
}

7、发送带标签的消息

  • RocketMQ提供消息过滤功能，通过tag进行区分
  • 订阅关系一致：同一个消费者组下所有消费者实例所订阅的Topic、Tag必须完全一致
  • 我们往一个主题里面发送消息的时候，根据业务逻辑，可能需要区分
  • 比如带有tagA标签的被A消费，带有tagB标签的被B消费

生产者发送标签消息（同一个主题，不同的标签）

@Test
public void tagProducer() throws Exception {
    DefaultMQProducer producer = new DefaultMQProducer("tag-producer-group");
    producer.setNamesrvAddr("localhost:9876");
    producer.start();
    Message message = new Message("tagTopic", "vip1", "我是vip1的文章".getBytes());
    Message message2 = new Message("tagTopic", "vip2", "我是vip2的文章".getBytes());
    producer.send(message);
    producer.send(message2);
    System.out.println("发送成功");
    producer.shutdown();
}
  • 消费者组a只监听主题为tagTopic，标签为vip1
  • subscribe订阅方法第二个参数，默认*监听所有的标签
@Test
public void tagConsumer1() throws Exception {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("tag-consumer-group-a");
    consumer.setNamesrvAddr("localhost:9876");
    consumer.subscribe("tagTopic", "vip1");
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
            System.out.println("我是vip1的消费者，我正在消费消息" + new String(msgs.get(0).getBody()));
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    consumer.start();
    System.in.read();
}
  • 消费者组b监听主题为tagTopic，标签为vip1或vip2
@Test
public void tagConsumer2() throws Exception {
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("tag-consumer-group-b");
    consumer.setNamesrvAddr("localhost:9876");
    consumer.subscribe("tagTopic", "vip1 || vip2");
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
            System.out.println("我是vip2的消费者，我正在消费消息" + new String(msgs.get(0).getBody()));
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    consumer.start();
    System.in.read();
}

什么时候该用 Topic，什么时候该用 Tag？

总结：不同的业务应该使用不同的Topic如果是相同的业务里面有不同表的表现形式，那么我们要使用tag进行区分

可以从以下几个方面进行判断：

  1. 消息类型是否一致：如普通消息、事务消息、定时（延时）消息、顺序消息，不同的消息类型使用不同的 Topic，无法通过 Tag 进行区分
  2. 业务是否相关联：没有直接关联的消息，如淘宝交易消息，京东物流消息使用不同的 Topic 进行区分；而同样是天猫交易消息，电器类订单、女装类订单、化妆品类订单的消息可以用 Tag 进行区分
  3. 消息优先级是否一致：如同样是物流消息，盒马必须小时内送达，天猫超市 24 小时内送达，淘宝物流则相对会慢一些，不同优先级的消息用不同的 Topic 进行区分。
  4. 消息量级是否相当：有些业务消息虽然量小但是实时性要求高，如果跟某些万亿量级的消息使用同一个 Topic，则有可能会因为过长的等待时间而“饿死”，此时需要将不同量级的消息进行拆分，使用不同的 Topic

通常情况下，不同的 Topic 之间的消息没有必然的联系，而 Tag 则用来区分同一个 Topic 下相互关联的消息

8、发送带key的消息

  • 在rocketmq中的消息，默认会有一个messageId当做消息的全局唯一标识

在这里插入图片描述

  • 我们也可以给消息携带一个key，用作业务唯一标识
  • 如果发送两次相同内容消息
    • 业务唯一标识key肯定一样，可以阻止重复消费
    • 但是上面默认的messageId则不一样，这样则无法区分重复数据

带key消息生产者

@Test
public void testKeyProducer() throws Exception {
    // 创建默认的生产者
    DefaultMQProducer producer = new DefaultMQProducer("test-group");
    // 设置nameServer地址
    producer.setNamesrvAddr("localhost:9876");
    // 启动实例
    producer.start();
    Message msg = new Message("TopicTest","我是一个带key的消息".getBytes());
    // 通过Message对象设置key
    String key = UUID.randomUUID().toString();
    msg.setKeys(key);
    SendResult send = producer.send(msg);
    System.out.println(send);
    // 关闭实例
    producer.shutdown();
}

带key消息消费者（从MessageExt对象中获取key）

@Test
public void testKeyConsumer() throws Exception {
    // 创建默认消费者组
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer-group");
    // 设置nameServer地址
    consumer.setNamesrvAddr("localhost:9876");
    // 订阅一个主题来消费 
    consumer.subscribe("TopicTest","*");
    // 注册一个消费监听 MessageListenerConcurrently是并发消费
    // 默认是20个线程一起消费，可以参看 consumer.setConsumeThreadMax()
    consumer.registerMessageListener(new MessageListenerConcurrently() {
        @Override
        public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
            MessageExt messageExt = msgs.get(0);
            // 从MessageExt对象获取key
            System.out.println("key值: " + messageExt.getKeys());
            System.out.println("消息体: " + new String(messageExt.getBody()));
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
    });
    consumer.start();
    System.in.read();
}

根据主题和key查询消息

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/145632.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

伊朗黑客对以色列科技行业发起恶意软件攻击

伊朗黑客对以色列科技行业发起恶意软件攻击

最近&#xff0c;安全研究人员发现了一场由“Imperial Kitten”发起的新攻击活动&#xff0c;目标是运输、物流和科技公司。 “Imperial Kitten”又被称为“Tortoiseshell”、“TA456”、“Crimson Sandstorm”和“Yellow Liderc”&#xff0c;多年来一直使用“Marcella Flore…
阅读更多...
加密磁盘密钥设置方案浅析 — LUKS1

加密磁盘密钥设置方案浅析 — LUKS1

虚拟化加密磁盘密钥设置方案浅析 前言元数据分析元数据格式整体格式头部格式加密算法密码校验key slot格式其它字段 流程验证 前言 我们在虚拟化加密磁盘密钥设置方案浅析 — TKS1中介绍了加密磁盘密钥设置方案&#xff0c;TKS1对密钥设置(Linux Unified Key Setup)的流程和方…
阅读更多...
模拟散列表（哈希表拉链法）

模拟散列表（哈希表拉链法）

维护一个集合&#xff0c;支持如下几种操作&#xff1a; I x&#xff0c;插入一个整数 x&#xff1b;Q x&#xff0c;询问整数 x 是否在集合中出现过&#xff1b; 现在要进行 N 次操作&#xff0c;对于每个询问操作输出对应的结果。 输入格式 第一行包含整数 N&#xff0c;…
阅读更多...
举报“将我的电脑控作己用者”！

举报“将我的电脑控作己用者”！

既然“麻辣800727”都说是“街子电信”干的&#xff0c;那么&#xff0c;我现在就正式举报&#xff1a;请依法管理宽带网&#xff0c;你国营的也不可以随意侵犯用户的人权&#xff0c;更不可以将自己变成法外之地&#xff01; 请公开答复&#xff0c;并改正&#xff0c;否则把…
阅读更多...
机器学习线性代数知识补充

机器学习线性代数知识补充

线性代数知识补充 正交矩阵与正交变换方阵特征值与特征向量相似矩阵对角化二次型正定二次型 正交矩阵与正交变换 方阵特征值与特征向量 相似矩阵 对角化 二次型 正定二次型
阅读更多...
H5游戏源码分享-超级染色体小游戏

H5游戏源码分享-超级染色体小游戏

H5游戏源码分享-超级染色体小游戏 游戏玩法 不断地扩大发展同颜色的色块 用最少的步数完成游戏 <!DOCTYPE html> <html><head><meta charset"UTF-8"><meta name"viewport"content"widthdevice-width,user-scalableno,init…
阅读更多...
应届裁员，天胡开局——谈谈我的前端一年经历

应届裁员，天胡开局——谈谈我的前端一年经历

应届裁员&#xff0c;天胡开局——谈谈我的前端一年经历 许久没有更新了&#xff0c;最近一个月都在忙&#xff0c;没错&#xff0c;正如题目所说&#xff0c;裁员然后找工作… 这周刚重新上班&#xff0c;工作第二天&#xff0c;感慨良多&#xff0c;记录些什么吧。 去年十…
阅读更多...
学习samba

学习samba

文章目录 一、samba介绍二、samba的主要进程三、配置文件四、例子 一、samba介绍 1、SMB&#xff08;Server Message Block&#xff09;协议实现文件共享&#xff0c;也称为CIFS&#xff08;Common Internet File System&#xff09;。 2、是Windows和类Unix系统之间共享文件的…
阅读更多...
【Linux】gitee仓库的注册使用以及在Linux上远程把代码上传到gitee上的方法

【Linux】gitee仓库的注册使用以及在Linux上远程把代码上传到gitee上的方法

君兮_的个人主页 即使走的再远&#xff0c;也勿忘启程时的初心 C/C 游戏开发 Hello,米娜桑们&#xff0c;这里是君兮_&#xff0c;今天为大家介绍一个在实际工作以及项目开发过程中非常实用的网站gitee&#xff0c;并教如何正确的使用这个网站以及常见问题的解决方案&#xf…
阅读更多...
java基础-数据类型

java基础-数据类型

1、变量 变量就是申请内存来存储值。也就是说&#xff0c;当创建变量的时候&#xff0c;需要在内存中申请空间。 内存管理系统根据变量的类型为变量分配存储空间&#xff0c;分配的空间只能用来储存该类型数据。 因此&#xff0c;通过定义不同类型的变量&#xff0c;可以在内…
阅读更多...
MySQL主主复制

MySQL主主复制

主1 192.168.66.15 主2 192.168.66.16 主1&#xff1a; roottest2 ~]# hostname master1 [roottest2 ~]# bash [rootmaster1 ~]# vim /etc/my.cnf server-id11 log-binmysql-bin auto_increment_increment2 auto_increment_offset1 replicate-do-dbdemo_db …
阅读更多...
appium+python自动化测试

appium+python自动化测试

获取APP的包名 1、aapt即Android Asset Packaging Tool&#xff0c;在SDK的build-tools目录下。该工具可以查看apk包名和launcherActivity 2、在android-sdk里面双击SDK-manager,下载buidl-tools 3、勾选build-tools&#xff0c;随便选一个版本&#xff0c;我这里选的是24的版…
阅读更多...
ESP32/ESP8266基于Arduino框架下驱动1.8“tft_oled屏幕仿数码管时钟

ESP32/ESP8266基于Arduino框架下驱动1.8“tft_oled屏幕仿数码管时钟

ESP32/ESP8266基于Arduino框架下驱动1.8"tft_oled屏幕仿数码管时钟 &#x1f4cd;相关篇《ESP32基于Arduino框架下U8g2驱动I2C OLED 时间显示》&#x1f4fa;效果演示&#xff1a; &#x1f33f;屏幕显示部分&#xff0c;采用使用TFT_eSPI库驱动&#xff0c;利用该库自带的…
阅读更多...
【SQLite】的使用及指令| 编程操作(增删改查)

【SQLite】的使用及指令| 编程操作(增删改查)

一、SQLite 使用和指令集 SQLite 的基本使用SQL 命令 二、常见的 SQL 数据类型 三、SQLite的命令用法 四、SQLite的编程操作 五、sqlite3_open函数 六、sqlite3_close函数 七、sqlite3_errcode函数 八、SQLite C Interface 九、sqlite3_exec函数 十、callback回调函数 十一、…
阅读更多...
vue：如何把后端传过来的数组的其中一个对象加入新的属性

vue：如何把后端传过来的数组的其中一个对象加入新的属性

加入我们是更改数组中的第一个对象&#xff0c;在vue中可以使用$set方法将属性插入到第一个对象中作为属性。 Script部分&#xff1a; <script>export default {data() {return {boxes: [//模拟后端传过来的数组{id:1,name:张三},{id:2,name:李四},{id:3,name:王五},{i…
阅读更多...
香港科技大学广州｜智能制造学域机器人与自主系统学域博士招生宣讲会—中国科学技术大学专场

香港科技大学广州｜智能制造学域机器人与自主系统学域博士招生宣讲会—中国科学技术大学专场

&#x1f3e0;地点&#xff1a;中国科学技术大学西区学生活动中心&#xff08;一楼&#xff09;报告厅 【宣讲会专场1】让制造更高效、更智能、更可持续—智能制造学域 &#x1f559;时间&#xff1a;2023年11月16日&#xff08;星期四&#xff09;18:00 报名链接&#xff1a…
阅读更多...
【SpringBoot篇】使用Spring Cache高效处理缓存数据

【SpringBoot篇】使用Spring Cache高效处理缓存数据

文章目录 &#x1f339;简述Spring Cache&#x1f3f3;️‍&#x1f308;常用注解&#x1f33a;使用SpringCache&#x1f6f8;Cacheable注解⭐测试 &#x1f6f8;CacheEvict&#x1f38d;一次清理一条数据&#x1f38d;一次删除多条数据 Spring Cache是一个框架,只要简单加一个…
阅读更多...
【Mysql】MySQL基于成本的优化

【Mysql】MySQL基于成本的优化

什么是成本 我们之前说 过MySQL 执行一个查询可以有不同的执行方案&#xff0c;它会选择其中成本最低&#xff0c;或者说代价最低的那种方案去真正的执行查询。那么成本是怎么计算的呢&#xff0c;其实在 MySQL 中一条查询语句的执行成本是由下边这两个方面组成的: I/O 成本 …
阅读更多...
数据结构：反射

数据结构：反射

基本概念 反射中的四个类 Class类 Java文件在被编译之后&#xff0c;生成了.class文件&#xff0c;JVM此时解读.class文件&#xff0c;将其解析为java.lang.Class 对象&#xff0c;在程序运行时每个java文件就最终变成了Class类对象的一个实例。通过反射机制应用这个 实例就…
阅读更多...
如何在Qemu上跑Milk-duo开发板

如何在Qemu上跑Milk-duo开发板

前言 &#xff08;1&#xff09;PLCT实验室实习生长期招聘&#xff1a;招聘信息链接 &#xff08;2&#xff09;学习本文之前&#xff0c;要求先看一下Milk-V Duo快速上手的环境搭建部分&#xff0c;创建好镜像文件。 正文 编译milk-duo qemu &#xff08;1&#xff09;下面步…
阅读更多...
最新文章

Copyright @ 2022~2023