# 通过外连接条件优化解决 MyBatis + PageHelper 分页统计不一致问题

在使用 MyBatis 和 PageHelper 进行分页查询时，外连接（如 `LEFT JOIN` 或 `RIGHT JOIN`）经常会因为连接条件不充分而引发笛卡尔积，导致分页统计的 `count` 结果与实际记录数不一致。通常这个问题发生在外连接的 `ON` 条件没有严格限定唯一性，从而造成了重复记录，影响了分页统计。

在本文中，我们将介绍如何通过在外连接的 `ON` 子句中添加多个条件来消除笛卡尔积，进而解决统计不一致的问题。



## 问题描述

假设我们有如下的查询，查询用户及其对应的部门信息：

```xml
<select id="selectUsers" resultType="User">
    SELECT u.*, d.dept_name 
    FROM users u
    LEFT JOIN department d ON u.dept_id = d.dept_id
    WHERE u.status = 'active'
</select>
```

这个查询中，`users` 表和 `department` 表通过 `LEFT JOIN` 连接，查询活跃状态的用户及其部门名称。通过 PageHelper 进行分页查询时，它会自动生成 `count` 查询来统计总记录数：

```sql
SELECT COUNT(1)
FROM users u
LEFT JOIN department d ON u.dept_id = d.dept_id
WHERE u.status = 'active'
```

由于外连接，`users` 表中的一条记录可能对应 `department` 表的多条记录，导致查询结果中产生重复数据，从而影响分页统计结果。具体表现为 `count` 结果与实际的用户记录数不一致。

## 解决方案：在 `ON` 子句中添加多个条件

为了消除笛卡尔积问题，我们可以在 `LEFT JOIN` 的 `ON` 子句中添加更多的条件，确保每个用户只匹配到唯一的部门信息。例如，如果用户的某个状态字段或者其他属性与部门有关，我们可以通过这些字段增加连接条件。

### 优化后的 SQL 例子

假设我们在 `users` 表中有一个 `join_status` 字段，它表示用户与部门的关系状态，那么我们可以优化 `JOIN` 的 `ON` 条件如下：

```xml
<select id="selectUsers" resultType="User">
    SELECT u.*, d.dept_name
    FROM users u
    LEFT JOIN department d ON u.dept_id = d.dept_id AND u.join_status = d.status
    WHERE u.status = 'active'
</select>
```

在这个优化后的查询中，除了 `u.dept_id = d.dept_id` 的连接条件，我们还增加了 `u.join_status = d.status`。这确保了只有那些满足部门状态相同的记录才会被连接，从而避免了产生重复记录。

### `count` 查询保持一致

通过添加额外的条件，分页查询和 `count` 查询可以保持一致，避免了笛卡尔积带来的统计误差：

```sql
SELECT COUNT(1)
FROM users u
LEFT JOIN department d ON u.dept_id = d.dept_id AND u.join_status = d.status
WHERE u.status = 'active'
```

通过优化连接条件，`count` 查询可以准确统计满足条件的用户记录数，而不会因为连接部门表而出现重复的用户记录。

## 更复杂的情况：多表连接

如果你的查询涉及到多个表的连接，并且这些表之间的关系比较复杂，类似的思路同样适用。你可以在每一个 `JOIN` 操作的 `ON` 子句中增加条件，确保每个表之间的连接是唯一和精确的。

例如，假设我们需要连接 `users` 表、`department` 表和 `roles` 表，我们可以通过为每个 `JOIN` 增加条件来避免笛卡尔积：

```xml
<select id="selectUsersWithRoles" resultType="User">
    SELECT u.*, d.dept_name, r.role_name
    FROM users u
    LEFT JOIN department d ON u.dept_id = d.dept_id AND u.join_status = d.status
    LEFT JOIN roles r ON u.role_id = r.role_id AND r.is_active = 1
    WHERE u.status = 'active'
</select>
```

在这个例子中，`users` 表和 `department` 表的连接条件不仅是 `dept_id`，还添加了 `join_status` 的匹配。类似的，`users` 表和 `roles` 表的连接条件也增加了角色的激活状态（`is_active = 1`）作为约束。

## 总结

当我们在 MyBatis + PageHelper 进行分页查询时，由于外连接的 `count` 查询可能会被优化，导致统计结果与实际数据不一致。通过在外连接的 `ON` 条件中添加更多的连接条件，我们可以有效消除笛卡尔积，确保查询结果的唯一性和准确性。具体步骤包括：

1. 在 `LEFT JOIN` 或其他连接类型的 `ON` 子句中，添加多个连接条件以确保连接数据的唯一性。
2. 确保 `count` 查询和数据查询使用相同的连接条件，避免不一致问题。
3. 对于多表连接，逐一检查每个 `JOIN` 的条件，确保避免产生重复数据。

通过这种方式，我们可以确保分页查询结果的正确性，并且 `count` 统计结果准确无误。希望这篇文章对你在处理分页查询时遇到的问题有所帮助。

---

这篇博客详细介绍了通过 `ON` 子句增加条件来解决分页 `count` 结果不准确的问题。你可以根据实际项目的需求进一步调整或扩展内容。

通过外连接条件优化解决 MyBatis + PageHelper 分页统计不一致问题

### 修改MySQL中表的排序规则：全局转换为utf8mb4

在MySQL中，字符集和排序规则对数据的存储和检索有着重要影响。使用utf8mb4字符集可以支持更广泛的Unicode字符，包括表情符号等。因此，在需要全局修改数据库中所有表的排序规则时，使用以下SQL查询可以帮助你实现这个目标。

#### 步骤1：生成ALTER TABLE语句



你可以使用下面的SQL语句生成ALTER TABLE命令，以便将所有表的字符集和排序规则转换为utf8mb4。

```sql
SELECT CONCAT('ALTER TABLE ', TABLE_NAME, ' CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;')
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA = 'your_database';
```

- **INFORMATION_SCHEMA.TABLES**: 这是一个系统表，包含了所有数据库和表的信息。
- **TABLE_SCHEMA**: 替换为你想要修改的数据库名。

#### 步骤2：执行生成的SQL语句

运行上述查询后，你将获得一系列ALTER TABLE命令。接下来，你可以将这些命令复制到你的MySQL客户端并逐个执行，或者将它们合并为一个脚本一次性执行。

#### 步骤3：验证修改

在执行完ALTER TABLE命令后，你可以使用以下查询验证每个表的字符集和排序规则是否已成功修改：

```sql
SELECT TABLE_NAME, CCSA.character_set_name, CCSA.collation_name
FROM INFORMATION_SCHEMA.TABLES T,
     INFORMATION_SCHEMA.COLLATION_CHARACTER_SET_APPLICABILITY CCSA
WHERE CCSA.collation_name = T.table_collation
  AND T.table_schema = 'your_database';
```

#### 注意事项

1. **备份数据**: 在进行全局修改之前，确保备份你的数据，以防万一出现意外情况。
2. **性能影响**: 对于大型数据库，执行ALTER TABLE可能会对性能产生影响。建议在低峰时段进行操作。
3. **外键约束**: 如果表之间存在外键约束，确保在修改字符集时不会违反这些约束。

通过以上步骤，你可以轻松地在MySQL中全局修改表的字符集和排序规则，确保你的数据库能够处理更丰富的字符集。希望这篇文章能对你有所帮助！

修改MySQL中表的排序规则：全局转换为utf8mb4

### MySQL 字符串字段存储纯数字时的隐式类型转换问题

在开发中，我们经常会遇到字符串字段存储纯数字的情况。通常，字符串字段用来存储文本信息，但是有时候，为了保持灵活性，某些数字信息（如订单号、电话号码等）也会被存储在 `VARCHAR` 或 `CHAR` 字段中。然而，当我们在查询这些字段时，如果不小心忽略了类型转换的细节，可能会出现意想不到的查询结果。这篇博客将详细介绍这个问题，并讨论如何避免它。

#### 1. 问题背景

假设我们有如下的 MySQL 表结构，其中 `num_str` 字段是 `VARCHAR` 类型，用来存储纯数字字符。



```sql
CREATE TABLE example (
    id INT AUTO_INCREMENT PRIMARY KEY,
    num_str VARCHAR(255)
);
```

现在我们向表中插入一些数据：

```sql
INSERT INTO example (num_str) VALUES ('123'), ('0123'), ('00123'), ('123abc');
```

这些看似不同的字符串包含纯数字或混合数字的内容。然后，我们尝试通过数字进行查询：

```sql
SELECT * FROM example WHERE num_str = 123;
```

**问题出现了：** 上述查询不仅会匹配到 `'123'`，还会匹配到 `'0123'`、`'00123'` 甚至 `'123abc'`。这是什么原因导致的呢？

#### 2. MySQL 隐式类型转换

在 MySQL 中，当我们对不同数据类型进行比较时，MySQL 会尝试将它们转换为相同的类型再进行比较。这被称为隐式类型转换。

具体到上面的例子，`num_str` 字段是字符串类型（`VARCHAR`），而查询时传入的 `123` 是一个数字。为了进行比较，MySQL 会尝试将字符串转换为数字进行匹配。

- `'123'` 会被转换为数字 `123`
- `'0123'` 会被转换为数字 `123`，忽略了前导的 `0`
- `'00123'` 也会被转换为 `123`
- `'123abc'` 由于以数字开头，它也会被转换为 `123`

因此，以上所有的字符串都被认为与数字 `123` 相等，从而被查询匹配到。

#### 3. 查询结果的不准确性

隐式类型转换可能会导致错误的查询结果。在实际应用中，我们可能期望的是精确的字符串匹配，而不是基于数字的模糊匹配。例如，如果我们需要查询确切的 `'123'`，而不是与数字 `123` 等效的所有值。

#### 4. 如何避免隐式类型转换问题

为了避免这种不准确的查询结果，最佳实践是在查询字符串字段时，始终将查询条件写为字符串，并使用引号包裹。这样可以确保 MySQL 直接进行字符串比较，而不会进行类型转换。

##### 示例 1：精确匹配字符串

```sql
SELECT * FROM example WHERE num_str = '123';
```

这个查询会只返回与 `'123'` 完全匹配的记录，而不会将 `'0123'`、`'00123'` 或 `'123abc'` 作为匹配结果。

##### 示例 2：模糊匹配字符串

如果你的需求是模糊匹配字符串，可以使用 `LIKE` 关键字：

```sql
SELECT * FROM example WHERE num_str LIKE '123%';
```

这个查询将返回所有以 `123` 开头的字符串，包括 `'123abc'`，但不会返回诸如 `'0123'` 或 `'00123'` 的记录。

#### 5. 总结

当 MySQL 处理字符串字段存储的纯数字时，如果我们在查询时不加引号，MySQL 会进行隐式类型转换，将字符串转换为数字进行比较。这种行为可能导致查询结果不准确，尤其是在我们需要精确匹配字符串的情况下。

为了解决这个问题，我们应该在查询字符串字段时，始终将查询条件作为字符串进行处理。通过这种方式，可以避免不必要的类型转换，并确保查询结果符合我们的预期。

**关键点总结：**
- 隐式类型转换会将字符串字段转为数字比较，导致多个字符串匹配同一数字。
- 查询时应使用引号包裹字符串字段，确保精确匹配。
- 需要模糊匹配时，可以使用 `LIKE` 查询。

通过遵循这些原则，可以有效避免 MySQL 字符串字段存储纯数字时出现的隐式类型转换问题，提高查询的准确性和可预期性。

MySQL 字符串字段存储纯数字时的隐式类型转换问题

## 使用 Spring Boot 整合 [MapStruct](https://mapstruct.org/) 的指南

### 一、前言
在 Java 开发中，DTO（Data Transfer Object）与实体类之间的转换通常是一个频繁的任务，尤其在构建复杂的应用时。手动进行转换不仅繁琐，还容易出错。为了提高开发效率并减少转换代码的冗余，我们可以使用 **MapStruct** —— 一个基于注解的 Java 对象映射框架，它能在编译时生成类型安全、性能优越的代码。

在这篇博客中，我将向大家展示如何在 **Spring Boot** 项目中整合 **MapStruct**，并通过具体示例介绍如何使用它进行对象的转换。

---

### 二、项目准备

#### 1. 创建 Spring Boot 项目



你可以通过 Spring Initializr 生成一个基本的 Spring Boot 项目，选择以下依赖：
- **Spring Web**
- **Lombok**
- **MapStruct**

#### 2. 添加依赖

如果你已经创建了项目，接下来需要在 `pom.xml` 中添加 **MapStruct** 相关依赖。

```xml
<dependencies>
    
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>1.5.3.Final</version>
    </dependency>

    
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>1.5.3.Final</version>
        <scope>provided</scope>
    </dependency>

    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.26</version>
        <scope>provided</scope>
    </dependency>
</dependencies>
```

#### 3. 配置 Maven 插件

为了确保 MapStruct 编译时生成代码，需要配置插件：

```xml
<build>
    <plugins>
        
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>11</source>
                <target>11</target>
                <annotationProcessorPaths>
                    <path>
                        <groupId>org.mapstruct</groupId>
                        <artifactId>mapstruct-processor</artifactId>
                        <version>${mapstruct.version}</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
```

---

### 三、MapStruct 的基本使用

#### 1. 创建实体类

首先，我们定义一个简单的 `User` 实体类，代表数据库中的用户信息。

```java
@Data
public class User {
    private Long id;
    private String username;
    private String email;
    private String date;
}
```

#### 2. 创建 DTO 类

接着创建一个与实体类相对应的 DTO 类，用于传输用户数据。

```java
@Data
public class UserDTO {
    private String username;
    private String email;
    private LocalDate date;
}
```

#### 3. 创建 Mapper 接口

使用 MapStruct 的核心是定义一个 `@Mapper` 接口。MapStruct 将会在编译时生成这个接口的实现类，接口中定义的默认`default`方法，在对象拷贝时，框架会自动根据参数和返回值自动调用。

```java
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper
public interface UserMapper {
    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

    UserDTO userToUserDTO(User user);
    
    User userDTOToUser(UserDTO userDTO);
    
    /**
     * 自定义属性名称相同类型不同的属性转换规则
     * 格式化字符串——》日期
     */
    default LocalDate mapStringToLocalDate(String value) {
        return LocalDate.parse(value);
    }
    
    /**
     * 自定义属性名称相同类型不同的属性转换规则
     * 日期——》格式化字符串
     */
    default LocalDate mapLocalDateToString(LocalDate value) {
        return value.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }
}
```

在上面的代码中，`UserMapper` 是一个接口，我们使用 `@Mapper` 注解来标记它。MapStruct 将自动生成实现这个接口的类。

#### 4. 测试 MapStruct

在编写完 Mapper 接口后，我们可以测试对象转换是否正确。

```java
public class UserMapperTest {

    public static void main(String[] args) {
        // 创建 User 实例
        User user = new User();
        user.setId(1L);
        user.setUsername("JohnDoe");
        user.setEmail("john.doe@example.com");

        // 使用 MapStruct 进行转换
        UserDTO userDTO = UserMapper.INSTANCE.userToUserDTO(user);

        System.out.println("UserDTO: " + userDTO);
    }
}
```

输出结果：
```plaintext
UserDTO: UserDTO(username=JohnDoe, email=john.doe@example.com)
```

这样，我们就完成了实体到 DTO 的转换。

---

### 四、在 Spring Boot 中整合 MapStruct

#### 1. Spring Boot 中使用 MapStruct

为了在 Spring Boot 项目中整合 MapStruct 并使其与 Spring 的依赖注入机制一起工作，我们需要在 `@Mapper` 注解中添加 `componentModel = "spring"` 配置。这样 MapStruct 生成的实现类将会成为 Spring 的 `Bean`，可以通过 `@Autowired` 注入。

```java
@Mapper(componentModel = "spring")
public interface UserMapper {
    UserDTO userToUserDTO(User user);

    User userDTOToUser(UserDTO userDTO);
}
```

#### 2. 使用 MapStruct 进行转换

现在我们可以在 Spring Boot 项目中通过依赖注入使用 MapStruct。

```java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    private final UserMapper userMapper;

    public UserController(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @GetMapping("/user")
    public UserDTO getUser() {
        // 模拟从数据库获取用户
        User user = new User();
        user.setId(1L);
        user.setUsername("JohnDoe");
        user.setEmail("john.doe@example.com");

        // 使用 MapStruct 转换为 DTO
        return userMapper.userToUserDTO(user);
    }
}
```

#### 3. 测试 Controller

启动 Spring Boot 项目，访问 `http://localhost:8080/user`，将会返回一个 `UserDTO` 的 JSON 对象：

```json
{
  "username": "JohnDoe",
  "email": "john.doe@example.com"
}
```

---

### 五、MapStruct 常用功能

#### 1. 自定义映射

如果字段名不同，可以使用 `@Mapping` 注解自定义字段的映射。例如：

```java
@Mapper(componentModel = "spring")
public interface UserMapper {
    @Mapping(source = "email", target = "emailAddress")
    UserDTO userToUserDTO(User user);
}
```

#### 2. 集合映射

MapStruct 还支持将集合进行映射：

```java
List<UserDTO> userToUserDTOList(List<User> users);
```

---

### 六、总结

通过 **MapStruct**，我们能够非常方便、快捷地实现对象之间的转换，极大减少了手写转换代码的繁琐。与 Spring Boot 整合后，通过依赖注入的方式，可以让转换逻辑更加简洁清晰。

#### 优点：
1. 编译时生成代码，性能优越。
2. 支持复杂映射规则，如字段名不同、嵌套对象等。
3. 简单易用，且与 Spring 无缝集成。

#### 使用场景：
- 实体类与 DTO 之间的相互转换。
- 需要进行批量转换时，如列表映射。

MapStruct 是处理对象映射的强大工具，适用于各种复杂项目中数据传输对象与实体对象的转换需求。

希望这篇文章能帮助大家更好地理解和使用 Spring Boot 与 MapStruct 的整合。如果你有任何疑问或建议，欢迎评论交流！

Spring Boot 整合 MapStruct 的指南

## RabbitMQ 工作原理及在 Spring Boot 中的应用

### 什么是 RabbitMQ？

RabbitMQ 是一个流行的开源消息代理软件，基于 AMQP（Advanced Message Queuing Protocol，高级消息队列协议）。它提供可靠的消息传递功能，支持多种消息模式和路由机制，常用于分布式系统和微服务架构中，用于解耦组件、实现异步处理和消息传递。

### RabbitMQ 的核心概念

在了解 RabbitMQ 的工作原理之前，我们需要熟悉以下核心概念：



- **消息（Message）**：在 RabbitMQ 中，消息是传递的数据单元，通常由生产者（Producer）发送，消费者（Consumer）接收。
- **生产者（Producer）**：消息的生成者，负责将消息发送到 RabbitMQ。
- **消费者（Consumer）**：消息的接收者，从 RabbitMQ 中获取消息并处理。
- **队列（Queue）**：消息的存储容器，消费者从队列中获取消息进行处理。
- **交换机（Exchange）**：消息的路由器，将消息路由到一个或多个队列。
- **绑定（Binding）**：交换机和队列之间的关系，定义了消息如何路由到队列。
- **路由键（Routing Key）**：消息的标识符，用于交换机路由消息到正确的队列。

:::info{title="相关信息"}
RabbitMQ的死信队列（Dead Letter Queue，DLQ）是处理未能成功消费或无法路由的消息的机制。通常情况下，消息会在队列中被消费者消费，但在某些情况下，消息无法被正常处理或消费，比如消费失败、消息过期等，此时这些“死信”消息会被转发到一个专门的“死信队列”中，用来做后续的分析或处理。
:::
### RabbitMQ 的工作流程

1. **生产者发送消息**：
   - 生产者应用程序将消息发送到 RabbitMQ。发送时，生产者指定了交换机，并可以附带一个路由键（如果交换机类型需要）。

2. **交换机路由消息**：
   - RabbitMQ 中的交换机根据其类型和绑定规则决定消息的路由。交换机将消息根据路由键和绑定规则路由到一个或多个队列。

3. **队列存储消息**：
   - 消息被路由到相应的队列后，队列会暂时存储这些消息，直到消费者将其取出。

4. **消费者接收消息**：
   - 消费者从队列中获取消息，并进行处理。处理完毕后，消费者会确认消息已被成功处理，RabbitMQ 会从队列中删除该消息。

### RabbitMQ 交换机类型

RabbitMQ 提供了四种主要的交换机类型，每种类型有不同的消息路由策略：

1. **Direct Exchange**
   - **定义**：精确匹配路由键的交换机。
   - **路由规则**：消息的路由键必须与绑定队列的路由键完全匹配。
   - **应用场景**：需要精确路由的场景，如将特定类型的消息发送到特定队列。

   ```java
   @Bean
   public DirectExchange directExchange() {
       return new DirectExchange("direct_exchange");
   }

   @Bean
   public Queue queue1() {
       return new Queue("queue1", true);
   }

   @Bean
   public Binding binding1() {
       return BindingBuilder.bind(queue1()).to(directExchange()).with("routing_key_1");
   }
   ```

2. **Fanout Exchange**
   - **定义**：广播型交换机。
   - **路由规则**：将消息广播到所有绑定到该交换机的队列，而不考虑路由键。
   - **应用场景**：将消息广播到多个队列，如广播通知或日志记录。

   ```java
   @Bean
   public FanoutExchange fanoutExchange() {
       return new FanoutExchange("fanout_exchange");
   }

   @Bean
   public Queue queue1() {
       return new Queue("queue1", true);
   }

   @Bean
   public Queue queue2() {
       return new Queue("queue2", true);
   }

   @Bean
   public Binding binding1() {
       return BindingBuilder.bind(queue1()).to(fanoutExchange());
   }

   @Bean
   public Binding binding2() {
       return BindingBuilder.bind(queue2()).to(fanoutExchange());
   }
   ```

3. **Topic Exchange**
   - **定义**：基于模式匹配的交换机。
   - **路由规则**：消息的路由键与队列的绑定模式进行匹配，支持通配符（如 `*` 和 `#`）。
   - **应用场景**：根据复杂模式进行消息路由，如按主题分类或灵活订阅。

   ```java
   @Bean
   public TopicExchange topicExchange() {
       return new TopicExchange("topic_exchange");
   }

   @Bean
   public Queue queue1() {
       return new Queue("queue1", true);
   }

   @Bean
   public Queue queue2() {
       return new Queue("queue2", true);
   }

   @Bean
   public Binding binding1() {
       return BindingBuilder.bind(queue1()).to(topicExchange()).with("news.#");
   }

   @Bean
   public Binding binding2() {
       return BindingBuilder.bind(queue2()).to(topicExchange()).with("sports.*");
   }
   ```

4. **Headers Exchange**
   - **定义**：根据消息头部属性进行路由的交换机。
   - **路由规则**：消息的头部属性与队列的绑定头部属性进行匹配，支持复杂的属性匹配。
   - **应用场景**：基于多个头部属性进行消息路由，如处理附加信息或元数据。

   ```java
   @Bean
   public HeadersExchange headersExchange() {
       return new HeadersExchange("headers_exchange");
   }

   @Bean
   public Queue queue() {
       return new Queue("queue", true);
   }

   @Bean
   public Binding binding() {
       Map<String, Object> headers = new HashMap<>();
       headers.put("header-key", "value");
       return BindingBuilder.bind(queue()).to(headersExchange()).whereAll(headers).match();
   }
   ```

### RabbitMQ 的消息确认机制

RabbitMQ 提供了多种消息确认机制，确保消息可靠传递：

- **消息确认（ACK）**：消费者处理消息后发送确认，RabbitMQ 会从队列中删除该消息。如果消费者未确认消息，RabbitMQ 会重新将消息投递到其他消费者。
- **事务机制**：通过 RabbitMQ 的事务机制，生产者可以确保消息的发送成功，但性能较低。
- **发布确认（Publisher Confirms）**：通过发布确认机制，生产者可以在消息成功发送到 RabbitMQ 时收到确认，提高了性能并确保消息传递的可靠性。

### RabbitMQ 的高可用性和集群

- **高可用性**：RabbitMQ 提供了镜像队列功能，通过将队列的副本分布在集群中的多个节点上来实现高可用性。即使一个节点故障，消息仍然可以在其他节点上找到。
- **集群**：RabbitMQ 支持集群模式，将多个 RabbitMQ 节点组合成一个集群，以提供更高的吞吐量和容错能力。集群中的节点可以共享队列和交换机信息。

### RabbitMQ 的管理和监控

- **管理界面**：RabbitMQ 提供了 Web 管理界面，可以方便地查看和管理 RabbitMQ 资源（如队列、交换机、绑定等）、监控消息流和性能。
- **监控插件**：RabbitMQ 提供了多种监控插件和工具，如 Prometheus 插件，可以用来监控 RabbitMQ 的性能和健康状态。

### 在 Spring Boot 中整合 RabbitMQ

Spring Boot 提供了对 RabbitMQ 的支持，使得在应用中集成 RabbitMQ 变得更加简单。下面是如何在 Spring Boot 中配置 RabbitMQ 的一个简单示例：

1. **添加依赖**

在 `pom.xml` 中添加 RabbitMQ 的 Spring Boot Starter 依赖：

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
```

2. **配置 RabbitMQ**

在 `application.properties` 或 `application.yml` 文件中配置 RabbitMQ 的连接信息：

```properties
spring.rabbitmq.virtual-host=dev # mq服务器vhost,默认为/
spring.rabbitmq.host=localhost # mq服务器ip,默认为localhost
spring.rabbitmq.port=5672 # mq服务器port,默认为5672
spring.rabbitmq.username=guest # mq服务器username,默认为gust
spring.rabbitmq.password=guest # mq服务器password,默认为guest
spring.rabbitmq.listener.simple.acknowledge-mode=manual #消费消息手动确认
```

```yml
spring:
  # rabbitmq消息队列配置
  rabbitmq:
    virtual-host: dev # mq服务器vhost,可以用来区分环境,默认为/
    host: localhost # mq服务器ip,默认为localhost
    port: 5672 # mq服务器port,默认为5672
    username: guest # mq服务器username,默认为gust
    password: guest # mq服务器password,默认为guest
    listener:
      simple:
        acknowledge-mode: manual #消费消息手动确认
```

3. **定义 RabbitMQ 组件**

在 Spring Boot 中定义交换机、队列和绑定（包含死信队列）：

```java
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    // 正常业务交换机
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("direct_exchange");
    }

    // 正常业务队列，并绑定死信队列的配置
    @Bean
    public Queue queue() {
        return QueueBuilder.durable("my_queue")
                // x-dead-letter-exchange、x-dead-letter-routing-key为rabbitmq规范
                .withArgument("x-dead-letter-exchange", "dlx_exchange")  // 死信交换机
                .withArgument("x-dead-letter-routing-key", "dlx_routing_key")  // 死信路由键
                .build();
    }

    // 正常业务队列与交换机绑定
    @Bean
    public Binding binding(Queue queue, DirectExchange directExchange) {
        return BindingBuilder.bind(queue).to(directExchange).with("my_routing_key").noargs();
    }

    // 死信交换机
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange("dlx_exchange");
    }

    // 死信队列
    @Bean
    public Queue dlxQueue() {
        return QueueBuilder.durable("dlx_queue").build();
    }

    // 死信队列与死信交换机绑定
    @Bean
    public Binding dlxBinding(Queue dlxQueue, DirectExchange dlxExchange) {
        return BindingBuilder.bind(dlxQueue).to(dlxExchange).with("dlx_routing_key").noargs();
    }
}
```

4. **生产者和消费者**

定义生产者和消费者来发送和接收消息：

```java
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired

;
import org.springframework.stereotype.Component;

@Component
public class MessageProducer {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sendMessage(String message) {
        amqpTemplate.convertAndSend("direct_exchange", "my_routing_key", message);
    }
}
```

```java
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;
import com.rabbitmq.client.Channel;

@Component
public class MessageConsumer {

    @RabbitListener(queues = "my_queue", ackMode = "MANUAL")
    public void receiveMessage(String message, Channel channel, Message amqpMessage) throws Exception {
        try {
            // 处理消息的逻辑
            System.out.println("Received message: " + message);
            
            // 手动确认消息（成功消费）
            channel.basicAck(amqpMessage.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            // 如果处理失败，可以拒绝消息并重新入队
            channel.basicNack(amqpMessage.getMessageProperties().getDeliveryTag(), false, true);
            System.err.println("Failed to process message, requeueing: " + e.getMessage());
        }
    }
}

```

### 总结

RabbitMQ 是一个功能强大且灵活的消息中间件，支持多种消息传递模式和路由机制。了解 RabbitMQ 的工作原理以及交换机类型，有助于设计和实现高效的消息传递系统。在 Spring Boot 中集成 RabbitMQ 可以简化开发过程，并充分发挥 RabbitMQ 的功能。希望本文能帮助你更好地理解 RabbitMQ 的工作原理以及如何在 Spring Boot 中进行应用。

通过外连接条件优化解决 MyBatis + PageHelper 分页统计不一致问题

修改MySQL中表的排序规则：全局转换为utf8mb4

步骤1：生成ALTER TABLE语句

MySQL 字符串字段存储纯数字时的隐式类型转换问题

1. 问题背景

使用 Spring Boot 整合 MapStruct 的指南

一、前言

二、项目准备

1. 创建 Spring Boot 项目

RabbitMQ 工作原理及在 Spring Boot 中的应用

什么是 RabbitMQ？

RabbitMQ 的核心概念