+ I wish you to become your own sun , no need to rely on who’s light. +
++ —— 愿你成为自己的太阳，无需凭借谁的光芒。 +
+| 1-1 | +1-2 | +1-3 | +|||
| 2-1 | +2-2 | +2-3 | +|||
| 3-1 | +3-2 | +3-3 | +|||
+
+### 2.Buffer的基本原理
+
+在谈到缓冲区时，我们说缓冲区对象本质上是一个数组，但它其实是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化，如果我们使用get()方法从缓冲区获取数据或者使用put()方法把数据写入缓冲区，都会引起缓冲区状态的变化
+在缓冲区中，最重要的属性有下面三个，它们一起合作完成对缓冲区内部装填的变化跟踪：
+
+position: 指定下一个将要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新创建一个Buffer对象时，position被初始化为0。
+
+limit: 指定还要多少数据需要取出（从缓冲区写入通道时），或者还有多少空间可以放入数据（在从通道读入缓冲区时）。
+
+capacity： 指定了可以存储在缓冲区中的最大数据容量，实际上，它指定了底层数组的大小，或者至少是指定了准许我们使用的底层数组的容量。
+
+以上三个属性之间有一些相对大小的关系：0 <= position <= limit <= capacity。如果我们创建一个新的容量大小为10的ByteBuffer对象，在初始化的时候，position设置为0，limit和capacity被设置为10，在以后使用ByteBuffer对象过程中，capacity的值不会再发生变化，而其它两个将会随着使用而变化。
+
+下面我们用代码来演示一遍，准备一个txt文档，存放的E盘，输入以下内容：
+test
+下面用一段代码来验证position,limit和capactiy这几个值的变化过程，代码如下：
+
+```java
+public class BufferDemo {
+ public static void main(String[] args) throws Exception {
+ //这里使用的是文件id处理
+ FileInputStream fin = new FileInputStream("E://test.txt");
+ //创建文件的操作管道
+ FileChannel fc = fin.getChannel();
+ //分配一个10个大小缓冲区，就是分配一个10个大小的byte数组
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+ output("初始化", buffer);
+ //先读取一下
+ fc.read(buffer);
+ output("调用read()", buffer);
+ //准备操作之前，先锁定操作范围
+ buffer.flip();
+ output("调用flip()", buffer);
+ //判断有没有可读数据
+ while (buffer.remaining() > 0){
+ byte b = buffer.get();
+ }
+ output("调用 get()", buffer);
+ //可以理解为解锁
+ buffer.clear();
+ output("调用clear()", buffer);
+ //最后把管道关闭
+ fin.close();
+
+ }
+
+ private static void output(String step, ByteBuffer buffer) {
+ System.out.println(step + ":");
+ //容量，数组大小
+ System.out.print("capacity: " + buffer.capacity() + ", " );
+ //当前操作数据所在的位置，也可以叫游标
+ System.out.print("position: " + buffer.position() + ", ");
+ //锁定值， flip, 数据操作范围索引只能在position - limit之间
+ System.out.println("limit: " + buffer.limit());
+ System.out.println();
+ }
+
+}COPY
+```
+
+完成的输出结果为：
+
+
+运行的结果我们可以看到，下面对以上结果进行图解，四个属性分别如图所示
+
+
+
+我们可以从通道中读取一些数据到缓冲区中，注意从通道读取数据，相当于往缓冲区中写入数据。如果读取4个自己的数据，则此时position的值为4，即下一个将要被写入的字节索引为4，而limit仍然是10，如下图所示：
+
+
+
+下一步把读取的数据写入到输出通道中，相当于从缓冲区中读取数据，在此之前，必去调用flip()方法，该方法将会完成两件事情：
+1.将limit设置为当前的position值
+2.把position设置为0
+由于position被设置为0，所以可以保证在下一步输出是读取到的是缓冲区中的第一个字节，而limit被设置为当前的position，可以保证读取的数据正好是之前写入到缓冲区中的数据， 如下图所示：
+
+
+现在调用get()方法从缓冲区中读取数据写入到输出通道，这会导致position的增加而limit保持不变，但position不会超过limit的值，所以在读取我们之前写入到缓冲区中的4个自己之后，position和limit的值都为4，如下图所示：
+
+
+在从缓冲区读取数据完毕后，limit的值仍然保持在我们调用flip()方法的值，调用clear()方法能够把所有的状态变化为初始化的值，如下图所示：
+
+
+### 3.缓冲区的分配
+
+在前面的几个例子中，我们已经看过了，在创建一个缓冲区对象时，会调用静态方法allocate()来指定缓冲区的容量，其实调用allocate()相当于创建一个指定大小的数组，并把它包装为缓冲区对象。或者我们也可以直接将一个现有的的数组，包装为缓冲区对象，如下实例所示：
+
+```java
+/**
+ * 手动分配缓冲区
+ */
+public class BufferWrap {
+
+ public void myMethod(){
+ //分配指定大小的缓冲区
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+ //包装一个现有的数组
+ byte array[] = new byte[10];
+ ByteBuffer buffer1 = ByteBuffer.wrap(array);
+ }
+}COPY
+```
+
+### 4.缓冲区分片
+
+在NIO中，除了可以分配或者包装一个缓冲区对象外，还可以根据现有的缓冲区对象创建一个子缓冲区，即在现有缓冲区上切出一片作为一个新的缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的，也就是说，子缓冲区相当于是现有缓冲区的一个视图窗口。调用slice()方法可以创建一个子缓冲区，让我们通过例子看一下：
+
+```java
+public class BufferSlice {
+
+ public static void main(String[] args) {
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+ //缓冲区的数据 0-9
+ for (int i=0; i < buffer.capacity(); i++){
+ buffer.put((byte)(i));
+ }
+
+ //创建子缓冲区
+ buffer.position(3);
+ buffer.limit(7);
+ ByteBuffer slice = buffer.slice();
+
+ //改变子缓冲区的内容
+ for (int i=0; i < slice.capacity(); i++){
+ byte b = slice.get(i);
+ b *= 10;
+ slice.put(i, b);
+ }
+
+ buffer.position(0);
+ buffer.limit(buffer.capacity());
+
+ while (buffer.remaining() > 0){
+ System.out.println(buffer.get());
+ }
+
+ }
+}COPY
+```
+
+在该示例中，分配了一个容量大小为10的缓冲区，并在其中放入数据0-9，而在该缓冲区基础上又创建一个子缓冲区，并改变子缓冲区的内容，从最后输出的结果来看，只有子缓冲区“可见的”那部分数据发生了变化，并且说明子缓冲区与原缓冲区时数据共享的，输出结果如下所示：
+
+
+### 5.只读缓冲区
+
+只读缓冲区非常简单，可以读取它们，但是不能向它们写入数据，可以通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区，并与原缓存取共享数据，只不过它是只读的，如果原缓冲区的内容发生了变化，只读缓冲区的内容也随之变化：
+
+```java
+public class ReadOnlyBuffer {
+
+ public static void main(String[] args) {
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+
+ //缓冲区的数据 0-9
+ for (int i=0; i< buffer.capacity(); i++){
+ buffer.put((byte)i);
+ }
+
+ //创建只读缓冲区
+ ByteBuffer readOnly = buffer.asReadOnlyBuffer();
+
+ //改变原缓冲区的内容
+ for (int i=0; i< buffer.capacity(); i++){
+ byte b = buffer.get(i);
+ b *= 10;
+ buffer.put(i, b);
+ }
+
+ readOnly.position(0);
+ readOnly.limit(buffer.capacity());
+ //只读缓冲区的内容也随之改变
+ while (readOnly.remaining() > 0){
+ System.out.println(readOnly.get());
+ }
+ }
+}
+COPY
+```
+
+如果尝试修改只读缓冲区的内容，则会报ReadOnlyBufferException异常。只读缓冲区对于保护数据很有用。在将缓冲区传递给某个对象方法时，无法知道这个方法是否会修改缓冲区中数据。创建一个只读的缓冲区可以保证该缓冲区不会被修改。只可以把常规缓冲区转换为只读缓冲区，而不能将只读的缓冲区转换为可写的缓冲区。
+
+### 6.直接缓冲区
+
+直接缓冲区是为加快I/O速度，使用一种特殊方式为其分配的内存的缓冲区，JDK文档中描述为：给定一个直接字节缓冲区，Java虚拟机将尽最大努力直接对它执行本机I/O操作。也就是说，它会在每一次调用底层操作系统的本机I/O操作之前（或之后），尝试避免将缓冲区的内容拷贝到一个中间缓冲区或者从一个中间缓冲区中拷贝内容。要分配直接缓冲区，需要调用allocateDirect()方法，而不是allocate()方法，使用方式与普通缓冲区并无区别，如下面的拷贝文件示例：
+
+```java
+public class DirectBuffer {
+ public static void main(String[] args) throws Exception {
+ //从磁盘上读取文件内容、
+ String infile = "E://test.txt";
+ FileInputStream fin = new FileInputStream(infile);
+ FileChannel fcin = fin.getChannel();
+
+ //把刚刚读取的内容写入到新的一个文件中
+ String outfile = String.format("E://testcopy.txt");
+ FileOutputStream fout = new FileOutputStream(outfile);
+ FileChannel fcout = fout.getChannel();
+
+ //使用allocateDirect ,而不是allocate
+ ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
+ while (true){
+ buffer.clear();
+ int r = fcin.read(buffer);
+ if (r == -1){
+ break;
+ }
+ buffer.flip();
+ fcout.write(buffer);
+ }
+ }
+}
+COPY
+```
+
+### 7.内存映射
+
+内存映射是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的I/O快的多。内存映射文件I/O是通过使文件中的数据出现为内存数组的内容来完成的，这其初听起来似乎不过就是将整个文件读到内存中，但是事实上并不是这样。一般来说只有文件中实际读取或者写入的部分才会映射到内存中g.如下面的示例代码：
+
+```java
+public class MappedBuffer {
+
+ private static final int start = 0;
+
+ private static final int size = 1024;
+
+ public static void main(String[] args) throws Exception {
+ RandomAccessFile raf = new RandomAccessFile("E://test.txt", "rw");
+ FileChannel fc = raf.getChannel();
+
+ //把缓冲区跟文件系统进行一个映射关联
+ //只要操作缓冲区里面的内容，文件内容也会跟着改变
+ MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, start, size);
+ mbb.put(0, (byte)97);
+ mbb.put(1023, (byte)122);
+ raf.close();
+ }
+
+}COPY
+```
+
+## 1.2选择器 Selector
+
+传统的Server/Client模式基于TPR(Thread Request),服务器会为每个客户请求建立一个线程，由该线程单独负责处理一个客户请求。这种模式带来的一个问题就是线程数量的剧增，大量的线程会增大服务器的开销。大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池线程的最大数量，这又带来了新的问题，如果线程池中有200个线程，而有200个用户都在进行大文件下载，会导致第201用户的请求无法及时处理，即便第201个用户想请求一个几kb大小的页面，传统的Server/Client模式如下图所示
+
+
+
+NIO 中非阻塞 I/O 采用了基于 Reactor 模式的工作方式，I/O 调用不会被阻塞，相反是注册感兴趣的特定 I/O 事件，如可读数据到
+达，新的套接字连接等等，在发生特定事件时，系统再通知我们。NIO 中实现非阻塞 I/O 的核心对象就是 Selector，Selector 就是
+注册各种 I/O 事件地方，而且当那些事件发生时，就是这个对象告诉我们所发生的事件，如下图所示：
+
+
+
+从图中可以看出，当有读或写等任何注册的事件发生时，可以从 Selector 中获得相应的 SelectionKey，同时从 SelectionKey 中可
+以找到发生的事件和该事件所发生的具体的 SelectableChannel，以获得客户端发送过来的数据。
+使用 NIO 中非阻塞 I/O 编写服务器处理程序，大体上可以分为下面三个步骤：
+
+1. 向 Selector 对象注册感兴趣的事件。
+2. 从 Selector 中获取感兴趣的事件。
+3. 根据不同的事件进行相应的处理。
+ 接下来我们用一个简单的示例来说明整个过程。首先是向 Selector 对象注册感兴趣的事件：
+
+
+
+创建了 ServerSocketChannel 对象，并调用 configureBlocking()方法，配置为非阻塞模式，接下来的三行代码把该通道绑定到指定
+端口，最后向 Selector 中注册事件，此处指定的是参数是 OP_ACCEPT，即指定我们想要监听 accept 事件，也就是新的连接发 生
+时所产生的事件，对于 ServerSocketChannel 通道来说，我们唯一可以指定的参数就是 OP_ACCEPT。
+从 Selector 中获取感兴趣的事件，即开始监听，进入内部循环：
+
+
+
+在非阻塞 I/O 中，内部循环模式基本都是遵循这种方式。首先调用 select()方法，该方法会阻塞，直到至少有一个事件发生，然后
+再使用 selectedKeys()方法获取发生事件的 SelectionKey，再使用迭代器进行循环。
+最后一步就是根据不同的事件，编写相应的处理代码：
+
+
+
+此处分别判断是接受请求、读数据还是写事件，分别作不同的处理。在 Java1.4 之前的 I/O 系统中，提供的都是面向流的 I/O
+系统，系统一次一个字节地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节的数据，面向流的
+I/O 速度非常慢，而在 Java 1.4 中推出了 NIO，这是一个面向块的 I/O 系统，系统以块的方式处理处理，每一个操作在
+一步中产生或者消费一个数据库，按块处理要比按字节处理数据快的多。
+
+## 1.3 通道Channel
\ No newline at end of file
diff --git "a/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/Nginx\347\232\204\351\205\215\347\275\256\345\222\214\344\275\277\347\224\250\345\221\275\344\273\244.md" "b/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/Nginx\347\232\204\351\205\215\347\275\256\345\222\214\344\275\277\347\224\250\345\221\275\344\273\244.md"
new file mode 100644
index 0000000..ecc20fa
--- /dev/null
+++ "b/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/Nginx\347\232\204\351\205\215\347\275\256\345\222\214\344\275\277\347\224\250\345\221\275\344\273\244.md"
@@ -0,0 +1,60 @@
+---
+title: Nginx的配置和使用命令
+date: 2022-07-26 13:10:15
+updated:
+categories:
+- 学习
+tags:
+- 服务器
+- Nginx
+keywords:
+- 服务器
+- Nginx
+description: 安装和简单使用Nginx部署项目
+cover: https://uzbox.com/wp-content/uploads/2022/04/e5b0bc8d2560c94ecf913d99525b6525.png
+top_img: https://wtit.com/wp-content/uploads/2022/01/WTIT-header-NGINX.png
+---
+
+### 1、配置文件地址
+
+```
+/opt/homebrew/etc/nginx/nginx.conf
+```
+
+### 2、bin目录
+
+```
+/opt/homebrew/Cellar/nginx/1.23.1/bin
+```
+
+### 3、前端页面地址
+
+```
+/opt/homebrew/var/www
+```
+
+### 4、启动nginx
+
+```shell
+sudo nginx
+```
+
+### 5、关闭nginx
+
+```shell
+sudo nginx -s stop
+```
+
+### 6、解决跨域
+
+```
+ server {
+ listen 8080;
+ server_name 192.168.0.114; #前端主机地址，我前后端都部署在局域网同一电脑上
+
+ location / {
+ root html/dist;
+ index index.html index.htm;
+ proxy_pass 192.168.0.114; #后端主机地址
+ }
+```
diff --git "a/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/Quarkus\344\272\221\345\216\237\347\224\237\346\227\266\344\273\243\347\232\204Java\346\241\206\346\236\266.md" "b/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/Quarkus\344\272\221\345\216\237\347\224\237\346\227\266\344\273\243\347\232\204Java\346\241\206\346\236\266.md"
new file mode 100644
index 0000000..f0c3132
--- /dev/null
+++ "b/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/Quarkus\344\272\221\345\216\237\347\224\237\346\227\266\344\273\243\347\232\204Java\346\241\206\346\236\266.md"
@@ -0,0 +1,201 @@
+---
+title: Quarkus——云原生时代的Java框架
+date: 2024-08-15 10:26:00
+updated: 2024-08-15 10:26:00
+categories:
+- 学习
+tags:
+- Quarkus
+- 云原生
+keywords:
+- Quarkus
+- 云原生
+description: Quarkus——云原生时代的Java框架
+cover: https://cdn.jsdelivr.net/gh/01Petard/imageURL@main/img/202410212154303.png
+top_img: https://cdn.jsdelivr.net/gh/01Petard/imageURL@main/img/202410212153128.png
+---
+# Quarkus: 云原生时代的Java框架
+
+## 云原生简介
+
+### 什么是云原生？
+
+云原生体系结构和技术是一种方法，用于设计、构造和操作在云中构建并充分利用云计算模型的工作负载。
+云原生技术有利于各组织在公有云、私有云和混合云等新型动态环境中，构建和运行可弹性扩展的应用。
+
+### 云原生的代表技术
+
+#### 微服务
+
+云原生系统采用微服务，而微服务是一种用于构造新式应用程序的常用体系结构样式。
+微服务构建为一组通过共享结构进行交互的分布式小型独立服务，共同具有以下特征：
+
+- 各自都在较大的域上下文中实现特定业务功能。
+
+- 各自都自主开发，可以独立部署。
+
+- 各自都是独立的，封装其自己的数据存储技术、依赖项和编程平台。
+
+- 各自都在自己的进程中运行，并使用 HTTP/HTTPS、gRPC、WebSocket 或 AMQP 等标准通信协议与其他微服务进行通信。
+
+- 它们组合在一起形成应用程序。
+
+ #### 容器
+
+ 容器是与系统其他部分隔离开的一系列进程
+ 容器提供进程级的隔离，可以将操作系统管理的资源划分到相互隔离的组中，在相互隔离的组之间解决资源使用存在冲突的问题
+ 容器是微服务的最佳载体，Docker是使用最广泛的一种容器技术。
+
+ #### Kubernetes
+
+ Kubernetes用于编排管理容器的生命周期，是整个云原生的基石，云原生的整个生态体系都是依靠Kubernetes建立起来的。
+ Kubernetes作为云应用的部署标准，直接面向业务应用，大大提高了云应用的可移植性，解决云厂商锁定的问题，让云应用可以在跨云之间无缝迁移，甚至用来管理混合云，成为企业 IT 云平台的新标准。
+
+#### 服务网格
+
+服务网格(Service Mesh)，是指用以处理服务与服务之间通信的基础设施层。
+服务网格 核心是业务逻辑与非业务逻辑解耦，实现开发只需关注业务逻辑的实现。将一大堆和业务逻辑无关的客户端 SDK（如服务发现，路由，负载均衡，限流降级等）从业务应用中剥离出来，放到单独的 Proxy（Sidecar） 进程中，之后下沉到基础设施中间件 Mesh（类似 TDDL 到 DRDS 的模式）。
+服务网格的出现弥补了Kubernetes在微服务的连接、管理和监控方面的短板，为Kubernetes提供更好的应用和服务管理。
+Istio是是目前最广为人知的一款服务网格架构。
+
+### 云原生的优点
+
+#### 快速迭代
+
+利用云原生应用程序开发，使得交付团队可以使用重复的自动化和编排来快速迭代，让开发人员有更多的精力聚焦于业务开发上。
+
+#### 自动部署
+
+相比于传统方法需要投入大量的精力来构建开发环境，云原生架构具备自动化和组合功能，交付十分敏捷，而不再需要人工干预重复执行。
+
+#### 独立高效
+
+云原生将应用程序代码解耦成独立模块化单元，降低微服务的部属时间与互依性，提高应用的扩展性等。
+
+## Java在云原生时代的挑战
+
+### Java的优势
+
+- 庞大的生态，丰富的插件，活跃的社区；
+- 平台无关性，一次运行，处处运行；
+- 垃圾回收机制，不用手动回收内存；
+
+### Java的劣势
+
+- 依赖JDK
+- 启动慢
+- 资源占用率高
+
+## Quarkus
+
+### 什么是Quarkus
+
+Quarkus 是专为 OpenJDK HotSpot 和 GraalVM 定制的全栈 Kubernetes 原生 Java 应用程序框架。与如 Spring 之类的其他框架相比，它提供了较小的内存占用并缩短了启动时间。它允许结合命令式和非阻塞响应式编程。
+
+
+### Quarkus的特性
+
+
+
+### Quarkus与传统Java应用的启动步骤对比
+
+- 传统应用的启动步骤
+ 
+- Quarkus应用的启动步骤
+ 
+
+### Quarkus功能介绍
+
+
+
+### 将应用从SpringBoot 迁移到Quarkus
+
+#### 依赖替换
+
+- `io.quarkus:quarkus-spring-boot-properties`: 使用注释如`@ConfigurationProperties`时需要;
+- `io.quarkus:quarkus-spring-di`：使用注释如`@Service`、`Configuration`时需要;
+- `io.quarkus:quarkus-spring-web`：使用注释如`@RestController`、`GetMapping`时需要;
+
+#### 类替换
+
+
+
+#### 注解替换
+
+
+
+#### 异常处理替换
+
+- SpringBoot
+
+ ```java
+ import javax.ws.rs.WebApplicationException;
+ import javax.ws.rs.core.Response;
+ import javax.ws.rs.ext.ExceptionMapper;
+ import javax.ws.rs.ext.Provider;
+ @Provider
+ public class UncaughtExceptionMapper implements ExceptionMapper
+- 启动运行`java -jar -Dserver.port=3050 target/wakatime-sync.jar
+ 
+
+#### Quarkus工程
+
+- 打包 `mvn package -Dnative`
+ 
+- 打包后产物
+ 
+- 启动`./target/wakatime-sync-1.0-runner`
+ 
+
+### Quarkus的局限性和缺点
+
+- 动态类加载
+- 反射
+- 动态代理
+- JNI
+- Java 安全管理器
+- 编译原生镜像耗时且占用资源较多
+- 生成的镜像没法做到**一处编译，处处运行**
+- 虽然社区活跃，支持的插件已有100多个，但相比Spring生态来说还是远远不够，需要插件都需要自己开发
+
+## 参考阅读
+
+1. [GraalVM指南](https://www.graalvm.org/22.1/guides/)
+2. [Quarkus指南](https://cn.quarkus.io/guides/)
+3. [Quarkus插件社区](https://github.com/quarkiverse)
+4. [Quarkus实战教程](https://quarkus.io/quarkus-workshops/super-heroes/)
+5. [原生镜像兼容性和优化指南](https://www.graalvm.org/22.1/reference-manual/native-image/Limitations/)
\ No newline at end of file
diff --git "a/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/RabbitMQ\345\277\253\351\200\237\344\270\212\346\211\213.md" "b/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/RabbitMQ\345\277\253\351\200\237\344\270\212\346\211\213.md"
new file mode 100644
index 0000000..69523e2
--- /dev/null
+++ "b/docs/\345\274\200\345\217\221/\346\241\206\346\236\266/RabbitMQ\345\277\253\351\200\237\344\270\212\346\211\213.md"
@@ -0,0 +1,174 @@
+---
+title: RabbitMQ快速上手
+date: 2024-06-29 15:24:00
+updated: 2024-10-26 15:39:00
+categories:
+- 学习
+tags:
+- RabbitMQ
+- 消息队列
+keywords:
+- RabbitMQ
+- 消息队列
+description: RabbitMQ快速上手
+cover: https://www.meshiq.com/wp-content/uploads/rabbitmq.png
+top_img: https://cdn.jsdelivr.net/gh/01Petard/imageURL@main/img/202410212159254.png
+---
+
+#### 常见的交换机类型：
+
+- **Direct Exchange**：直连交换机。消息会被路由到所有`路由键`与`绑定队列`。
+- **Fanout Exchange**：广播交换机。消息会被路由到所有`绑定队列`，忽略路由键。
+- **Topic Exchange**：主题交换机。消息会被路由到所有`绑定队列`，支持通配符。
+
+最简单的消息队列只需要`生产者类`和`消费者类`，如下：
+
+```java
+@SpringBootTest
+public class RabbitProducer {
+
+ @Test
+ public void testSimpleQueue() {
+ // 创建连接工厂
+ CachingConnectionFactory connectionFactory = new CachingConnectionFactory("192.168.20.80");
+ connectionFactory.setUsername("leke");
+ connectionFactory.setPassword("leke@@@");
+ // 创建 RabbitTemplate
+ RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
+ // 发送消息
+ rabbitTemplate.convertAndSend("e.test", "q.test", "hello, spring amqp!");
+
+ }
+}
+
+
+@Component
+public class RabbitConsumer {
+ // 表明监听的队列名称
+ @RabbitListener(bindings = @QueueBinding(
+ value = @Queue(value = "q.test", durable = "true"),
+ exchange = @Exchange(value = "e.test")))
+ public void listenSimpleQueueMessage(String msg) {
+ //3、打印消息，模拟处理消息
+ System.out.println("spring 消费者接收到消息：【" + msg + "】");
+ }
+
+}
+```
+
+
+
+**但从项目设计角度出发，我们需要这样使用消息队列，如下：**
+
+`RabbitMqConstant`常量类：存放交换机名称和队列名称
+
+```java
+public class RabbitMqConstant {
+
+ public static final String TEST_EXCHANGE = "e.test";
+ public static final String TEST_QUEUE = "q.test";
+
+}
+```
+
+`RabbitConfig`配置类：注册交换机类和队列类，绑定交换机和队列（如果采用注解绑定，可以不写）
+
+```java
+public class RabbitConfig {
+ @Bean
+ public DirectExchange testExchange() {
+ return new DirectExchange(RabbitMqConstant.TEST_EXCHANGE);
+ }
+
+ @Bean
+ public Queue testQueue() {
+ return new Queue(RabbitMqConstant.TEST_QUEUE);
+ }
+
+ @Bean
+ public Binding testBinding() {
+ return BindingBuilder.bind(testQueue())
+ .to(testExchange())
+ .with(RabbitMqConstant.TEST_QUEUE);
+ }
+
+ // 其他的配置，例如配置消息监听容器工厂。以下代码定义了如何处理消息消费过程中的异常情况，特别是通过自定义的异常策略来控制消息的重试逻辑，增强了消息处理的健壮性和灵活性。
+ @Bean
+ public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
+ SimpleRabbitListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) {
+ SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
+ configurer.configure(factory, connectionFactory);
+ @SuppressWarnings("unchecked")
+ FatalExceptionStrategy strategy = LekeFatalExceptionStrategy.retryOn(DataAccessException.class,
+ RemoteAccessException.class, Exception.class);
+ factory.setErrorHandler(new ConditionalRejectingErrorHandler(strategy));
+ return factory;
+ }
+}
+class FatalExceptionStrategy extends DefaultExceptionStrategy {
+
+ // 构建策略
+ @SuppressWarnings("unchecked")
+ public static FatalExceptionStrategy retryOn(Class... exClasses) {
+ Set