### 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 中进行应用。

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

### Spring Boot 整合 WebSocket 教程

在这篇博客中，我将详细介绍如何使用 Spring Boot 整合 WebSocket，并实现消息推送功能。我们将使用 `@EnableWebSocketMessageBroker` 注解来配置 WebSocket，使用 `SimpMessagingTemplate` 发送消息。前端将使用 `vue.min.js`、`sockjs.min.js` 和 `stomp.min.js` 实现与后端的通信。

#### 一、项目依赖

首先，在 `pom.xml` 中添加所需的依赖：

```xml
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
    
</dependencies>
```
或
```gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-websocket'
    // 其他依赖
}
```



#### 二、WebSocket 配置

创建一个 WebSocket 配置类，使用 `@EnableWebSocketMessageBroker` 注解：

```java
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    public final static String BASE_URL = "/topic";

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 注册的端点
        registry.addEndpoint("/ws")
                .setAllowedOrigins("*")
                .withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setPreservePublishOrder(true)
                .enableSimpleBroker(BASE_URL);//订阅Broker名称
    }
}
```

#### 三、WebSocket 工具类

创建一个websocket发送消息工具类：

```java
import com.alibaba.fastjson.JSON;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Component;

@Component
public class WebSocketUtil {

    private static SimpMessagingTemplate template;

    public WebSocketUtil(SimpMessagingTemplate messagingTemplate) {
        template = messagingTemplate;
    }

    /**
     * 推送消息
     *
     * @param suffixUrl 路径后缀
     * @param flag      标识
     * @param msg       消息内容
     */
    public static void sendMsg(String suffixUrl, String flag, Object msg) {
        String path = BASE_URL + suffixUrl;
        if (StrUtil.isNotBlank(flag)) {
            path += "/" + flag;
        }
        template.convertAndSend(path, JSON.toJSONString(msg));
    }
}
```

#### 四、消息接收和发送

创建一个websocket消息控制器：

```java
import lombok.extern.slf4j.Slf4j;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@CrossOrigin("*")
public class WebSocketController {

    @MessageMapping("/toServer")
    public void sendMsg(String msg, @Header("token") String token) {
        log.info("请求接收到的消息为：{}", msg);
        WebSocketUtil.sendMsg("/toClient", "1805473892329054222", "客户端你好！我是服务端");
    }
}
```

#### 五、前端实现

前端我们使用 Vue.js 结合 SockJS 和 STOMP.js 实现 WebSocket 通信。首先，确保引入必要的库：

```html
<script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1.4.0/dist/sockjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/stompjs@2.3.3/lib/stomp.min.js"></script>
```
工具封装
```js
import SockJS from 'sockjs-client'
import Stomp from 'stompjs'
import { getToken } from '@/utils/auth'

class WebSocketUtil {
    constructor() {
        this.socket = null;
        this.broker = '/topic'
        this.stompClient = null;
        this.connected = false;
        this.token = getToken()
        this.headers = {
            token: this.token
        }
    }

    connect(callback) {
        // 使用代理后的WebSocket URL
        const socketUrl = "/business/ws"; // 代理配置会将/api/ws 转发到 http://127.0.0.1:23001/ws
        this.socket = new SockJS(socketUrl);
        this.stompClient = Stomp.over(this.socket);
        this.stompClient.connect(this.headers, frame => {
            this.connected = true
            callback()
        }, error => {
            console.error('Error: ' + error);
        });
    }

    subscribe(destination, callback) {
        if (this.connected) {
            this.stompClient.subscribe(this.broker + destination, (message) => {
                callback(JSON.parse(message.body))
            });
        } else {
            console.error('WebSocket is not connected, subscribe fail.');
        }
    }

    connectAndSubscribe(destination, callback) {
        // 使用代理后的WebSocket URL
        const socketUrl = "/api/business/ws"; // 代理配置会将/api/ws 转发到 http://127.0.0.1:23001/ws
        this.socket = new SockJS(socketUrl);
        this.stompClient = Stomp.over(this.socket);
        this.stompClient.connect(this.headers, frame => {
            console.log('Connected: ' + frame);
            this.connected = true
            if (this.connected) {
                this.stompClient.subscribe(this.broker + destination, message => {
                    callback(message);
                });
            } else {
                console.error('WebSocket is not connected, subscribe fail.');
            }
        }, error => {
            console.error('Error: ' + error);
        });
    }

    send(destination, message) {
        if (this.connected) {
            this.stompClient.send(destination, this.headers, JSON.stringify(message))
        } else {
            console.error('WebSocket is not connected, send fail.');
        }
    }

    disconnect() {
        if (this.stompClient !== null) {
            this.stompClient.disconnect();
        }
        this.connected = false;
        console.log('Disconnected');
    }
}

// 导出实例
export default new WebSocketUtil();
```

main.js全局配置
```js
// 工具类申明
import WebSocketUtil from '@/utils/websocket'
// 将 WebSocketUtil 实例添加到 Vue 原型上
Vue.prototype.$webSocketUtil = WebSocketUtil;
```


接下来，编写 Vue 组件来实现 WebSocket 通信：

```html
<div id="app">
    <h1>WebSocket 测试</h1>
    <div>
        <label for="message">消息内容：</label>
        <input type="text" v-model="message" id="message">
        <button @click="sendMessage">发送消息</button>
    </div>
    <div>
        <h2>收到的消息：</h2>
        <ul>
            <li v-for="msg in messages" :key="msg">{{ msg }}</li>
        </ul>
    </div>
</div>

<script>
export default {
  data() {
    return {
    }
  },
  mounted() {
    init()
  },
  methods: {
    init() {
      this.$webSocketUtil.connect(() => {
          this.$webSocketUtil.subscribe('/toClient', (response) => {
              console.log(response);
              this.messages.push(response.body);
          });
      })
    },
    sendMessage() {
      this.$webSocketUtil.send('/toServer', this.message)
    }
  }
}
</script>
```

以上就是使用 Spring Boot 整合 WebSocket 的完整示例。希望这篇教程对你有所帮助！

Spring Boot 整合 WebSocket 教程

# MyBatis-Flex 安装与配置使用指南

MyBatis-Flex 是一个轻量级、高效的 MyBatis 增强工具，它在 MyBatis 的基础上增加了一些便捷的功能，帮助开发者更加高效地操作数据库。在这篇博客中，我们将介绍如何安装、配置和使用 MyBatis-Flex。

## 一、安装 MyBatis-Flex

### 1. 引入 Maven 依赖

首先，在你的项目的 `pom.xml` 文件中添加 MyBatis-Flex 的依赖：



```xml
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-spring-boot3-starter</artifactId>
    <version>${mybatisFlexVersion}</version>
</dependency>
```

### 2. 配置数据库连接

在 `application.properties` 文件中配置数据库连接信息：

```properties
spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
```

## 二、配置 MyBatis-Flex

### 1. 配置 Spring Boot 和 MyBatis

在 `application.properties` 文件中添加 MyBatis 配置：

```properties
mybatis.config-location=classpath:mybatis-config.xml
mybatis.mapper-locations=classpath:mapper/*.xml
```

### 2. 启动类添加注解

在 Spring Boot 的启动类上添加 `@MapperScan` 注解，指定 Mapper 接口所在的包：

```java
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.project.mapper")
public class MybatisFlexApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisFlexApplication.class, args);
    }
}
```

### 3. 自动填充配置

有些时候，我们会定义实体类的基类，而基类的属性希望自动填充，这时候使用自动填充就能达到想要的效果

- 基类

```java
package com.yilian.manage.base.entity;

import cn.hutool.core.bean.BeanUtil;
import com.mybatisflex.annotation.Column;
import com.mybatisflex.annotation.Id;
import com.mybatisflex.annotation.KeyType;
import com.mybatisflex.core.keygen.KeyGenerators;
import com.mybatisflex.core.paginate.Page;
import lombok.Data;

import java.io.Serial;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * 实体类基类
 *
 * @author JACK WEI
 * @createDate 2023-02-02 11:59:15
 */
@Data
public abstract class BaseEntity implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 记录编号
     */
    @Id(keyType = KeyType.Generator, value = KeyGenerators.snowFlakeId)
    private Long id;

    /**
     * 创建人
     */
    @Column
    private Long createUser;

    /**
     * 创建时间
     */
    @Column
    private LocalDateTime createTime;

    /**
     * 更新人
     */
    @Column
    private Long updateUser;

    /**
     * 更新时间
     */
    @Column
    private LocalDateTime updateTime;

    /**
     * 状态：false 停用、true 启用
     */
    @Column
    private Boolean status;

    /**
     * 是否删除：false 否、true 是
     */
    @Column(isLogicDelete = true)
    private Boolean deleted;

    /**
     * entity转respVO
     *
     * @param entity           实体类
     * @param respClass        respVO类class
     * @param biConsumer       entity和respVO自定义操作
     * @param ignoreProperties 忽略字段
     * @return 响应体
     */
    public static <E, T> T buildOther(E entity, Class<T> respClass, BiConsumer<E, T> biConsumer, String... ignoreProperties) {
        T t = BeanUtil.copyProperties(entity, respClass, ignoreProperties);
        if (Objects.nonNull(entity)) {
            biConsumer.accept(entity, t);
        }
        return t;
    }

    /**
     * entity集合转respVO集合
     *
     * @param entityCollection 实体类集合
     * @param respClass        respVO类class
     * @return 集合响应体
     */
    public static <E, T> List<T> buildOther(Collection<E> entityCollection, Class<T> respClass) {
        return BeanUtil.copyToList(entityCollection, respClass);
    }

    /**
     * entity集合转respVO集合
     *
     * @param entityCollection 实体类集合
     * @param respClass        respVO类class
     * @param respConsumer     respVO自定义操作
     * @return 集合响应体
     */
    public static <E, T> List<T> buildOther(Collection<E> entityCollection, Class<T> respClass, Consumer<T> respConsumer) {
        List<T> rList = BeanUtil.copyToList(entityCollection, respClass);
        rList.forEach(respConsumer);
        return rList;
    }

    /**
     * entity集合转respVO集合
     *
     * @param tCollection 实体类集合
     * @param rClass      respVO类class
     * @param biConsumer  entity和respVO自定义操作
     * @return 集合响应体
     */
    public static <E, T> List<T> buildOther(Collection<E> tCollection, Class<T> rClass, BiConsumer<E, T> biConsumer) {
        tCollection.forEach(Entity -> biConsumer.accept(Entity, null));
        List<T> tList = BeanUtil.copyToList(tCollection, rClass);
        tList.forEach(resp -> biConsumer.accept(null, resp));
        return tList;
    }

    /**
     * entity分页转respVO分页
     *
     * @param entityPageResp 实体类分页
     * @param respClass      respVO类class
     * @return 分页响应体
     */
    public static <E, T> Page<T> buildOther(Page<E> entityPageResp, Class<T> respClass) {
        Page<T> rPageResp = new Page<>();
        BeanUtil.copyProperties(entityPageResp, rPageResp);
        rPageResp.setRecords(BeanUtil.copyToList(entityPageResp.getRecords(), respClass));
        return rPageResp;
    }

    /**
     * entity分页转respVO分页
     *
     * @param entityPageResp 实体类分页
     * @param rClass         respVO类class
     * @param respConsumer   respVO自定义操作
     * @return 分页响应体
     */
    public static <E, T> Page<T> buildOther(Page<E> entityPageResp, Class<T> rClass, Consumer<T> respConsumer) {
        Page<T> rPageResp = new Page<>();
        BeanUtil.copyProperties(entityPageResp, rPageResp);
        rPageResp.setRecords(BeanUtil.copyToList(entityPageResp.getRecords(), rClass));
        rPageResp.getRecords().forEach(respConsumer);
        return rPageResp;
    }

    /**
     * entity分页转respVO分页
     *
     * @param entityPageResp 实体类分页
     * @param respClass      respVO类class
     * @param biConsumer     entity和respVO自定义操作
     * @return 分页响应体
     */
    public static <E, T> Page<T> buildOther(Page<E> entityPageResp, Class<T> respClass, BiConsumer<E, T> biConsumer) {
        entityPageResp.getRecords().forEach(entity -> biConsumer.accept(entity, null));
        Page<T> rPageResp = new Page<>();
        BeanUtil.copyProperties(entityPageResp, rPageResp);
        rPageResp.setRecords(BeanUtil.copyToList(entityPageResp.getRecords(), respClass));
        rPageResp.getRecords().forEach(resp -> biConsumer.accept(null, resp));
        return rPageResp;
    }

    /**
     * entity转respVO
     *
     * @param rClass           需要转换的类
     * @param ignoreProperties 忽略字段
     * @return 响应体
     */
    public <T> T buildOther(Class<T> rClass, String... ignoreProperties) {
        return BeanUtil.copyProperties(this, rClass, ignoreProperties);
    }

    /**
     * entity转respVO
     *
     * @param respClass        respVO类class
     * @param respConsumer     respVO自定义操作
     * @param ignoreProperties 忽略字段
     * @return 响应体
     */
    public <T> T buildOther(Class<T> respClass, Consumer<T> respConsumer, String... ignoreProperties) {
        T t = BeanUtil.copyProperties(this, respClass, ignoreProperties);
        respConsumer.accept(t);
        return t;
    }

}

```
- 自动填充配置类
```java
package com.yilian.manage.config;

import com.mybatisflex.annotation.InsertListener;
import com.mybatisflex.annotation.UpdateListener;
import com.mybatisflex.core.FlexGlobalConfig;
import com.yilian.manage.base.entity.BaseEntity;
import com.yilian.manage.util.UserUtil;
import org.springframework.context.annotation.Configuration;

import java.time.LocalDateTime;

/**
 * 数据持久化时，自动填充的字段
 *
 * @author JACK WEI
 * @createDate 2023-02-02 13:56:24
 */
@Configuration
public class MybatisFlexConfig implements InsertListener, UpdateListener {

    public MybatisFlexConfig() {
        FlexGlobalConfig defaultConfig = FlexGlobalConfig.getDefaultConfig();
        defaultConfig.registerInsertListener(this, BaseEntity.class);
        defaultConfig.registerUpdateListener(this, BaseEntity.class);
    }


    /**
     * 被新增时做一些前置操作
     */
    @Override
    public void onInsert(Object o) {
        BaseEntity baseEntity = (BaseEntity) o;
        baseEntity.setCreateUser(UserUtil.getCurrentUser().getId());
        baseEntity.setCreateTime(LocalDateTime.now());
        baseEntity.setUpdateUser(UserUtil.getCurrentUser().getId());
        baseEntity.setUpdateTime(LocalDateTime.now());
        baseEntity.setStatus(Boolean.TRUE);
        baseEntity.setDeleted(Boolean.FALSE);
    }

    /**
     * 被更新时做一些前置操作
     */
    @Override
    public void onUpdate(Object o) {
        BaseEntity baseEntity = (BaseEntity) o;
        baseEntity.setUpdateUser(UserUtil.getCurrentUser().getId());
        baseEntity.setUpdateTime(LocalDateTime.now());
    }

}

```

## 三、使用 MyBatis-Flex

### 1. 创建实体类

在 `com.example.project.model` 包下创建一个实体类，例如 `User`：

```java
package com.example.project.model;

import com.mybatisflex.annotation.Table;
import com.yilian.manage.base.entity.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@Table("user")
@EqualsAndHashCode(callSuper = true)
public class User {
    private Long id;
    private String name;
    private Integer age;
}
```

### 2. 创建 Mapper 接口

在 `com.example.project.mapper` 包下创建 Mapper 接口，例如 `UserMapper`：

```java
package com.example.project.mapper;

import com.example.project.model.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface UserMapper {

    @Select("SELECT * FROM user WHERE id = #{id}")
    User selectUserById(Long id);

    @Select("SELECT * FROM user")
    List<User> selectAllUsers();

    @Insert("INSERT INTO user(name, age) VALUES(#{name}, #{age})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insertUser(User user);

    @Update("UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id}")
    void updateUser(User user);

    @Delete("DELETE FROM user WHERE id = #{id}")
    void deleteUser(Long id);
}
```

### 3. 配置 Mapper XML

在 `src/main/resources/mapper` 目录下创建 Mapper XML 文件，例如 `UserMapper.xml`：

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.project.mapper.UserMapper">
    <resultMap id="BaseResultMap" type="com.example.project.model.User">
        <id column="id" property="id" />
        <result column="name" property="name" />
        <result column="age" property="age" />
    </resultMap>

    <sql id="Base_Column_List">
        id, name, age
    </sql>

    <select id="selectUserById" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM user
        WHERE id = #{id}
    </select>

    <select id="selectAllUsers" resultMap="BaseResultMap">
        SELECT <include refid="Base_Column_List" />
        FROM user
    </select>

    <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user (name, age)
        VALUES (#{name}, #{age})
    </insert>

    <update id="updateUser">
        UPDATE user
        SET name = #{name}, age = #{age}
        WHERE id = #{id}
    </update>

    <delete id="deleteUser">
        DELETE FROM user
        WHERE id = #{id}
    </delete>
</mapper>
```

### 4. 编写 Service 层

在 `com.example.project.service` 包下创建 Service 类，例如 `UserService`：

```java
package com.example.project.service;

import com.example.project.mapper.UserMapper;
import com.example.project.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.selectUserById(id);
    }

    public List<User> getAllUsers() {
        return userMapper.selectAllUsers();
    }

    public void createUser(User user) {
        userMapper.insertUser(user);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    public void deleteUser(Long id) {
        userMapper.deleteUser(id);
    }
}
```

### 5. 编写 Controller 层

在 `com.example.project.controller` 包下创建 Controller 类，例如 `UserController`：

```java
package com.example.project.controller;

import com.example.project.model.User;
import com.example.project.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @PostMapping
    public void createUser(@RequestBody User user) {
        userService.createUser(user);
    }

    @PutMapping
    public void updateUser(@RequestBody User user) {
        userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}
```

## 总结

通过以上步骤，我们成功地在 Spring Boot 项目中集成了 MyBatis-Flex，并实现了基本的增删改查功能。MyBatis-Flex 提供了更高效、更便捷的 MyBatis 操作方式，希望这篇博客能够帮助你更好地理解和使用 MyBatis-Flex。如果你有任何问题或建议，欢迎在评论区留言讨论。

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

1. 问题背景

使用 Spring Boot 整合 MapStruct 的指南

一、前言

二、项目准备

1. 创建 Spring Boot 项目

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

什么是 RabbitMQ？

RabbitMQ 的核心概念

Spring Boot 整合 WebSocket 教程

一、项目依赖

MyBatis-Flex 安装与配置使用指南

一、安装 MyBatis-Flex

1. 引入 Maven 依赖