微服务学习——服务异步通讯

news2024/9/23 7:26:14

实用篇-RabbitMQ

初识MQ

同步调用的问题

微服务间基于Feign的调用就属于同步方式，存在一些问题。

  1. 耦合度高
    每次加入新的需求，都要修改原来的代码
  2. 性能下降
    调用者需要等待服务提供者响应，如果调用链过长则响应时间等于每次调用的时间之和。
  3. 资源浪费
    调用链中的每个服务在等待响应过程中，不能释放请求占用的资源，高并发场景下会极度浪费系统资源
  4. 级联失败
    如果服务提供者出现问题,所有调用方都会跟着出问题,如同多米诺骨牌一样，迅速导致整个微服务群故障

异步调用方案

异步调用常见实现就是事件驱动模式

1

事件驱动优势

优势一:服务解耦

优势二:性能提升，吞吐量提高

优势三:服务没有强依赖，不担心级联失败问题

优势四:流量削峰

异步通信的缺点:

  • 依赖于Broker的可靠性、安全性、吞吐能力
  • 架构复杂了，业务没有明显的流程线，不好追踪管理

什么是MQ

MQ(MessageQueue)，中文是消息队列，字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

2

RabbitMQ快速入门

RabbitMQ概述

RabbitMQ是基于Erlang语言开发的开源消息通信中间件，官网地址: https://www.rabbitmq.com/

单机部署

下载镜像

方式一：在线拉取

docker pull rabbitmq:3-management

方式二：从本地加载

上传到虚拟机中后，使用命令加载镜像即可：

docker load -i mq.tar

安装MQ

执行下面的命令来运行MQ容器：

docker run \
 -e RABBITMQ_DEFAULT_USER=itcast \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 --name mq \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3-management

RabbitMQ的结构和概念

3

RabbitMQ中的几个概念:

  • channel:操作MQ的工具
  • exchange:路由消息到队列中
  • queue:缓存消息
  • virtual host:虚拟主机，是对queue、exchange等资源的逻辑分组

常见消息模型

MQ的官方文档中给出了5个MQ的Demo示例，对应了几种不同的用法:

  • 基本消息队列(BasicQueue)

  • 工作消息队列( workQueue)

4.1

  • 发布订阅（Publish、Subscribe)，又根据交换机类型不同分为三种:
    • Fanout Exchange:广播
    • Direct Exchange:路由
    • Topic Exchange:主题

4.2

HelloWorld案例

官方的HelloWorld是基于最基础的消息队列模型来实现的，只包括三个角色:

  • publisher:消息发布者，将消息发送到队列queue
  • queue:消息队列，负责接受并缓存消息
  • consumer:订阅队列，处理队列中的消息

5

基本消息队列的消息发送流程:

  1. 建立connection
  2. 创建channel
  3. 利用channel声明队列
  4. 利用channel向队列发送消息
package cn.itcast.mq.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.5.131");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}

基本消息队列的消息接收流程:

  1. 建立connection
  2. 创建channel
  3. 利用channel声明队列
  4. 定义consumer的消费行为handleDelivery()
  5. 利用channel将消费者与队列绑定
package cn.itcast.mq.helloworld;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.5.131");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

SpringAMQP

什么是SpringAMQP

SpringAmqp的官方地址: https://spring.io/projects/spring-amqp

  • AMQP

Advanced Message Queuing Protocol，是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。

  • Spring AMQP

Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现。

  • 案例
    利用SpringAMQP实现HelloWorld中的基础消息队列功能

流程如下:

  1. 在父工程中引入spring-amqp的依赖
  2. 在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列
  3. 在consumer服务中编写消费逻辑，绑定simple.queue这个队列
  • 步骤

步骤1:引入AMQP依赖

因为publisher和consumer服务都需要amqp依赖，因此这里把依赖直接放到父工程mq-demo中:

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

步骤2:在publisher中编写测试方法，向simple.queue发送消息

  1. 在publisher服务中编写application.yml，添加mq连接信息:

    spring:
  rabbitmq:
    host: 192.168.5.131 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /

  2. 在publisher服务中新建一个测试类，编写测试方法:

    package cn.itcast.mq.spring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendMessage2SimpleQueue() {
        String queueName = "simple.queue";
        String message = "hello Spring amqp!";
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

步骤3:在consumer中编写消费逻辑，监听simple.queue

  1. 在consumer服务中编写application.yml，添加mq连接信息:

    spring:
  rabbitmq:
    host: 192.168.5.131 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /

  2. 在consumer服务中新建一个类，编写消费逻辑:

    @Component
public class SpringRabbitListener {
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
    }
}

Work Queue工作队列

work queue，工作队列，可以提高消息处理速度，避免队列消息堆积

多个消费者绑定到一个队列，同一条消息只会被一个消费者处理

6

案例
模拟WorkQueue，实现一个队列绑定多个消费者
基本思路如下:

  1. 在publisher服务中定义测试方法，每秒产生50条消息，发送到simple.queue

    @Test
public void testSendMessage2WorkQueue() throws InterruptedException {
    String queueName = "simple.queue";
    String message = "hello message__";
    for (int i = 1; i < 50; i++) {
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

  2. 在consumer服务中定义两个消息监听者，都监听simple.queue队列

  3. 消费者1每秒处理50条消息，消费者2每秒处理10条消息

    @RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消费者1接收到simple.queue的消息：【" + msg + "】"+ LocalTime.now());
    Thread.sleep(20);
}

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消费者2接收到simple.queue的消息：【" + msg + "】"+LocalTime.now());
    Thread.sleep(200);
}

消费预取限制

修改application.yml文件，设置preFetch这个值，可以控制预取消息的上限

logging:
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
spring:
  rabbitmq:
    host: 192.168.5.131 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

发布( Publish ) 、订阅( Subscribe )

发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者。实现方式是加入了exchange(交换机)。

7

常见exchange类型包括:

  • Fanout：广播
  • Direct：路由
  • Topic：话题

注意：exchange负责消息路由，而不是存储，路由失败则消息丢失

Fanout Exchange

Fanout Exchange会将接收到的消息路由到每一个跟其绑定的queue

案例
利用SpringAMQP演示FanoutExchange的使用
实现思路如下:

  1. 在consumer服务中，利用代码声明队列、交换机，并将两者绑定

    在consumer服务常见一个类，添加@Configuration注解，并声明FanoutExchange、Queue和绑定关系对象Binding，代码如下:

    package cn.itcast.mq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {
    //itcast.fanout
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("itcast.fanout");
    }

    //fanout.queue1
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.queue1");
    }

    //绑定队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
        return BindingBuilder
                .bind(fanoutQueue1)
                .to(fanoutExchange);
    }

    //fanout.queue2
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.queue2");
    }

    //绑定队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
        return BindingBuilder
                .bind(fanoutQueue2)
                .to(fanoutExchange);
    }
}

  2. 在consumer服务中，编写两个消费者方法，分别监听fanout.queue1和fanout.queue2

    @RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
    System.out.println("消费者接收到fanout.queue1的消息：【" + msg + "】");
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
    System.out.println("消费者接收到fanout.queue2的消息：【" + msg + "】");
}

  3. 在publisher中编写测试方法，向itcast.fanout发送消息

    @Test
public void testSendFanoutExchange() {
    //交换机名称
    String exchangeName = "itcast.fanout";
    //消息
    String message = "hello everyone";
    //发送消息
    rabbitTemplate.convertAndSend(exchangeName, "", message);
}

8

DirectExchange

Direct Exchange 会将接收到的消息根据规则路由到指定的Queue，因此称为路由模式（routes)。

9

  • 每一个Queue都与Exchange设置一个BindingKey
  • 发布者发送消息时，指定消息的RoutingKey
  • Exchange将消息路由到BindingKey与消息RoutingKey一致的队列

案例
利用SpringAMQP演示DirectExchange的使用
实现思路如下:

  1. 在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2

  2. 并利用@RabbitListener声明Exchange、Queue、RoutingKey

    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(name= "direct.queue1"),
        exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
        key = {"red","blue"}
))
public void listenDirectQueue1(String msg) {
    System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
}
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name= "direct.queue2"),
        exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
        key = {"red","yellow"}
))
public void listenDirectQueue2(String msg) {
    System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}

  3. 在publisher中编写测试方法，向itcast. direct发送消息

    @Test
public void testSendDirectExchange() {
    //交换机名称
    String exchangeName = "itcast.direct";
    //消息
    String message_blue = "hello blue";
    String message_red = "hello red";
    String message_yellow = "hello yellow";
    //发送消息
    rabbitTemplate.convertAndSend(exchangeName, "blue", message_blue);
    rabbitTemplate.convertAndSend(exchangeName, "red", message_red);
    rabbitTemplate.convertAndSend(exchangeName, "yellow", message_yellow);
}

10

描述下Direct交换机与Fanout交换机的差异?

  • Fanout交换机将消息路由给每一个与之绑定的队列
  • Direct交换机根据RoutingKey判断路由给哪个队列
  • 如果多个队列具有相同的RoutingKey，则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解?

  • @Queue
  • @Exchange

TopicExchange

TopicExchange与DirectExchange类似，区别在于routingKey必须是多个单词的列表，并且以.分割。

Queue与Exchange指定BindingKey时可以使用通配符:

  • #:代指0个或多个单词
  • *:代指一个单词

11

案例
利用SpringAMQP演示TopicExchange的使用
实现思路如下:

  1. 在consumer服务中，编写两个消费者方法，分别监听topIc.queue1和topIc.queue1

  2. 并利用@RabbitListener声明Exchange.Queue、RoutingKey

    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "topic.queue1"),
        exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
        key = "china.#"
))
public void listenTopicQueue1(String msg) {
    System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
}
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "topic.queue2"),
        exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
        key = "#.news"
))
public void listenTopicQueue2(String msg) {
    System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}

  3. 在publisher中编写测试方法，向itcast. topic发送消息）

    @Test
public void testSendTopicExchange() {
    //交换机名称
    String exchangeName = "itcast.topic";
    //消息
    String message_news = "喜报！孙悟空大战哥斯拉，胜!";
    String message_weather = "今天的风儿甚是喧嚣";
    //发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message_news);
    rabbitTemplate.convertAndSend(exchangeName, "china.weather", message_weather);
}

12

运行结果：

13

消息转换器

案例
测试发送Object类型消息

说明:在SpringAMQP的发送方法中，接收消息的类型是Object，也就是说我们可以发送任意对象类型的消息，SpringAMQP会帮我们序列化为字节后发送。

在consumer中利用@Bean声明一个队列:

@Bean
public Queue objectQueue() {
    return new Queue("object.queue");
}

在publisher中发送消息以测试:

//发送对象类型的msg
@Test
public void testSendObjectQueue() {
    Map<String, Object> msg = new HashMap<>();
    msg.put("name", "张三");
    msg.put("age", "18");
    rabbitTemplate.convertAndSend("object.queue", msg);
}

Spring的对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而
默认实现是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。

如果要修改只需要定义一个MessageConverter类型的Bean即可。推荐用JSON方式序列化，步骤如下:

  • 在publisher服务引入依赖（此处直接在父工程引入）

    <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

  • 在publisher服务声明MessageConverter（启动类中定义bean）

    @Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}

接收消息：

  • 在consumer服务引入Jackson依赖（父工程已引入，跳过）

  • 在consumer服务定义MessageConverter

    @Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}

  • 然后定义一个消费者，监听object.queue队列并消费消息

    //接收object类型的msg
@RabbitListener(queues = "object.queue")
public void listenObjectQueue(Map<String, Object> msg) {
    System.out.println("接收到消息：【" + msg + "】");
}

SpringAMQP中消息的序列化和反序列化是怎么实现的?

  • 利用MessageConverter实现的，默认是JDK的序列化
    cy>

  • 在publisher服务声明MessageConverter（启动类中定义bean）

    @Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}

接收消息：

  • 在consumer服务引入Jackson依赖（父工程已引入，跳过）

  • 在consumer服务定义MessageConverter

    @Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}

  • 然后定义一个消费者，监听object.queue队列并消费消息

    //接收object类型的msg
@RabbitListener(queues = "object.queue")
public void listenObjectQueue(Map<String, Object> msg) {
    System.out.println("接收到消息：【" + msg + "】");
}

SpringAMQP中消息的序列化和反序列化是怎么实现的?

  • 利用MessageConverter实现的，默认是JDK的序列化
  • 注意发送方与接收方必须使用相同的MessageConverter

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【数据库】事务的隔离级别以及实现原理

【数据库】事务的隔离级别以及实现原理

文章目录 前言一、事务什么是事务&#xff1f;事务的四大特性分别是 二、事务并发存在的问题脏读可重复读不可重复读幻读 三、以MYSQL数据库来分析四种隔离级别第一种隔离级别&#xff1a;Read uncommitted(读未提交)第二种隔离级别&#xff1a;Read committed(读提交)第三种隔…
阅读更多...
此环境变量太大，此对话框允许将值设置为最长 2047 个字符

此环境变量太大，此对话框允许将值设置为最长 2047 个字符

背景: 自己是一个计算机爱好者&#xff0c;又大体精通计算机各种编程语言&#xff0c;所以电脑上安装的各种编译或者编程软件比较多&#xff0c;有一天需要安装一个多版本的python环境&#xff0c;发现无法添加环境变量&#xff0c;于是乎&#xff0c;自己去查看原因并解决这个…
阅读更多...
C语言 sizeof, size_t, strlen

C语言 sizeof, size_t, strlen

C语言 sizeof, size_t, strlen 文章目录 C语言 sizeof, size_t, strlen一. sizeof1.1 返回结构体长度 二. size_t三. sizeof 和 strlen 一. sizeof 返回一个结构体或者类型所占的内存字节数 1.1 返回结构体长度 这里我编写了2个结构体&#xff0c;区别在于数组问题 #include …
阅读更多...
智慧园区gis三维数字孪生可视化平台辅助管理者提升安全管控效力

智慧园区gis三维数字孪生可视化平台辅助管理者提升安全管控效力

随着信息技术的发展,3D可视化已经成为交互式管理的主流。智慧3D可视化交互管理平台能够帮助企业实现高效、灵活的管理。 1&#xff1a;智慧3D可视化交互管理平台的基本特性 智慧3D可视化交互管理平台能够实时显示工厂中生产车间的设备和生产线的运行状态&#xff0c;并通过交互…
阅读更多...
火焰图怎么看

火焰图怎么看

性能平台 通过该平台可以使用pprof采集线上的服务指标数据生成CPU占用数据并自动绘制出火焰图&#xff0c;Top&#xff0c;以及函数调用图等。 1.1 火焰图 火焰图的深度代表了函数的调用栈&#xff0c;火焰图最深处就是正在执行的函数&#xff0c;上方的都是它的父函数&#x…
阅读更多...
C++线程的简单学习及了解

C++线程的简单学习及了解

此篇文章只是线程的简单了解。 文章目录 前言一、线程的优缺点二、C线程库 1.thread类的简单介绍2.线程函数参数总结 前言 什么是线程&#xff1f; 在一个程序里的一个执行路线就叫做线程&#xff08;thread&#xff09;。更准确的定义是&#xff1a;线程是“一个进程内部的控…
阅读更多...
git 使用大全及各种疑难杂症解决方法(长期更新)

git 使用大全及各种疑难杂症解决方法(长期更新)

Git使用中遇到的各种问题及解决方法 git clone后修改文件然后再上传覆盖 git push出现“Everything up-to-date”解决方法 git commit后如何撤销或修改 git 同步远程和本地的同名分支 git push异常问题出现符号解决方法 git 删除最近或者任意一次提交commit
阅读更多...
Http详解

Http详解

一、什么是Http协议 Http全称为超文本传输协议&#xff0c;是目前使用最主流的 应用层协议&#xff0c; 二、Http工作过程 当我们在浏览器中输入一个 “网址”, 此时浏览器就会给对应的服务器发送⼀个 HTTP 请求. 对方服务器收到这个请求之后, 经过计算处理, 就会返回⼀个 …
阅读更多...
DAY06_常用API上

DAY06_常用API上

1&#xff1a;API 概述 1.1 API概述 如何自己设计对象并使用 获取已有对象并使用 而关于第一块知识&#xff1a;学习如何自己设计对象并使用&#xff0c;现在已经有一些基础了。 API(Application Programming Interface) &#xff1a;应用程序编程接口 那如何理解应用程序…
阅读更多...
软件测试技术（四）白盒测试

软件测试技术（四）白盒测试

白盒测试 白盒测试&#xff08;White Box Testing&#xff09;又称结构测试、透明盒测试、逻辑驱动测试或基于代码的测试。白盒测试只测试软件产品的内部结构和处理过程&#xff0c;而不测试软件产品的功能&#xff0c;用于纠正软件系统在描述、表示和规格上的错误&#xff0c…
阅读更多...
IDEA弹出`Lombok requires enabled annotation processing`错误信息

IDEA弹出`Lombok requires enabled annotation processing`错误信息

问题背景 项目启动时&#xff0c;弹出一个报错窗口 问题原因 当您使用 Lombok 库时&#xff0c;您可能会遇到Lombok requires enabled annotation processing的错误消息。这是因为 Lombok 库使用了 Java 注解处理器&#xff08;annotation processor&#xff09;&#xff0c;而…
阅读更多...
MySQL学习笔记第四天

MySQL学习笔记第四天

第04章运算符 3.逻辑运算符 逻辑运算符主要用来判断表达式的真假&#xff0c;在MySQL中&#xff0c;逻辑运算符的返回结果为1、0或者NULL。 MySQL中支持4种逻辑运算符如下&#xff1a; 3.1逻辑非运算符 逻辑非&#xff08;NOT或!&#xff09;运算符表示当给定的值为0时返回…
阅读更多...
【分布式技术专题】「分布式技术架构」手把手教你如何开发一个属于自己的限流器RateLimiter功能服务

【分布式技术专题】「分布式技术架构」手把手教你如何开发一个属于自己的限流器RateLimiter功能服务

限流器的算法选项 随着互联网的快速发展&#xff0c;越来越多的应用程序需要处理大量的请求。如果没有限制&#xff0c;这些请求可能会导致应用程序崩溃或变得不可用。因此&#xff0c;限流器是一种非常重要的技术&#xff0c;可以帮助应用程序控制请求的数量和速率&#xff0…
阅读更多...
【JavaEE初阶】多线程（四）阻塞队列 定时器 线程池

【JavaEE初阶】多线程（四）阻塞队列 定时器 线程池

文章目录 多线程案例阻塞队列概念生产者消费者模型标准库中的阻塞队列自己实现一个阻塞队列 定时器概念标准库中的定时器实现定时器 线程池标准库中的线程池工厂模式 ThreadPoolExecutor();构造方法参数详解(重点)实现线程池 多线程案例 阻塞队列 概念 阻塞队列是一种特殊的…
阅读更多...
【软考备战·希赛网每日一练】2023年4月26日

【软考备战·希赛网每日一练】2023年4月26日

文章目录 一、今日成绩二、错题总结第一题 三、知识查缺 题目及解析来源&#xff1a;2023年04月26日软件设计师每日一练 一、今日成绩 二、错题总结 第一题 解析&#xff1a; 数据耦合&#xff1a;一组模块借助参数表传递简单数据。 公共耦合&#xff1a;多个模块都访问同一个…
阅读更多...
C++题解 | 逆波兰表达式相关

C++题解 | 逆波兰表达式相关

✨个人主页&#xff1a; 夜 默 &#x1f389;所属专栏&#xff1a; C/C相关题解 &#x1f38a;每篇一句&#xff1a; 图片来源 A year from now you may wish you had started today. 明年今日&#xff0c;你会希望此时此刻的自己已经开始行动了。 文章目录 &#x1f307;前言…
阅读更多...
改进YOLOv8 | 即插即用篇 | YOLOv8 引入 RepVGG 重参数化模块 |《RepVGG：让VGG风格的卷积神经网络再次伟大》

改进YOLOv8 | 即插即用篇 | YOLOv8 引入 RepVGG 重参数化模块 |《RepVGG：让VGG风格的卷积神经网络再次伟大》

我们提出了一种简单但功能强大的卷积神经网络结构，该模型在推理时类似于VGG，只有33的卷积和ReLU堆叠而成，而训练时间模型具有多分支拓扑结构。训练时间和推理时间结构的这种解耦是通过结构重新参数化技术实现的，因此该模型被命名为RepVGG。在ImageNet上，RepVGG达到了超过8…
阅读更多...
手把手教你搭建属于自己的服务器

手把手教你搭建属于自己的服务器

最近总是想搭建自己的网站&#xff0c;奈何皮夹里空空如也&#xff0c;服务器也租不起&#xff0c;更别说域名了。于是我就寻思能否自己搭建个服务器&#xff0c;还不要钱呢&#xff1f; 还真行&#xff01;&#xff01;&#xff01; 经过几天的冲浪&#xff0c;我发现有两个免…
阅读更多...
AlgoC++第七课：手写Matrix

AlgoC++第七课：手写Matrix

目录 手写Matrix前言1. 明确需求2. 基本实现2.1 创建矩阵2.2 外部访问2.3 <<操作符重载 3. 矩阵运算3.1 矩阵标量运算3.2 通用矩阵乘法3.3 矩阵求逆 4. 完整示例代码总结 手写Matrix 前言 手写AI推出的全新面向AI算法的C课程 Algo C&#xff0c;链接。记录下个人学习笔记…
阅读更多...
01 背包 （二维 ）

01 背包 （二维 ）

首先是我对背包问题的理解&#xff1a; 有一个背包可以放下 n kg&#xff0c;有一些物品&#xff0c;价值和重量一一对应&#xff0c;问题是&#xff0c;需要怎样才能使背包中的价值最大&#xff1f; 不同的规则对应不同的背包问题 01背包&#xff1a;每一个物品只能被放入一次…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023