## 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。如果你有任何问题或建议，欢迎在评论区留言讨论。

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

# Spring Boot 日期和时间格式化配置指南

在使用 Spring Boot 开发过程中，处理日期和时间类型的数据是一个常见的需求。为了确保日期和时间在整个应用程序中能够一致且正确地处理，我们需要进行一些配置。在这篇博客中，我们将展示如何通过自定义配置来实现这一目标。

## 背景介绍

在 Java 中，处理日期和时间的类主要包括 `LocalDateTime`、`LocalDate` 和 `LocalTime`。这些类在不同场景下需要进行格式化或解析，例如在 JSON 序列化/反序列化、请求参数和表单数据处理等。通过自定义配置，我们可以统一这些日期和时间类型的格式，确保在整个应用程序中使用一致的格式。

## 解决方案

我们将通过创建一个配置类 `JacksonConfig` 来实现日期和时间的格式化配置。该类实现了 `WebMvcConfigurer` 接口，并提供了两个关键方法：



1. `jackson2ObjectMapperBuilderCustomizer`：用于配置 Jackson 的 ObjectMapper，处理 JSON 序列化和反序列化。
2. `addFormatters`：用于配置 Spring MVC 的格式化规则，处理请求参数和表单数据的解析。

以下是完整的代码示例：

```java
package com.code.generator.config;

import cn.hutool.core.date.DatePattern;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.annotation.Order;
import org.springframework.format.FormatterRegistry;
import org.springframework.format.datetime.standard.DateTimeFormatterRegistrar;
import org.springframework.lang.NonNull;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

/**
 * @author Jack Wei
 * @date 2022/2/25 11:08
 */
@Order(-1)
@Configuration
public class JacksonConfig implements WebMvcConfigurer {

    @Bean
    @Primary
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder -> builder
                .modules(new JavaTimeModule())
                .serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)))
                .serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)))
                .serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)))
                .deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)))
                .deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)))
                .deserializerByType(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)))
                .serializerByType(Long.class, ToStringSerializer.instance)
                .serializerByType(Long.TYPE, ToStringSerializer.instance);
    }

    @Override
    public void addFormatters(@NonNull FormatterRegistry registry) {
        DateTimeFormatterRegistrar dateTimeRegistrar = new DateTimeFormatterRegistrar();
        dateTimeRegistrar.setDateFormatter(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN));
        dateTimeRegistrar.setTimeFormatter(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN));
        dateTimeRegistrar.setDateTimeFormatter(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN));
        dateTimeRegistrar.registerFormatters(registry);
    }
}
```

## 详细解释

### `jackson2ObjectMapperBuilderCustomizer` 方法

这个方法配置了 Jackson 的 ObjectMapper，主要用于处理 JSON 数据的序列化和反序列化。通过该方法，我们可以设置自定义的序列化和反序列化规则：

- **日期和时间格式**：使用 `LocalDateTimeSerializer`、`LocalDateSerializer` 和 `LocalTimeSerializer` 设置日期和时间的序列化格式，使用 `LocalDateTimeDeserializer`、`LocalDateDeserializer` 和 `LocalTimeDeserializer` 设置反序列化格式。
- **Long 类型的处理**：将 `Long` 类型字段序列化为字符串，避免前端处理长整型数值时出现精度丢失问题。

### `addFormatters` 方法

这个方法配置了 Spring MVC 的格式化规则，主要用于处理请求参数和表单数据的解析：

- **日期和时间格式**：使用 `DateTimeFormatterRegistrar` 设置 `LocalDateTime`、`LocalDate` 和 `LocalTime` 类型的格式化规则。确保在处理请求参数和表单数据时能够正确解析和格式化日期和时间。

## 总结

通过上述配置，我们可以确保在处理 JSON 数据和请求参数时，应用程序中的日期和时间格式一致且正确。这不仅提高了代码的可读性和维护性，还避免了由于格式不一致导致的潜在问题。

希望这篇博客对你在 Spring Boot 开发中处理日期和时间格式化有所帮助。如果你有任何问题或建议，欢迎在评论区留言讨论。

Spring Boot 日期和时间格式化配置指南

### 使用 EasyExcel 实现多 Sheet 循环填充

在日常工作中，我们经常需要生成 Excel 报表，其中一个复杂场景就是多 Sheet 表格的填充。使用阿里巴巴的 EasyExcel 库可以简化这个过程。本文将介绍如何使用 EasyExcel 实现多 Sheet 的循环填充。

#### 一、前置准备

在开始之前，请确保您的项目已经引入了 EasyExcel 依赖。如果没有，请在 `pom.xml` 文件中添加以下依赖：

```xml
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>easyexcel</artifactId>
    <version>${newest version}</version>
</dependency>
```



#### 二、创建基础模型类

首先，我们创建一个模型类，用于存储需要写入 Excel 的数据。

```java
public class User {
    private String name;
    private Integer age;
    private String email;

    // getters and setters
}
```

#### 三、创建多 Sheet 填充的逻辑

接下来，我们编写多 Sheet 循环填充的逻辑。在每个 Sheet 中写入不同的数据。

```java
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;

import java.util.ArrayList;
import java.util.List;

public class MultiSheetWriteExample {
    public static void main(String[] args) {
        String fileName = "multiSheetExample.xlsx";
        ExcelWriter excelWriter = EasyExcel.write(fileName).build();

        // Sheet 数据准备
        List<List<User>> sheetData = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            List<User> data = new ArrayList<>();
            for (int j = 0; j < 10; j++) {
                User user = new User();
                user.setName("User" + i + j);
                user.setAge(20 + j);
                user.setEmail("user" + i + j + "@example.com");
                data.add(user);
            }
            sheetData.add(data);
        }

        // 写入多个 Sheet
        for (int i = 0; i < sheetData.size(); i++) {
            WriteSheet writeSheet = EasyExcel.writerSheet(i, "Sheet" + (i + 1)).head(User.class).build();
            excelWriter.write(sheetData.get(i), writeSheet);
        }

        // 关闭 ExcelWriter
        excelWriter.finish();
    }
}
```

在这个示例中，我们创建了三个 Sheet，每个 Sheet 都填充了不同的用户数据。`EasyExcel.writerSheet` 方法用于创建新的 Sheet，`write` 方法用于将数据写入当前 Sheet。

#### 四、优化和扩展

在实际应用中，数据可能来自数据库或其他外部数据源。我们可以将数据源抽象出来，增强代码的灵活性。

```java
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;

import java.util.List;

public class MultiSheetWriteExample {

    public static void main(String[] args) {
        String fileName = "multiSheetExample.xlsx";
        ExcelWriter excelWriter = EasyExcel.write(fileName).build();

        // 从数据源获取 Sheet 数据
        List<List<User>> sheetData = fetchDataFromDataSource();

        // 写入多个 Sheet
        for (int i = 0; i < sheetData.size(); i++) {
            WriteSheet writeSheet = EasyExcel.writerSheet(i, "Sheet" + (i + 1)).head(User.class).build();
            excelWriter.write(sheetData.get(i), writeSheet);
        }

        // 关闭 ExcelWriter
        excelWriter.finish();
    }

    private static List<List<User>> fetchDataFromDataSource() {
        // 模拟从数据库或其他数据源获取数据
        // 这里简单返回之前的数据示例
        List<List<User>> sheetData = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            List<User> data = new ArrayList<>();
            for (int j = 0; j < 10; j++) {
                User user = new User();
                user.setName("User" + i + j);
                user.setAge(20 + j);
                user.setEmail("user" + i + j + "@example.com");
                data.add(user);
            }
            sheetData.add(data);
        }
        return sheetData;
    }
}
```

这样做可以让数据的获取与 Excel 的生成逻辑分离，使得代码更加清晰和可维护。

#### 五、总结

通过使用 EasyExcel，我们可以轻松实现多 Sheet 表格的循环填充。本文介绍了如何创建基本的模型类，并通过循环将不同的数据写入多个 Sheet。这样的实现不仅提高了代码的可读性和维护性，也使得生成复杂的 Excel 报表变得更加简单。

希望本文能帮助你更好地掌握 EasyExcel 的多 Sheet 填充技巧，在实际工作中提升效率。如果你有更多关于 EasyExcel 的使用经验或问题，欢迎在评论区分享。

---

### 扩展阅读

- [EasyExcel 官方文档](https://www.yuque.com/easyexcel)
- [阿里巴巴 Java 开发手册](https://github.com/alibaba/p3c)

通过以上学习和实践，您应该能够轻松地在项目中实现多 Sheet 循环填充，为数据展示提供更好的解决方案。