RabbitMQ实现六类工作模式

😊 @ 作者： 一恍过去
💖 @ 主页： https://blog.csdn.net/zhuocailing3390
🎊 @ 社区： Java技术栈交流
🎉 @ 主题： RabbitMQ实现六类工作模式
⏱️ @ 创作时间： 2023年07月20日

在这里插入图片描述

目录

  • 1、概述
  • 2、工具类封装
  • 3、简单列队模式
  • 4、工作列队模式
  • 5、发布/订阅模式
  • 6、路由模式
  • 7、主题模式
  • 8、交换机说明
  • 9、发布确认模式(消息确认机制)
    • 9.1、消费者实现
    • 9.2、单个确认发布(生产者实现)
    • 9.3、批量确认发布(生产者实现)
    • 9.4、异步确认发布(生产者实现)
    • 9.5、三类确认发布区别对比
  • 10、源码地址

1、概述

六模式：简单模式、工作模式、发布订阅模式、路由模式、主题模式、发布确认模式
参考代码：https://gitee.com/lhzlx/rabbit-simple-demo.git
在这里插入图片描述

2、工具类封装

在下面每种模式的笔记中，会进行代码演示，为了方便，进行工具类的封装，代码如下：

public class RabbitMqUtils {/*** 得到一个连接的  channel** @return* @throws Exception*/public static Channel getChannel() throws Exception {//创建一个连接工厂ConnectionFactory factory = new ConnectionFactory();factory.setHost("127.0.0.1");factory.setUsername("admin");factory.setPassword("admin");Connection connection = factory.newConnection();return connection.createChannel();}
}

3、简单列队模式

由生产者通过直接将消息发送到消费者
在这里插入图片描述

代码包路径： lhz.simple

public class Producer {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();/** 生成一个队列* 1.队列名称* 2.队列里面的消息是否持久化   默认消息存储在内存中* 3.该队列是否只供一个消费者进行消费   是否进行共享   true可以多个消费者消费* 4.是否自动删除   最后一个消费者端开连接以后   该队列是否自动删除   true 自动删除* 5.其他参数*/channel.queueDeclare(QUEUE_NAME, false, false, false, null);String message = "hello world";/** 发送一个消息* 1.发送到那个交换机(可以没有)* 2.路由的  key是哪个* 3.其他的参数信息* 4.发送消息的消息体*/channel.basicPublish("", QUEUE_NAME, null, message.getBytes());System.out.println("消息发送完毕");}
}

消费者：

public class Consumer {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();// 消费队列消息的一个回调接口DeliverCallback deliverCallback = (consumerTag, delivery) -> {String message = new String(delivery.getBody());System.out.println("消息消费成功,内容:");System.out.println(message);};// 取消消费的一个回调接口   如在消费的时候队列被删除掉了CancelCallback cancelCallback = (consumerTag) -> {System.out.println("消息消费被中断");};/** 消费者消费消息* 1.消费哪个队列* 2.消费成功之后是否要自动应答   true代表自动应答   false手动应答* 3.消费者未成功消费的回调* 3.消费者取消消费的的回调*/channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);System.out.println("等待接收消息....");}
}

4、工作列队模式

工作队列： 用来将耗时的任务分发给多个消费者，并且一个消息只能被消费一次，默认情况下RabbitMQ 将按顺序将每条消息发送给下一个消费者==(即轮询分发)==。

主要解决问题： 处理资源密集型任务，并且还要等他完成。有了工作队列，我们就可以将具体的工作放到后面去做，将工作封装为一个消息，发送到队列中，一个工作进程就可以取出消息并完成工作。如果启动了多个工作进程，那么工作就可以在多个进程间共享。
在这里插入图片描述

代码包路径： lhz.work

public class Producer {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {try (Channel channel = RabbitMqUtils.getChannel();) {channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 从控制台当中接受信息Scanner scanner = new Scanner(System.in);while (scanner.hasNext()) {String message = scanner.next();channel.basicPublish("", QUEUE_NAME, null, message.getBytes());System.out.println("发送消息完成:" + message);}}}
}

消费者：
消费者需要两个，分别为：Consumer01 、Consumer02两者代码一致，只是名称不同，下面以Consumer01 代码为例：

// Consumer01与Consumer02代码一致
public class Consumer01 {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();// 消费队列消息的一个回调接口DeliverCallback deliverCallback = (consumerTag, delivery) -> {String message = new String(delivery.getBody());System.out.println("Consumer01消息消费成功,内容:");System.out.println(message);};// 取消消费的一个回调接口   如在消费的时候队列被删除掉了CancelCallback cancelCallback = (consumerTag) -> {System.out.println("Consumer01消息消费被中断");};//采用自动应答channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);System.out.println("Consumer01等待接收消息....");}
}

结果：
为了演示工作队列的轮询分发，需要启动两个Consumer实例，然后再启动Producer并且在控制台多次输入内容，可以看到两个Consumer会依次接收消息，结果如下：
在这里插入图片描述

5、发布/订阅模式

发布/订阅模式是：
生产者将消息发送到交换机中，由交换机发送给不同类型的消费者，做到发布一次，消费多个，如果消费者绑定的队列名称一样，将按照轮询进行消费，所以保证了：同一个队列的中的消息不会被重复消费；

比如：
它包含一个生产者、多个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上去，两个队列绑定到交换机上去，生产者通过发送消息到交换机，所有消费者接收并消费消息。

在这里插入图片描述

代码包路径： lhz.fanout

public class Producer {/*** 定义交换机和队列名称*/private static final String EXCHANGE_NAME = "fanout_exchange";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();/*绑定的交换机 参数1交互机名称 参数2 exchange类型 */channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);for (int i = 0; i < 10; i++) {String message = "消息：" + i;// 发送一个消息,1.发送到那个交换机,2.路由的  key是哪个,3.其他的参数信息,4.发送消息的消息体channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());}System.out.println("消息发送完毕");}
}

消费者：
消费者需要两个，分别为：Consumer01 、Consumer02两者代码一致，只是名称不同，下面以Consumer01 代码为例：

/**
*两个消费者逻辑代码一样，只是绑定的队列不同，Consumer01：consumerFanout_sms；Consumer02：consumerFanout_email
*/
public class Consumer01(02) {/*** 设置队列及交换机名称*/private static final String QUEUE_NAME = "consumerFanout_sms";private static final String QUEUE_NAME = "consumerFanout_email";private static final String EXCHANGE_NAME = "fanout_exchange";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();//消费者关联队列channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKeychannel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");// 消费队列消息的一个回调接口DeliverCallback deliverCallback = (consumerTag, delivery) -> {String message = new String(delivery.getBody());System.out.println("Consumer01(02)消息消费成功,内容:");System.out.println(message);};// 取消消费的一个回调接口   如在消费的时候队列被删除掉了CancelCallback cancelCallback = (consumerTag) -> {System.out.println("Consumer01(02)消息消费被中断");};channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);System.out.println("Consumer01(02)等待接收消息....");}
}

结果：
先启动一次生产者，再启动两个消费者，绑定到交换机A，以及两个不同的队列、然后再重新启动生产者，绑定到交换机A；

在生产者发生消息以后，两个不同名称的消费者队列都可以接收到消息相同的内容，这些因为不同的消费者绑定了同一个交换机
注意：如果消费者绑定的队列名称一样，将按照轮询进行消费，所以保证了：同一个队列的中的消息不会被重复消费；**

6、路由模式

路由模式：
跟发布订阅模式类似，在订阅模式的基础上修改了exchange类型以及加上了路由键，如果消费者的路由键一样，其效果和发布/订阅模式一致，订阅模式是分发到所有绑定到交换机的所有队列，路由模式只分发到绑定在交换机上面指定路由键的队列，一个队列可以绑定多个不同的路由

注意： 消息可能匹配多个消费者，但是同一个队列的中的消息不会被重复消费；；

我们可以看一下下面这张图：

在这里插入图片描述
在上面这张图中，我们可以看到 X 绑定了两个队列，绑定类型是 direct。队列 Q1 绑定键为 orange， 队列 Q2 绑定键有两个:一个绑定键为 black，另一个绑定键为 green。
在这种绑定情况下，生产者发布消息到 exchange 上，绑定键为 orange 的消息会被发布到队列 Q1。绑定键为 black、green的消息会被发布到队列 Q2，其他消息类型的消息将被丢弃。

说明： 生产者发送消息到交换机，同时定义了一个路由 routingKey，多个消费者声明多个队列，与交换机进行绑定，同时定义路由 routingKey，只有和生产者发送消息时的路由 routingKey相同的消费者才能消费数据；

注意： 如果交换机和路由绑定后，需要修改路由就要修改交换机名称

代码包路径：lhz.route

生产者：

public class Producer {/*** 定义交换机和队列名称*/private static final String EXCHANGE_NAME = "direct_exchange";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();/*绑定的交换机 参数1交互机名称 参数2 exchange类型 */channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);// 发送消息String message = "", sendType = "";for (int i = 0; i < 20; i++) {if (i % 2 == 0) {sendType = "info";message = "我是 info 级别的消息类型：" + i;} else {sendType = "error";message = "我是 error 级别的消息类型：" + i;}System.out.println("[send]：" + message + "  " + sendType);// 第二个参数就是路由键channel.basicPublish(EXCHANGE_NAME, sendType, null, message.getBytes());}System.out.println("消息发送完毕");}
}

消费者：
消费者需要两个，分别为：Consumer01 、Consumer02两者代码一致，只是名称不同，下面以Consumer01 代码为例：

/**
* 两个消费者逻辑代码一样，只是绑定的队列不同和不同的路由键
* Consumer01:"info"、"consumer_info"；Consumer02:"error"、"consumer_error"；
*/
public class Consumer01(02) {/*** 设置队列及交换机名称*/private static final String ROUTING_KEY = "info";private static final String ROUTING_KEY = "error";private static final String QUEUE_NAME = "consumer_info";private static final String QUEUE_NAME = "consumer_error";private static final String EXCHANGE_NAME = "direct_exchange";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();//消费者关联队列channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKeychannel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);// 消费队列消息的一个回调接口DeliverCallback deliverCallback = (consumerTag, delivery) -> {String message = new String(delivery.getBody());System.out.println("Consumer01(02)消息消费成功,内容:");System.out.println(message);};// 取消消费的一个回调接口   如在消费的时候队列被删除掉了CancelCallback cancelCallback = (consumerTag) -> {System.out.println("Consumer01(02)消息消费被中断");};channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);System.out.println("Consumer01(02)等待接收消息....");}
}

结果：
先启动一次生产者，再启动两个消费者，绑定到交换机A，以及两个不同的队列和不同的路由键；最后重新启动生产者，绑定到交换机A；

7、主题模式

主题模式：
跟 routing 路由模式类似，只不过路由模式是指定固定的路由键 routingKey，而主题模式是可以模糊匹配路由routingKey，类似于SQL中 = 和 like 的关系

注意：消息可能匹配多个消费者，但是同一个队列的中的消息不会被重复消费；
要求：

  • 要求
    Topic 模式消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以 “.” 或者 “#” 分隔开。这些单词可以是任意单词，这个单词列表最多不能超过 255 个字节。

  • 分隔符

    “*(星号)”：可以代替一个单词

    “#(井号)”：可以替代零个或多个单词

  • 比如

    • 中间带 orange 带3个单词： *.orange.*
    • 最后一个词是 rabbit 的3 个单词：*.*.rabbit
    • 以 lazy开头的多个单词lazy.#

图示：
在这里插入图片描述

注意： 如果交换机和路由绑定后，需要修改路由就要修改交换机名称

代码包路径：lhz.toptic

生产者：

public class Producer {/*** 定义交换机和队列名称*/private static final String EXCHANGE_NAME = "topic";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();/*绑定的交换机 参数1交互机名称 参数2 exchange类型 */channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);// 定义路由keyString routingKey = "mq.info.log";String message = "topic_exchange_msg：" + routingKey;System.out.println("[send] = " + message);// 发送消息// 第二个参数就是路由键channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());System.out.println("消息发送完毕");}
}

消费者：

public class Consumer {/*** 设置路由匹配规则*/private static final String ROUTING_KEY = "#.log";/*** 设置队列及交换机名称*/private static final String QUEUE_NAME = "topic_consumer";private static final String EXCHANGE_NAME = "topic";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();//消费者关联队列channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKeychannel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);// 消费队列消息的一个回调接口DeliverCallback deliverCallback = (consumerTag, delivery) -> {String message = new String(delivery.getBody());System.out.println("消息消费成功,内容:");System.out.println(message);};// 取消消费的一个回调接口   如在消费的时候队列被删除掉了CancelCallback cancelCallback = (consumerTag) -> {System.out.println("消息消费被中断");};channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);System.out.println("等待接收消息....");}
}

结果：
先启动消费者，绑定到交换机A，通过通配符模糊匹配路由；再启动生产者，绑定到交换机A，设置具体的路由键；

8、交换机说明

在没有交换机的情况，生产者直接往队列发送消息，消费者绑定队列消费相消息，但是同一个队列中一个消息只会被消费一次，所以无法满足一个消息同时被多个消费者使用；

​交换机的作用就可以解决这个问题，一个交换机可以绑定多个不同的队列，一个队列绑定多个消费者；生产者将消息发送到交换机中，所有绑定了该交换机的队列都可以收到消息；所以生产者发送一次消息，可以被不同的队列**(消费者)**进行消费；当同一个队列中存在多个消费者时，消息不会被重复消费；

9、发布确认模式(消息确认机制)

概念： 生产者将信道设置成 确认(confirm) 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID(从 1 开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者(包含消息的唯一 ID)，这就使得生产者知道消息已经正确到达目的队列了，如果消息和队列是可持久化的，那么确认消息会在将消息写入磁盘之后发出，broker 回传给生产者的确认消息中 delivery-tag 域包含了确认消息的序列号。

优点： confirm 模式最大的好处在于他是异步的，一旦发布一条消息，生产者就可以在等待信道返回确认的同时继续发送下一条消息，当消息最终得到ack之后，生产者可以通过回调方法来处理该ack消息；如果 RabbitMQ 因为自身内部错误导致消息丢失，就会发送一条 nack 消息，生产者应用程序同样可以在回调方法中处理该 nack 消息；

使用： 发布确认模式默认是没有开启的，生产者通过调用方法 confirmSelect实现开启
在这里插入图片描述

9.1、消费者实现

代码包路径： lhz.confirm

public class Consumer {//设置队列名称private final static String QUEUE_NAME = "confirm_queue";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();// 消费队列消息的一个回调接口DeliverCallback deliverCallback = (consumerTag, delivery) -> {String message = new String(delivery.getBody());System.out.println("消息消费成功,内容:");System.out.println(message);};// 取消消费的一个回调接口   如在消费的时候队列被删除掉了CancelCallback cancelCallback = (consumerTag) -> {System.out.println("消息消费被中断");};// 消费者消费消息channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);System.out.println("等待接收消息....");}
}

9.2、单个确认发布(生产者实现)

单个确认发布：
是一种简单的确认方式，它是一种**同步确认发布** 的方式，也就是发布的消息只有被确认发布之后，后续的消息才能继续发布,通过waitForConfirmsOrDie(long outTime)方法，指定时间范围内(单位:毫秒)这个消息没有被确认那么它将抛出异常；通过waitForConfirms()对broker响应的消息进行确认；

这种确认方式有一个最大的缺点就是：发布速度特别的慢，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量，当然对于某 些应用程序来说这可能已经足够了。

代码包路径： lhz.confirm
类：SingleProducer
说明： 确认发布的实现只是对生产者代码做修改，所以消费者代码不变，参考：《9.1、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

public class SingleProducer {// 设置队列名称private final static String QUEUE_NAME = "confirm_queue";// 发送消息数量private final static Integer MESSAGE_COUNT = 100;public static void main(String[] args) throws Exception {try (Channel channel = RabbitMqUtils.getChannel()) {channel.queueDeclare(QUEUE_NAME, false, false, false, null);//开启发布确认channel.confirmSelect();long begin = System.currentTimeMillis();for (int i = 0; i < MESSAGE_COUNT; i++) {String message = i + "";channel.basicPublish("", QUEUE_NAME, null, message.getBytes());//服务端返回确认状态，如果 false或超时时间内未返回，生产者可以消息重发boolean flag = channel.waitForConfirms();if (flag) {System.out.println("消息发送成功");}}long end = System.currentTimeMillis();System.out.println("发布" + MESSAGE_COUNT + "个单独确认消息,耗时" + (end - begin) + "ms");}}
}

9.3、批量确认发布(生产者实现)

批量确认发布：
与单个等待确认消息相比，会先发布一批消息然后一起确认 可以极大地提高吞吐量，它也是一种**同步确认发布** 的方式。

这种方式的缺点就是： 当消息发布出现问题时，不知道是哪个消息出现问题了；

代码包路径：lhz.confirm
类：BatchProducer
**说明：**确认发布的实现只是对生产者代码做修改，所以消费者代码不变，参考：《9.1、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

public class BatchProducer {// 设置队列名称private final static String QUEUE_NAME = "confirm_queue";// 发送消息数量private final static Integer MESSAGE_COUNT = 100;public static void main(String[] args) throws Exception {try (Channel channel = RabbitMqUtils.getChannel()) {channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 开启发布确认channel.confirmSelect();// 批量确认消息大小int batchSize = 100;// 未确认消息个数int outstandingMessageCount = 0;long begin = System.currentTimeMillis();for (int i = 0; i < MESSAGE_COUNT; i++) {String message = i + "";channel.basicPublish("", QUEUE_NAME, null, message.getBytes());outstandingMessageCount++;// 达到设置的批处理大小时，进行确认if (outstandingMessageCount == batchSize) {channel.waitForConfirms();outstandingMessageCount = 0;}}// 为了确保还有剩余没有确认消息，进行再次确认if (outstandingMessageCount > 0) {channel.waitForConfirms();}long end = System.currentTimeMillis();System.out.println("发布" + MESSAGE_COUNT + "个批量确认消息,耗时" + (end - begin) + "ms");}}
}

9.4、异步确认发布(生产者实现)

异步确认发布：
虽然编程逻辑比上两个要复杂，但是可靠性和效率更高；他是利用回调函数来保证是否投递成功。逻辑图如下：
在这里插入图片描述

代码包路径：lhz.confirm
类：AsynProducer
**说明：**确认发布的实现只是对生产者代码做修改，所以消费者代码不变，参考：《9.1、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

public class AsynProducer {/*** 设置队列名称*/private final static String QUEUE_NAME = "confirm_queue";/*** 发送消息数量*/private final static Integer MESSAGE_COUNT = 500;public static void main(String[] args) throws Exception {try (Channel channel = RabbitMqUtils.getChannel()) {channel.queueDeclare(QUEUE_NAME, false, false, false, null);//开启发布确认channel.confirmSelect();/** 线程安全有序的一个哈希表，适用于高并发的情况* 1.轻松的将序号与消息进行关联* 2.轻松批量删除条目    只要给到序列号* 3.支持并发访问*/ConcurrentSkipListMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap();/** 确认收到消息的一个回调* 1.消息序列号* 2.true可以确认小于等于当前序列号的消息*   false确认当前序列号消息*/ConfirmCallback ackCallback = (sequenceNumber, multiple) -> {if (multiple) {//返回的是小于等于当前序列号的未确认消息    是一个  mapConcurrentNavigableMap<Long, String> confirmed = outstandingConfirms.headMap(sequenceNumber, true);//清除该部分未确认消息confirmed.clear();} else {//只清除当前序列号的消息outstandingConfirms.remove(sequenceNumber);}};// 未被确认消息回调ConfirmCallback nackCallback = (sequenceNumber, multiple) -> {String message = outstandingConfirms.get(sequenceNumber);System.out.println("未被确认消息：" + message + "，序列号" + sequenceNumber);};/** 添加一个异步确认的监听器* 1.确认收到消息的回调* 2.未收到消息的回调*/channel.addConfirmListener(ackCallback, nackCallback);long begin = System.currentTimeMillis();for (int i = 0; i < MESSAGE_COUNT; i++) {String message = "消息" + i;/** channel.getNextPublishSeqNo()获取下一个消息的序列号* 通过序列号与消息体进行一个关联* 全部都是未确认的消息体*/outstandingConfirms.put(channel.getNextPublishSeqNo(), message);channel.basicPublish("", QUEUE_NAME, null, message.getBytes());}long end = System.currentTimeMillis();System.out.println("发布" + MESSAGE_COUNT + "个异步确认消息,耗时" + (end - begin) + "ms");}}
}

9.5、三类确认发布区别对比

  • 单独发布消息
    同步等待确认，简单，但吞吐量非常有限，较耗时。

  • 批量发布消息
    批量同步等待确认，简单，合理的吞吐量，一旦出现问题但很难推断出是那条 消息出现了问题，效率较高。

  • 异步处理：
    最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些，效率高。

10、源码地址

源码地址：https://gitee.com/lhzlx/rabbit-simple-demo.git

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

图像处理之梯度及边缘检测算子

图像处理之梯度及边缘检测算子

文章目录 一、sobel 算子二、Scharr算子三、Roberts算子四、拉普拉斯算子 梯度是一个量变化的速度&#xff0c;在数学中通常使用求导、求偏导获取梯度或者某一方向上的梯度。 在数字图像中梯度可以看为像素值分别在x,y方向上的变化速度&#xff0c;因为数字图像的离散型&#x…
阅读更多...
微软浏览器连不上网络

微软浏览器连不上网络

针对微软浏览器连不上网络&#xff0c;但其他浏览器仍能连上网络 控制面板 -> 网络和Internet -> Internet 选项 -> 连接 -> 局域网设置 -> 取消代理服务器
阅读更多...
SQL数据库（设置模式、数据库操作、表操作、列操作、SQL索引/约束、SQL数据类型、SQL函数、常见问题）

SQL数据库（设置模式、数据库操作、表操作、列操作、SQL索引/约束、SQL数据类型、SQL函数、常见问题）

目录 SQL数据库 设置模式 SET NAMES utf-8 set sql_safe_updates1 数据库操作 CREATE DATABASE databaseName&#xff08;创建数据库&#xff09; USE databaseName&#xff08;选择数据库&#xff09; DROP DATABASE databaseName&#xff08;删除数据库&#xff09; …
阅读更多...
[pyqt5]鼠标指针光标样式

[pyqt5]鼠标指针光标样式

pyqt5默认有下面几种光标样式 设置光标&#xff1a; self.setCursor(Qt.CrossCursor) 恢复默认光标 self.unsetCursor() 自定义光标 from PyQt5.Qt import * import sysapp QApplication(sys.argv)# 创建一个控件 window QWidget() window.resize(500,500) window.move(…
阅读更多...
指针知多少

指针知多少

作者简介&#xff1a;დ旧言~&#xff0c;目前大一&#xff0c;现在学习Java&#xff0c;c&#xff0c;Python等 座右铭&#xff1a;松树千年终是朽&#xff0c;槿花一日自为荣。 望小伙伴们点赞&#x1f44d;收藏✨加关注哟&#x1f495;&#x1f495; ⛵前言 不知道大家还记…
阅读更多...
【深度学习】多任务学习

【深度学习】多任务学习

多任务学习是一个很火的话题&#xff0c;在自动驾驶领域以及其他对存储资源要求较高的端侧任务&#xff0c;都会考虑这种方式。之前面试的时候也有被问题多任务学习。前几天看到一个写得很好的例子&#xff0c;在此记录一下&#xff0c;也好久没有写博客了。 1.参考 论文是20…
阅读更多...
p2p大豆计数模型

p2p大豆计数模型

前面学习了一下论文&#xff1a;Improved Field-Based Soybean Seed Counting and Localization with Feature Level Considered 论文链接&#xff1a;https://spj.science.org/doi/10.34133/plantphenomics.0026 解读链接&#xff1a;论文阅读--考虑特征水平的改进的基于田间…
阅读更多...
如何在 3ds Max 中使用 Mental Ray 制作逼真的草地和带有光晕的天空

如何在 3ds Max 中使用 Mental Ray 制作逼真的草地和带有光晕的天空

推荐&#xff1a; NSDT场景编辑器助你快速搭建可二次开发的3D应用场景 首先&#xff0c;您将创建一个平面对象&#xff0c;然后添加一个噪点修改器。在此之上应用毛发和毛皮修饰符。 这将用于模拟逼真的草地。 我们用日光系统创造太阳和天空。为太阳添加镜头和戒指效果以及酷炫…
阅读更多...
ES6类-继承-Symbol-模版字符串

ES6类-继承-Symbol-模版字符串

目录 类 继承 ES5 如何继承 ES6继承 Symbol 用途 可以产生唯一的值&#xff0c;独一无二的值 解决命名冲突 getOwnPropertySymbols() 作为全局注册表 缓存 Symbol.for() 消除魔术字符串 模版字符串 类 在javascript语言中&#xff0c;生成实例对象使用构造函数&#xf…
阅读更多...
使用Linux Deploy搭建服务器（三）Linux Deploy安装宝塔面板

使用Linux Deploy搭建服务器（三）Linux Deploy安装宝塔面板

宝塔面板是一个免费的服务器管理平台&#xff0c;可以在你的服务器上安装它&#xff0c;然后你就能很方便的管理你的服务器&#xff0c;以及搭建各种服务平台&#xff0c;在此基础上我们可以使用内网穿透&#xff0c;搭建出自己的Linux服务器。可以这样一个相对便宜的方式&…
阅读更多...
【数学建模】利用C语言来实现 太阳赤纬 太阳高度角 太阳方位角 计算和求解分析 树木树冠阴影面积与种植间距的编程计算分析研究

【数学建模】利用C语言来实现 太阳赤纬 太阳高度角 太阳方位角 计算和求解分析 树木树冠阴影面积与种植间距的编程计算分析研究

太阳赤纬的计算 #include <stdio.h> #include <math.h>double calculateDelta(int year, int month, int day, int hour, int minute, int second) {int n, n0;double t, theta, delta;// 计算n和n0n month * 30 day;n0 79.6764 0.2422 * (year - 1985) - ((y…
阅读更多...
前端Vue仿微信我的菜单栏组件按钮组件

前端Vue仿微信我的菜单栏组件按钮组件

随着技术的发展&#xff0c;开发的复杂度也越来越高&#xff0c;传统开发方式将一个系统做成了整块应用&#xff0c;经常出现的情况就是一个小小的改动或者一个小功能的增加可能会引起整体逻辑的修改&#xff0c;造成牵一发而动全身。 通过组件化开发&#xff0c;可以有效实现…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023