Spring Boot 中的序列化与反序列化：深入理解 Web 层与 Redis 缓存

# Java中的Redis客户端：Jedis、Lettuce和Redisson的比较与实战

在Java开发中，Redis是一种广泛使用的快速、键值存储数据库，用于缓存、消息队列等。Java开发者通常会选择Jedis、Lettuce或Redisson作为Redis客户端。本文将详细探讨这三种客户端的特性、核心原理，并展示如何在Spring Boot项目中使用它们。

## 常见特性比较

### Jedis

- **类型**：轻量级客户端，直接映射Redis命令。
- **连接**：使用连接池管理连接，非线程安全。
- **操作模式**：主要支持同步操作。
- **特性**：简单易用，但不支持异步和响应式编程。



### Lettuce

- **类型**：基于Netty的高级客户端。
- **连接**：线程安全，支持连接多路复用。
- **操作模式**：支持同步、异步和响应式编程。
- **特性**：功能丰富，适合高并发和复杂场景。

### Redisson

- **类型**：提供丰富的分布式数据结构和同步器。
- **连接**：线程安全，支持连接多路复用。
- **操作模式**：支持同步和异步操作。
- **特性**：提供分布式Java对象和服务，如分布式锁、原子变量等。

## 核心原理解析

### Jedis核心原理

Jedis通过直接与Redis服务器建立Socket连接，并发送标准的Redis命令来实现其功能。它使用阻塞I/O，每个Jedis实例对应一个物理连接。

### Lettuce核心原理

Lettuce使用Netty框架实现非阻塞I/O，可以在多个线程间共享单个连接实例。它通过发布/订阅模式来支持异步和事件驱动的编程。

### Redisson核心原理

Redisson在Lettuce的基础上进一步抽象，提供了丰富的分布式Java数据结构，如RemoteService和分布式锁等。它使用Netty进行网络通信，并实现了高级的序列化和反序列化机制。

## Spring Boot中的实战应用

### Jedis在Spring Boot中的使用

1. **依赖配置**：
   ```xml
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>
   ```
2. **连接配置**：在`application.properties`中配置Redis服务器的地址和端口。
   ```yaml
   spring:
     data:
       # redis配置
       redis:
         # Redis数据库索引（默认为0）
         database: 0
         # Redis服务器地址
         host: 127.0.0.0
         # Redis服务器连接端口
         port: 26379
         # Redis服务器连接密码（默认为空）
         password: wzw2391
         # 查询超时时间
         timeout: 10s
         # 连接超时时间
         connect-timeout: 10s
         jedis:
           pool:
             # 连接池最大连接数
             max-active: 200
             # 连接池最大阻塞等待时间（使用负值表示没有限制）
             max-wait: -1ms
             # 连接池中的最大空闲连接
             max-idle: 10
             # 连接池中的最小空闲连接
             min-idle: 0
   ```
3. **序列化配置**：
   ```java
   @Bean
   @SuppressWarnings("all")
   public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
       RedisTemplate<String, Object> template = new RedisTemplate<>();
       template.setConnectionFactory(factory);
   
       // Json序列化配置
       ObjectMapper objectMapper = new ObjectMapper();
       objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
       objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
       Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);
   
       // 设置value的序列化规则和 key的序列化规则
       template.setKeySerializer(new StringRedisSerializer());
       template.setValueSerializer(jackson2JsonRedisSerializer);
       template.setHashKeySerializer(new StringRedisSerializer());
       template.setHashValueSerializer(jackson2JsonRedisSerializer);
       template.afterPropertiesSet();
       return template;
   }
   ```

4. **使用示例**
   ```java
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   import org.springframework.data.redis.core.RedisTemplate;
   
   @Service
   public class RedisService {
   
       @Autowired
       private RedisTemplate<String, Object> redisTemplate;
       
       // String
       public void setStringValue(String key, String value) {
           redisTemplate.opsForValue().set(key, value);
       }
   
       public String getStringValue(String key) {
           return (String) redisTemplate.opsForValue().get(key);
       }
       
       // Hash
       public void setHashValue(String key, String hashKey, Object value) {
           redisTemplate.opsForHash().put(key, hashKey, value);
       }
   
       public Object getHashValue(String key, String hashKey) {
           return redisTemplate.opsForHash().get(key, hashKey);
       }
   
       public Map<Object, Object> getHashAll(String key) {
           return redisTemplate.opsForHash().entries(key);
       }
   }
   
   ```

### Lettuce在Spring Boot中的使用

1. **依赖配置**：
   ```xml
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>
   ```
2. **配置连接**：
   ```yaml
   spring:
     data:
       # redis配置
       redis:
         # Redis数据库索引（默认为0）
         database: 0
         # Redis服务器地址
         host: 127.0.0.0
         # Redis服务器连接端口
         port: 26379
         # Redis服务器连接密码（默认为空）
         password: wzw2391
         # 查询超时时间
         timeout: 10s
         # 连接超时时间
         connect-timeout: 10s
         lettuce:
           pool:
             # 连接池最大连接数
             max-active: 200
             # 连接池最大阻塞等待时间（使用负值表示没有限制）
             max-wait: -1ms
             # 连接池中的最大空闲连接
             max-idle: 10
             # 连接池中的最小空闲连接
             min-idle: 0
   ```
3. 序列化配置：
   ```java
   @Bean
   @SuppressWarnings("all")
   public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
       RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
       redisTemplate.setConnectionFactory(lettuceConnectionFactory);
       // Json序列化配置
       ObjectMapper objectMapper = new ObjectMapper();
       objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
       objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
       Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);
   
       // 设置value的序列化规则和 key的序列化规则
       redisTemplate.setKeySerializer(new StringRedisSerializer());
       redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
       redisTemplate.setHashKeySerializer(new StringRedisSerializer());
       redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
       redisTemplate.afterPropertiesSet();
       return redisTemplate;
   }
   ```
4. **使用示例：** 和jedis一样

### Redisson在Spring Boot中的使用

1. **依赖配置**：
   ```xml
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>最新版本</version>
    </dependency>
   ```
2. **配置连接**：
   ```java
       @Bean
       public RedissonClient redisson(RedisProperties redisProperties) {
           // 配置Redisson
           Config config = new Config();
           SingleServerConfig singleServerConfig = config
                   .useSingleServer()
                   .setDatabase(redisProperties.getDatabase())
                   .setAddress("redis://" + redisProperties.getHost() + ":" + redisProperties.getPort());
           if (StrUtil.isNotBlank(redisProperties.getPassword())) {
               singleServerConfig.setPassword(redisProperties.getPassword());
           }
           // 使用json序列化方式
           Codec codec = new JsonJacksonCodec();
           config.setCodec(codec);
           return Redisson.create(config);
       }
   ```
3. **使用示例**：
   ```java
   import org.redisson.api.RMap;
   import org.redisson.api.RList;
   import org.redisson.api.RTopic;
   import org.redisson.api.listener.MessageListener;
   
   RMap<String, String> map = redisson.getMap("myMap");
   map.put("key", "value");
   String value = map.get("key");
   RList<String> list = redisson.getList("myList");
   list.add("value1");
   list.add("value2");
   RTopic topic = redisson.getTopic("myTopic");
   topic.addListener(String.class, new MessageListener<String>() {
       @Override
       public void onMessage(CharSequence channel, String msg) {
           System.out.println("received message: " + msg);
       }
   });
   
   // 发送消息
   topic.publish("Hello, Redisson!");
   ```
   ```java
   import org.redisson.api.RLock;
   
   // ...
   
   RLock lock = redisson.getLock("myLock");
   lock.lock();
   try {
       // 执行临界区代码
   } finally {
       lock.unlock();
   }
   
   ```

 ## 结论

选择哪种客户端取决于您的具体需求：Jedis适合轻量级和简单场景；Lettuce适合高并发和复杂场景；Redisson适合需要丰富分布式特性的场景。在Spring Boot中，这些客户端的集成和使用都非常简单高效。希望本文能帮助您选择合适的Redis客户端，并在您的Java应用中高效地使用Redis。

Java中的Redis客户端：Jedis、Lettuce和Redisson的比较与实战

## 标题：MySQL SQL Mode演变与8.0版本后的关键约束


随着MySQL数据库的发展和版本迭代，SQL Mode这一核心特性在数据验证、语句执行以及兼容性方面扮演了越来越重要的角色。从早期的宽松模式到逐渐强化的严格模式，SQL Mode的变化深刻影响着MySQL用户的应用场景及数据处理方式。本文将深入探讨SQL Mode在MySQL不同版本中的变迁，并聚焦于MySQL 8.0版本之后引入的关键约束。

### MySQL 5.7之前的SQL Mode变化



在MySQL较早的版本中，默认的SQL Mode相对宽松，允许一些非标准的行为以确保向后兼容性和易用性。例如，允许插入零日期或隐式转换数据类型，不强制执行GROUP BY子句的完整性等。尽管如此，MySQL还是提供了多种SQL Mode供用户选择，以便对SQL语句的执行进行定制，包括但不限于`STRICT_TRANS_TABLES`（严格事务表模式）、`ANSI`（更接近ANSI SQL标准）和`TRADITIONAL`（传统模式，结合多个严格选项）。

### MySQL 5.7版本中的SQL Mode改进

MySQL 5.7版本对SQL Mode进行了显著增强，其中一个重大改变是默认包含了`ONLY_FULL_GROUP_BY`模式。这意味着在执行包含GROUP BY子句的查询时，SELECT列表中的所有非聚合列必须出现在GROUP BY子句中，或者作为聚合函数的目标列。此举有助于避免模糊查询结果并符合SQL标准。

此外，MySQL 5.7还加强了对其他严格模式的支持，如`STRICT_TRANS_TABLES`使得在事务表中遇到非法数据时触发错误而非警告或自动调整。同时，新增或进一步强调了诸如`NO_ZERO_DATE`、`NO_AUTO_VALUE_ON_ZERO`等模式，提高了数据完整性和一致性要求。

### MySQL 8.0版本之后的SQL Mode与新约束

MySQL 8.0版本在SQL Mode的管理和使用上更加精细和标准化，但值得注意的是，MySQL 8.0取消了`ONLY_FULL_GROUP_BY`作为默认SQL Mode的一部分。虽然不再默认开启，但为了保证查询结果的一致性和防止潜在的数据问题，强烈建议在生产环境中显式启用此模式。

在MySQL 8.0及其后续版本中，SQL Mode仍然支持一系列严格的约束条件，例如：

- `STRICT_TRANS_TABLES`继续提供对事务表的严格模式控制。
- `NO_ZERO_DATE`禁止插入'0000-00-00'作为日期值，除非`ALLOW_INVALID_DATES`也同时被设置。
- `ERROR_FOR_DIVISION_BY_ZERO`确保除数为零时抛出错误，而不是返回NULL或其他特殊值。
- `NO_ENGINE_SUBSTITUTION`防止在指定的存储引擎不可用时自动替换为其他引擎。

MySQL 8.0版本还增强了对Unicode字符集的支持，更新了对JSON数据类型的操作，以及其他语法和性能改进，这些改进与SQL Mode一起，共同推动了MySQL数据库系统朝着更高的标准合规性、安全性和稳定性发展。

总之，SQL Mode在MySQL的不同版本中不断演进，成为数据库管理员和开发者确保数据一致性和应用健壮性的有力工具。理解并合理配置SQL Mode对于优化应用程序与MySQL的交互至关重要，特别是在复杂的分布式环境和微服务架构下，它能够帮助我们更好地应对各种数据处理挑战。

MySQL SQL Mode演变与8.0版本后的关键约束

# 基于JTA的Java两阶段提交：深入理解和实践

在分布式系统中，事务管理是确保数据一致性、完整性和隔离性的关键环节。Java Transaction API (JTA) 作为Java平台的企业级事务处理标准，提供了对分布式事务的支持，其中就包括了经典的两阶段提交（Two-Phase Commit, 2PC）协议。本文将详细介绍基于JTA的两阶段提交原理和实现方式。

## **一、两阶段提交概述**

两阶段提交是一种分布式事务协调机制，它通过两个阶段来保证多个参与资源（如数据库实例、消息队列等）要么全部成功提交事务，要么全部回滚以保持一致性。整个过程涉及的角色主要包括：



1. **事务协调者（Transaction Coordinator）**：负责发起并管理整个事务流程，通常由应用服务器或事务管理器扮演。
2. **参与者（Resource Participants）**：每个参与事务的数据库或其他资源，它们需要支持XA事务接口以参与到两阶段提交过程中。

### **两阶段提交的具体步骤：**

#### **第一阶段 - 准备阶段(Prepare Phase)**

- 协调者发起一个全局事务，并向所有参与者发送“准备”请求。
- 参与者接收到请求后，在本地执行事务操作并锁定相关资源，但不提交到永久存储区。
- 根据本地事务的成功与否，参与者回复协调者“准备好提交”或“无法准备”。

#### **第二阶段 - 提交/回滚阶段(Commit/Rollback Phase)**

- 如果协调者收到所有参与者的“准备好提交”响应，则向所有参与者发出“提交”命令。
- 各个参与者收到“提交”命令后，释放之前锁定的资源，并将本地事务提交至永久存储。
- 若有任何参与者在准备阶段无法完成准备工作，协调者将通知其他参与者进行“回滚”，参与者根据指令撤销已做的更改并释放资源。

## **二、JTA与两阶段提交**

Java Transaction API (JTA) 是Java EE规范的一部分，为跨多个资源管理器（如多个数据库连接）的分布式事务提供了一个统一的编程模型。JTA使用X/Open XA接口与资源管理器交互，而大多数主流数据库驱动程序都实现了XA接口以支持两阶段提交。

在Java应用程序中，我们可以通过以下方式利用JTA实现两阶段提交：

1. 使用`javax.transaction.UserTransaction`接口手动控制事务边界。例如：

```java
UserTransaction utx = new InitialContext().lookup("java:comp/UserTransaction");
utx.begin();

// 执行分布式事务操作...
// ...

utx.commit(); // 这里会触发两阶段提交流程
```

2. 配合容器管理的事务（CMT），让应用服务器自动管理事务生命周期。在EJB或Spring框架中，可以通过注解（如@TransactionAttribute）来声明事务属性。

3. 利用事务管理器（Transaction Manager），比如Atomikos或Narayana，它们封装了复杂的XA事务处理逻辑，并提供了更高级别的API和服务。

总的来说，基于JTA的两阶段提交为我们解决了分布式环境下的事务难题，但也需注意其潜在的性能瓶颈和单点故障问题。因此，在实际应用场景中，可能还需要结合其他事务模式（如Saga、TCC、Seata等）以及补偿机制来优化整体系统的事务处理能力。

基于JTA的Java两阶段提交：深入理解和实践

# MyBatis-Plus 多数据源事务实现原理解析

## 引言

在复杂的企业级应用中，经常会遇到需要操作多个数据库的情况。MyBatis-Plus 作为一个强大的 ORM 框架，提供了对多数据源的支持，并通过集成 JTA 来实现跨多个数据源的事务管理。本文将深入探讨 MyBatis-Plus 如何实现多数据源事务，并特别关注 JTA 的实现原理。



## JTA 的实现原理

JTA（Java Transaction API）是一个用于管理分布式事务的 Java API。它主要用于在多个事务资源（如数据库、消息系统等）之间协调事务，以确保所有操作要么全部成功，要么全部失败，从而保证事务的一致性和原子性。

### JTA 的组成

JTA 主要由两部分组成：

1. **事务管理器 (Transaction Manager)**：负责创建、维护和终结事务。它协调多个事务参与者，确保事务的一致性和完整性。

2. **资源管理器 (Resource Manager)**：通常是数据库或消息服务等，负责提供事务性资源。资源管理器通过 XA 接口与事务管理器通信。

### XA 事务

JTA 使用 XA 规范来协调事务。XA 是一个基于两阶段提交协议（2PC）的标准，它定义了资源管理器如何与事务管理器通信来实现分布式事务。

#### 两阶段提交协议（2PC）

1. **准备阶段（Prepare）**：事务管理器指示所有参与的资源管理器准备提交。每个资源管理器将事务操作记录到日志中，并响应是否准备就绪。

2. **提交/回滚阶段（Commit/Rollback）**：如果所有资源管理器都报告准备就绪，事务管理器会发出提交指令；如果任何一个资源管理器报告失败，事务管理器会发出回滚指令。

### JTA 与 MyBatis-Plus 的集成

在 MyBatis-Plus 中，JTA 可以通过集成 Atomikos 或 Narayana 等 JTA 实现来实现多数据源事务管理。这些实现提供了事务管理器的具体实现，允许 MyBatis-Plus 在多个不同的数据源之间协调事务。

## 总结

JTA 通过提供一套标准的 API 和基于两阶段提交协议的事务管理机制，使得在分布式系统中实现事务的一致性和原子性成为可能。在 MyBatis-Plus 中，通过集成 JTA，开发者可以在多数据源环境下有效地管理跨多个数据库的事务。虽然实现相对复杂，但这为构建大型、分布式的企业应用提供了强大的支持。

---

本文详细解析了 JTA 的实现原理及其在 MyBatis-Plus 中的应用，为理解和应用分布式事务提供了参考。如果需要更深入的技术细节，建议查阅相关的开发文档和源代码。

:::warning{title="注意"}
本文适用场景为单个JAVM服务，多数据源情况，不适用于分布式微服务
:::

一、Web 层的 JSON 序列化/反序列化

概述

Java中的Redis客户端：Jedis、Lettuce和Redisson的比较与实战

常见特性比较

Jedis

标题：MySQL SQL Mode演变与8.0版本后的关键约束

MySQL 5.7之前的SQL Mode变化

基于JTA的Java两阶段提交：深入理解和实践

一、两阶段提交概述

MyBatis-Plus 多数据源事务实现原理解析

引言