JAVA 整合 RabbitMQ

maven pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.orchids</groupId><artifactId>Rabbitmq</artifactId><version>1.0-SNAPSHOT</version><properties><maven.compiler.source>8</maven.compiler.source><maven.compiler.target>8</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>com.rabbitmq</groupId><artifactId>amqp-client</artifactId><version>5.20.0</version></dependency></dependencies></project>
连接RabbitMQ工具类
package com.orchids.rabbitmq.utils;import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;/*** @ Author qwh* @ Date 2024/6/5 16:05*/public class ConnectionUtil {public static final String HOST_ADDRESS = "192.168.70.145";public static Connection getConnection() throws Exception {// 定义连接工厂ConnectionFactory factory = new ConnectionFactory();// 设置服务地址factory.setHost(HOST_ADDRESS);// 端口factory.setPort(5672);//设置账号信息，用户名、密码、vhostfactory.setVirtualHost("/");factory.setUsername("guest");factory.setPassword("123456");// 通过工程获取连接Connection connection = factory.newConnection();return connection;}public static void main(String[] args) throws Exception {Connection con = ConnectionUtil.getConnection();// amqp://guest@192.168.200.100:5672/System.out.println(con);con.close();}}
work 工作模式
  1. 生产者只有一个
  2. 发送一个消息
  3. 消费者也只有一个 消息也只能被这个消费者消费
  5. 生产者发送多个消息
  6. 由多个消费者来竞争
  7. 谁抢到算谁的
  9. 多个消费者 监听同一个队列 各个消费者之间对同一个消息是竞争关系
  10. workquenes 工作模式适用于任务较重或任务较多的情况 多消费者分摊任务 提高消息处理效率
  11. 消费者
package com.orchids.rabbitmq.demo;import com.rabbitmq.client.*;  import java.io.IOException;  public class Consumer {  public static void main(String[] args) throws Exception {  // 1.创建连接工厂  ConnectionFactory factory = new ConnectionFactory();  // 2. 设置参数  factory.setHost("192.168.70.145");factory.setPort(5672);  factory.setVirtualHost("/");  factory.setUsername("guest");factory.setPassword("123456");  // 3. 创建连接 Connection        Connection connection = factory.newConnection();  // 4. 创建Channel  Channel channel = connection.createChannel();  // 5. 创建队列  // 如果没有一个名字叫simple_queue的队列，则会创建该队列，如果有则不会创建  // 参数1. queue：队列名称  // 参数2. durable：是否持久化。如果持久化，则当MQ重启之后还在  // 参数3. exclusive：是否独占。  // 参数4. autoDelete：是否自动删除。当没有Consumer时，自动删除掉  // 参数5. arguments：其它参数。  channel.queueDeclare("simple_queue",true,false,false,null);  // 接收消息  DefaultConsumer consumer = new DefaultConsumer(channel){  // 回调方法,当收到消息后，会自动执行该方法  // 参数1. consumerTag：标识  // 参数2. envelope：获取一些信息，交换机，路由key...  // 参数3. properties：配置信息  // 参数4. body：数据  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("consumerTag："+consumerTag);  System.out.println("Exchange："+envelope.getExchange());  System.out.println("RoutingKey："+envelope.getRoutingKey());  System.out.println("properties："+properties);  System.out.println("body："+new String(body));  }  };  // 参数1. queue：队列名称  // 参数2. autoAck：是否自动确认，类似咱们发短信，发送成功会收到一个确认消息  // 参数3. callback：回调对象  // 消费者类似一个监听程序，主要是用来监听消息  channel.basicConsume("simple_queue",true,consumer);  }  }
  1. 生产者
package com.orchids.rabbitmq.demo;import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  public class Producer {  public static void main(String[] args) throws Exception {  // 创建连接工厂  ConnectionFactory connectionFactory = new ConnectionFactory();  // 设置主机地址  connectionFactory.setHost("192.168.70.145");// 设置连接端口号：默认为 5672connectionFactory.setPort(5672);// 虚拟主机名称：默认为 /connectionFactory.setVirtualHost("/");// 设置连接用户名；默认为guest  connectionFactory.setUsername("guest");// 设置连接密码；默认为guest  connectionFactory.setPassword("123456");// 创建连接  Connection connection = connectionFactory.newConnection();  // 创建频道  Channel channel = connection.createChannel();  // 声明（创建）队列  // queue      参数1：队列名称  // durable    参数2：是否定义持久化队列，当 MQ 重启之后还在  // exclusive  参数3：是否独占本次连接。若独占，只能有一个消费者监听这个队列且 Connection 关闭时删除这个队列  // autoDelete 参数4：是否在不使用的时候自动删除队列，也就是在没有Consumer时自动删除  // arguments  参数5：队列其它参数  channel.queueDeclare("simple_queue", true, false, false, null);  // 要发送的信息  String message = "你好；小兔子！";  // 参数1：交换机名称,如果没有指定则使用默认Default Exchange  // 参数2：路由key,简单模式可以传递队列名称  // 参数3：配置信息  // 参数4：消息内容  channel.basicPublish("", "simple_queue", null, message.getBytes());  System.out.println("已发送消息：" + message);  // 关闭资源  channel.close();  connection.close();  }  }
public/subscribe 工作模式
  1. 生产者不是把消息发送到队列 而是发送到交换机
  2. 交换机接收消息 而如何处理消息取决于交换机的类型
  3. 交换机有三种常见类型 -->就是广播
  4. 交换机只负责转发消息不具备存储消息的能力因此如果没有任何队列于交换机绑定 或者没有符合路由规则的队列 那么消息会丢失

常见的三种交换机

  1. fanout 广播 将消息发送给所有绑定到交换机的队列
  2. direct 定向 把消息交符合指定routing key的队列
  3. topic 通配符 把消息交给符合routing pattern的队列
fanout 交换机 广播 生产者->交换机->多个队列->广播到多个消费者
package com.orchids.rabbitmq.fanout;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;  public class Consumer1 {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String queue1Name = "test_fanout_queue1";  channel.queueDeclare(queue1Name,true,false,false,null);  Consumer consumer = new DefaultConsumer(channel){  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("body："+new String(body));  System.out.println("队列 1 消费者 1 将日志信息打印到控制台.....");  }  };  channel.basicConsume(queue1Name,true,consumer);  }  }

package com.orchids.rabbitmq.fanout;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;  public class Consumer2 {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String queue2Name = "test_fanout_queue2";  channel.queueDeclare(queue2Name,true,false,false,null);  Consumer consumer = new DefaultConsumer(channel){  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("body："+new String(body));  System.out.println("队列 2 消费者 2 将日志信息打印到控制台.....");  }  };  channel.basicConsume(queue2Name,true,consumer);  }  }

package com.orchids.rabbitmq.fanout;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  public class Producer {  public static void main(String[] args) throws Exception {  // 1、获取连接  Connection connection = ConnectionUtil.getConnection();// 2、创建频道  Channel channel = connection.createChannel();  // 参数1. exchange：交换机名称  // 参数2. type：交换机类型  //     DIRECT("direct")：定向  //     FANOUT("fanout")：扇形（广播），发送消息到每一个与之绑定队列。  //     TOPIC("topic")：通配符的方式  //     HEADERS("headers")：参数匹配  // 参数3. durable：是否持久化  // 参数4. autoDelete：自动删除  // 参数5. internal：内部使用。一般false  // 参数6. arguments：其它参数  String exchangeName = "test_fanout";  // 3、创建交换机  channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);  // 4、创建队列  String queue1Name = "test_fanout_queue1";  String queue2Name = "test_fanout_queue2";  channel.queueDeclare(queue1Name,true,false,false,null);  channel.queueDeclare(queue2Name,true,false,false,null);  // 5、绑定队列和交换机  // 参数1. queue：队列名称  // 参数2. exchange：交换机名称  // 参数3. routingKey：路由键，绑定规则  //     如果交换机的类型为fanout，routingKey设置为""  channel.queueBind(queue1Name,exchangeName,"");  channel.queueBind(queue2Name,exchangeName,"");  String body = "日志信息：张三调用了findAll方法...日志级别：info...";  // 6、发送消息  channel.basicPublish(exchangeName,"",null,body.getBytes());  // 7、释放资源  channel.close();  connection.close();  }  }
direct 交换机
  1. 交换机和队列通过路由键进行绑定
  2. 生产者发送消息时不仅要指定交换机 还要指定路由键
  3. 交换机接受到消息会发送到路由键进行绑定的队列
  4. 在编码上public/subscribe发布于订阅模式的区别
    1. 交换机的类型为direct
    2. 队列绑定交换机的时候需要指定reouting key
package com.orchids.rabbitmq.dircet;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;  public class Consumer1 {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String queue1Name = "test_direct_queue1";  channel.queueDeclare(queue1Name,true,false,false,null);  Consumer consumer = new DefaultConsumer(channel){  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("body："+new String(body));  System.out.println("Consumer1 将日志信息打印到控制台.....");  }  };  channel.basicConsume(queue1Name,true,consumer);  }  }

package com.orchids.rabbitmq.dircet;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;  public class Consumer2 {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String queue2Name = "test_direct_queue2";  channel.queueDeclare(queue2Name,true,false,false,null);  Consumer consumer = new DefaultConsumer(channel){  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("body："+new String(body));  System.out.println("Consumer2 将日志信息存储到数据库.....");  }  };  channel.basicConsume(queue2Name,true,consumer);  }  }

package com.orchids.rabbitmq.dircet;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  public class Producer {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String exchangeName = "test_direct";  // 创建交换机  channel.exchangeDeclare(exchangeName,BuiltinExchangeType.DIRECT,true,false,false,null);  // 创建队列  String queue1Name = "test_direct_queue1";  String queue2Name = "test_direct_queue2";  // 声明（创建）队列  channel.queueDeclare(queue1Name,true,false,false,null);  channel.queueDeclare(queue2Name,true,false,false,null);  // 队列绑定交换机  // 队列1绑定error  channel.queueBind(queue1Name,exchangeName,"error");  // 队列2绑定info error warning  channel.queueBind(queue2Name,exchangeName,"info");  channel.queueBind(queue2Name,exchangeName,"error");  channel.queueBind(queue2Name,exchangeName,"warning");  String message = "日志信息：张三调用了delete方法.错误了,日志级别warning";  // 发送消息  channel.basicPublish(exchangeName,"warning",null,message.getBytes());  System.out.println(message);  // 释放资源  channel.close();  connection.close();  }  }
topics交换机
  1. toppics类型交换机 于direct 相比 都是可以根据RoutingKey 把消息路由到不同的队列 只不过Topic类型exchange可以让队列在绑定routing key的时候使用通配符
  2. Routing Key 一般都是由一个或者多个单词组成 多个单词以 . 号分割
  3. 通配符规则
  4. “#”匹配零个或多个词
  5. “*”匹配一个词
package com.orchids.rabbitmq.topics;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;  public class Consumer1 {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String QUEUE_NAME = "test_topic_queue1";  channel.queueDeclare(QUEUE_NAME,true,false,false,null);  Consumer consumer = new DefaultConsumer(channel){  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("body："+new String(body));  }  };  channel.basicConsume(QUEUE_NAME,true,consumer);  }  }

package com.orchids.rabbitmq.topics;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;  public class Consumer2 {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String QUEUE_NAME = "test_topic_queue2";  channel.queueDeclare(QUEUE_NAME,true,false,false,null);  Consumer consumer = new DefaultConsumer(channel){  @Override  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {  System.out.println("body："+new String(body));  }  };  channel.basicConsume(QUEUE_NAME,true,consumer);  }  }

package com.orchids.rabbitmq.topics;import com.orchids.rabbitmq.utils.ConnectionUtil;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  public class Producer {  public static void main(String[] args) throws Exception {  Connection connection = ConnectionUtil.getConnection();Channel channel = connection.createChannel();  String exchangeName = "test_topic";  channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);  String queue1Name = "test_topic_queue1";  String queue2Name = "test_topic_queue2";  channel.queueDeclare(queue1Name,true,false,false,null);  channel.queueDeclare(queue2Name,true,false,false,null);  // 绑定队列和交换机  // 参数1. queue：队列名称  // 参数2. exchange：交换机名称  // 参数3. routingKey：路由键,绑定规则  //      如果交换机的类型为fanout ,routingKey设置为""  // routing key 常用格式：系统的名称.日志的级别。  // 需求： 所有error级别的日志存入数据库,所有order系统的日志存入数据库  channel.queueBind(queue1Name,exchangeName,"#.error");  channel.queueBind(queue1Name,exchangeName,"order.*");  channel.queueBind(queue2Name,exchangeName,"*.*");  // 分别发送消息到队列：order.info、goods.info、goods.error  String body = "[所在系统：order][日志级别：info][日志内容：订单生成，保存成功]";  channel.basicPublish(exchangeName,"order.info",null,body.getBytes());  body = "[所在系统：goods][日志级别：info][日志内容：商品发布成功]";  channel.basicPublish(exchangeName,"goods.info",null,body.getBytes());  body = "[所在系统：goods][日志级别：error][日志内容：商品发布失败]";  channel.basicPublish(exchangeName,"goods.error",null,body.getBytes());  channel.close();  connection.close();  }  }
spring boot 整合 RabbitMQ
生产者
parent pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.1.5</version></parent><groupId>com.orchids</groupId><artifactId>springrabbitmq</artifactId><version>1.0-SNAPSHOT</version><packaging>pom</packaging><modules><module>producer</module><module>consumer</module><module>comfirm-producer</module><module>comfire-consumer</module></modules><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-amqp</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies></project>
producer pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.orchids</groupId><artifactId>springrabbitmq</artifactId><version>1.0-SNAPSHOT</version></parent><artifactId>producer</artifactId><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-amqp</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency></dependencies></project>
配置文件
spring:rabbitmq:host: 192.168.70.145port: 5672username: guestpassword: 123456virtual-host: /publisher-confirm-type: CORRELATED # 交换机的确认publisher-returns: true # 队列的确认
编写代码
package com.orchids;import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;/*** @ Author qwh* @ Date 2024/6/5 19:17*/
@SpringBootTest
public class ProducerTest {public static final String EXCHANGE_DIRECT = "exchange.direct.order";public static final String ROUTING_KEY = "order";@Autowiredprivate RabbitTemplate rabbitTemplate;@Testpublic void SendMessage(){rabbitTemplate.convertAndSend(EXCHANGE_DIRECT,ROUTING_KEY,"Hello world RabbitMQ");}
}
消费者
consumer pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.orchids</groupId><artifactId>springrabbitmq</artifactId><version>1.0-SNAPSHOT</version></parent><artifactId>consumer</artifactId><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-amqp</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies></project>
监听器
package com.orchids.rabbit.listener;import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;/*** @ Author qwh* @ Date 2024/6/5 19:05*/
@Component
@Slf4j
public class MyMessageListener {public static final String EXCHANGE_DIRECT = "exchange.direct.order";public static final String ROUTING_KEY = "order";public static final String QUEUE_NAME  = "queue.order";@RabbitListener(bindings = @QueueBinding(value = @Queue(value = QUEUE_NAME,durable = "true"),exchange = @Exchange(value = EXCHANGE_DIRECT,type = "direct"),key = {ROUTING_KEY}))public void processMessage(String dateString, Message message, Channel channel){log.info("消息信息"+dateString);}
}
启动类
package com.orchids;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;/*** @ Author qwh* @ Date 2024/6/5 19:02*/
@SpringBootApplication
public class ConsumerApplication {public static void main(String[] args) {SpringApplication.run(ConsumerApplication.class,args);}
}

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

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

相关文章

Web后端开发(请求-实体参数）（二）

Web后端开发(请求-实体参数）（二）

简单实体对象&#xff1a;请求参数名与形参对象属性名相同&#xff0c;定义对象(POJO)接收即可 RequestMapping("/simplePojo") public String simplePojo(User user){System.out.println(user);return "OK"; } public class User{private String name;p…
阅读更多...
算法——Floyd判圈算法

算法——Floyd判圈算法

介绍 Floyd判圈算法用于判断一个链表中是否有环。 思想 使用快慢指针fast, slow&#xff0c;快指针每次走两步fast fast.next.next&#xff0c;慢指针每次走一步slow slow.next。当出现fast null || fast.next null时&#xff0c;说明链表不存在环&#xff0c;如果存在环…
阅读更多...
1.2-自然语言的分布式表示-基于计数的方法

1.2-自然语言的分布式表示-基于计数的方法

本篇笔记对应的视频链接为&#xff1a; 3-基于计数的方法表示单词-将文字转换成编号的预处理工作_哔哩哔哩_bilibili&#xff1b;4-基于计数的方法表示单词-使用共现矩阵进行单词的分布式表示_哔哩哔哩_bilibili&#xff1b;5-基于计数的方法表示单词-单词之间相似度计算_哔哩哔…
阅读更多...
计算机网络 —— 网络层（CIDR）

计算机网络 —— 网络层（CIDR）

计算机网络 —— 网络层&#xff08;CIDR&#xff09; CIDR的提出背景什么是CIDR基本概念划分示例应用优势 举个例子路由聚合常用数字 我们今天来看IPv4地址划分的另一种方法 —— CIDR。 CIDR的提出背景 CIDR&#xff08;无类域间路由&#xff0c;Classless Inter-Domain Ro…
阅读更多...
大众汽车裁员加速，38万元遣散费起步

大众汽车裁员加速，38万元遣散费起步

导语 大家好&#xff0c;我是社长&#xff0c;老K。专注分享智能制造和智能仓储物流等内容。 新书《智能物流系统构成与技术实践》 几周前&#xff0c;大众汽车宣布了一项新的裁员计划。 一、裁员行动与额外福利并行 大众汽车近期在裁员行动上取得了显著进展&#xff0c;其遣散…
阅读更多...
深度解析：AI Prompt 提示词工程的兴起、争议与未来发展

深度解析：AI Prompt 提示词工程的兴起、争议与未来发展

PART1: 提示词工程的兴起 在人工智能领域中&#xff0c;一个新的领域——提示词工程&#xff08;prompt engineering&#xff09;——开始显露头角。 这个领域的核心在于精心设计输入&#xff0c;以引导AI模型产生特定的、期望的输出。 随着AI技术的飞速发展&#xff0c;特别…
阅读更多...
Spark MLlib 机器学习

Spark MLlib 机器学习

Spark MLlib是一个在Apache Spark上构建的机器学习库&#xff0c;用于解决大规模数据集上的机器学习问题。它提供了一组丰富的机器学习算法和工具&#xff0c;可以用于分类、回归、聚类、推荐和协同过滤等任务。同时&#xff0c;它还提供了一些特征提取、特征转换和特征选择的工…
阅读更多...
无头+单向+非循环链表的实现

无头+单向+非循环链表的实现

这里写目录标题 1. 链表1.1 链表的概念及结构1.2 链表的分类 2. 接口实现3. 链表的实现3.1 打印链表3.2 头插3.3 尾插3.4 头删3.5 尾删3.6 单链表查找3.7 在pos之前插入3.8 在pos之后插入3.9 删除pos位置的值3.10 删除pos位置之后的值3.11 链表的释放3.12 动态申请一个节点 4. …
阅读更多...
《精通ChatGPT：从入门到大师的Prompt指南》第11章：Prompt与AI的未来

《精通ChatGPT：从入门到大师的Prompt指南》第11章：Prompt与AI的未来

第11章&#xff1a;Prompt与AI的未来 11.1 技术发展的新方向 在迅速发展的人工智能领域&#xff0c;Prompt工程作为与AI模型交互的核心方式&#xff0c;正处于技术创新的前沿。未来几年&#xff0c;Prompt工程将沿着多个新方向发展&#xff0c;这些方向不仅会改变我们与AI互动…
阅读更多...
Golang 高级面试题

Golang 高级面试题

在准备 Golang 高级面试时，通常会涉及到多种关键领域。本文将涵盖各个领域的具体问题示例和实现代码。 数据结构与算法 实现堆、链表、栈、队列、哈希表 1.最小堆： 最小堆是一种完全二叉树，树中每个节点的值都小于等于其子节点的值。常用于实现优先队列。 package main…
阅读更多...
Spring AI 第三讲Embeddings（嵌入式） Model API 第一讲OpenAI 嵌入

Spring AI 第三讲Embeddings（嵌入式） Model API 第一讲OpenAI 嵌入

Spring AI 支持 OpenAI 的文本嵌入模型。OpenAI 的文本嵌入测量文本字符串的相关性。嵌入是一个浮点数向量&#xff08;列表&#xff09;。两个向量之间的距离可以衡量它们之间的相关性。距离小表示关联度高&#xff0c;距离大表示关联度低。 先决条件 您需要与 OpenAI 创建一…
阅读更多...
Python怎么降雪：一场编程的奇幻之旅

Python怎么降雪：一场编程的奇幻之旅

Python怎么降雪&#xff1a;一场编程的奇幻之旅 在编程的世界里&#xff0c;我们通常与数字、逻辑和算法打交道&#xff0c;但今天&#xff0c;让我们打破常规&#xff0c;走进一个更加奇幻的领域——使用Python来模拟降雪的场景。这不仅是一场编程的挑战&#xff0c;更是一次…
阅读更多...
idm究竟有哪些优势

idm究竟有哪些优势

IDM&#xff0c;即Internet Download Manager&#xff0c;是一款功能强大的下载管理软件&#xff0c;具有许多优势。以下是IDM的主要优势&#xff1a; 加快下载速度&#xff1a;IDM采用多线程技术下载文件&#xff0c;能够同时分割文件并使用多个连接下载&#xff0c;从而大大提…
阅读更多...
【Linux】rsync远程数据同步工具使用

【Linux】rsync远程数据同步工具使用

一、rsync工具介绍 rsync是一个用于在本地或远程系统之间同步文件和目录的工具。它通过比较源和目标文件的元数据&#xff08;例如修改时间和大小&#xff09;来确定需要同步的内容&#xff0c;然后仅传输必要的数据进行更新&#xff0c;从而实现高效的同步操作。 rsync有如下特…
阅读更多...
Transformer学习之SwinTransformer

Transformer学习之SwinTransformer

1.算法简介 本文主要参考自以下链接&#xff0c;整理成线上的形式用于备忘&#xff0c;排版太麻烦了直接贴图&#xff0c;参考的朋友慎重&#xff0c;不如直接看参考链接&#xff0c;后期有了新的理解继续更正。 参考链接1&#xff1a;Swin-Transformer网络结构详解_swin tran…
阅读更多...
程序员如何转行成为一个漫画自媒体-连载2

程序员如何转行成为一个漫画自媒体-连载2

仿写关于如何撰写文案的内容如下&#xff1a; 如何编写文案&#xff1f; 从零开始自己创作显然效率过低&#xff0c;初期阶段还是需要从其他漫画公众号中学习技巧&#xff0c;然而只能看到最终成品&#xff0c;却无法获得他们的实际文案。 不过&#xff0c;通过广泛的阅读&…
阅读更多...
【文件导出2】导出html文件数据

【文件导出2】导出html文件数据

导出html文件数据 文章目录 导出html文件数据前言一、实现代码1.controller层2.接口层3.接口实现类4.FileUtil 工具类 二、文件导出效果总结 前言 springBoot项目实现在线导出html文件数据的功能。 一、实现代码 1.controller层 GetMapping("/record/_export") Ap…
阅读更多...
.NET4.8安装失败解决办法

.NET4.8安装失败解决办法

在windows 2008 r2 安装.net 4.8 &#xff0c;一开始下载 .net 4.8 的web 安装包&#xff0c;链接如下&#xff1a; https://download.visualstudio.microsoft.com/download/pr/2d6bb6b2-226a-4baa-bdec-798822606ff1/9b7b8746971ed51a1770ae4293618187/ndp48-web.exe 安装过…
阅读更多...
Flutter中同步与异步

Flutter中同步与异步

一&#xff0c;同步/异步的理解 1&#xff0c;await&#xff1a;同步机制 同步操作会阻止其他操作执行&#xff0c;直到完成为止。同步就好比打电话一样&#xff0c;打电话时都是一个人在说另一个人听&#xff0c;一个人在说的时候另一个人等待&#xff0c;等另一个人说完后再…
阅读更多...
【Git】远程操作 -- 详解

【Git】远程操作 -- 详解

一、理解分布式版本控制系统 我们目前所说的所有内容&#xff08;工作区、暂存区、版本库等等&#xff09;都是在本地&#xff0c;也就是在我们的笔记本或者计算机上。而我们的 Git 其实是分布式版本控制系统。 上面这段话是什么意思呢&#xff1f; 可以简单理解为&#xff1…
阅读更多...
最新文章

Copyright @ 2022~2023