# 使用 NVM 管理 Node.js 版本

Node.js 是一个广泛使用的开源服务器环境，允许你运行 JavaScript 代码。随着 Node.js 的不断发展，不同的项目可能需要不同版本的 Node.js。这时，Node Version Manager (NVM) 就显得尤为重要，它可以帮助你在同一台机器上管理多个 Node.js 版本。本博客将指导你如何下载安装 NVM 并使用它来管理 Node.js 版本，最后会提到一个关于 Yarn 的重要注意事项。

## 安装 NVM

### 对于 macOS 和 Linux 用户

1. 打开终端。
2. 运行安装脚本。可以通过 cURL 或 Wget 来运行 NVM 的安装脚本。以下是使用 cURL 的命令：



   ```bash
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
   ```

   或者，使用 Wget：

   ```bash
   wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
   ```

3. 重启终端。
4. 验证安装。运行 `nvm -v` 来确认 NVM 已成功安装。

### 对于 Windows 用户

Windows 用户需要使用 NVM for Windows，一个专门为 Windows 环境设计的版本。

1. 访问 [NVM for Windows 的 GitHub 页面](https://github.com/coreybutler/nvm-windows/releases)。
2. 下载最新版本的安装程序。
3. 运行下载的安装程序并按照指示完成安装。
4. 打开命令提示符或 PowerShell 并运行 `nvm version` 来检查 NVM 是否正确安装。
5. 全局配置npm镜像源，进入C:\Users\用户名\AppData\Roaming\nvm目录打开settings.txt文件在末尾添加`npm_mirror: https://registry.npmmirror.com`，如下图
![image.png](/static/img/c10b222b41672d51f26f91ff733aa338.image.webp)
## 使用 NVM 管理 Node.js

一旦安装了 NVM，你就可以轻松地安装和切换 Node.js 的不同版本了。

### 安装 Node.js 版本

使用 NVM 安装 Node.js 版本非常简单。例如，要安装 Node.js 的最新版本，可以运行：

```bash
nvm install node
```

要安装特定版本的 Node.js，可以指定版本号，例如：

```bash
nvm install 18.19.1
nvm install 16.20.2
```

### 列出已安装的版本

要查看所有已安装的 Node.js 版本，可以使用：

```bash
nvm list
```

![](https://www.tcuwzw.com/static/img/4118c236f161e225f087ac299043d5da.image.webp)

### 使用特定版本的 Node.js

安装多个 Node.js 版本后，你可以根据需要切换使用的版本。例如，要切换到 Node.js 14.17.0 版本，可以运行：

```bash
nvm use 18.19.1
```

### 卸载 Node.js 版本

如果需要卸载某个特定的 Node.js 版本，可以这样做：

```bash
nvm uninstall 18.19.1
```

## 注意事项：Yarn 的安装

虽然 NVM 可以管理 Node.js 的多个版本，但需要注意的是，每个 Node.js 版本的 Yarn 需要单独安装。这是因为 Yarn 是作为全局 npm 包安装的，不同的 Node.js 版本拥有独立的全局包空间。

因此，当你使用 NVM 切换到一个新的 Node.js 版本后，如果计划使用 Yarn，你需要重新安装它：

```bash
npm install -g yarn
```

这样确保了无论你切换到哪个 Node.js 版本，都能使用 Yarn。

## 结语

NVM 是每个 Node.js 开发者工具箱中不可或缺的一部分，它让管理不同版本的 Node.js 变得轻而易举。记住，当你在不同的 Node.js 版本之间切换时，确保为每个版本单独安装 Yarn，这样可以保持项目的稳定性和一致性。使用 NVM，你可以更加专注于

使用 NVM 管理 Node.js 版本

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等）以及补偿机制来优化整体系统的事务处理能力。

使用 NVM 管理 Node.js 版本

安装 NVM

对于 macOS 和 Linux 用户

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

概述

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

常见特性比较

Jedis

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

MySQL 5.7之前的SQL Mode变化

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

一、两阶段提交概述