# 如何卸载通过官方安装包安装的 Node.js

当你通过 Node.js 的官方安装包在 macOS 上安装了 Node.js 之后，可能会发现没有直接的卸载程序来帮助你移除它。不过，通过手动删除相关文件和目录，可以实现彻底卸载。下面是详细的步骤：

## 步骤 1: 删除 Node.js 文件

打开终端（Terminal），使用以下命令删除 Node.js 相关的文件夹和文件。你可能需要管理员权限来执行这些命令，因此部分命令前会加上 `sudo`。



### 删除 Node.js 文件夹：

```sh
sudo rm -rf /usr/local/lib/node_modules
sudo rm -rf /usr/local/include/node
```

### 删除 Node.js 二进制文件：

```sh
sudo rm /usr/local/bin/node
sudo rm /usr/local/bin/npm
sudo rm /usr/local/bin/npx
```

## 步骤 2: 清理环境变量

如果你在 `.bash_profile`、`.zshrc`、`.bashrc` 或其他 shell 配置文件中设置了与 Node.js 相关的环境变量，你需要编辑这些文件并移除或注释掉这些变量。

1. 打开配置文件，这里以 `.zshrc` 为例（如果你使用 Bash Shell，可能需要编辑 `.bash_profile` 或 `.bashrc`）：

   ```sh
   open -e ~/.zshrc
   ```

2. 查找并删除或注释掉与 `NODE_PATH` 或其他 Node.js 相关的环境变量设置。

3. 保存文件并关闭编辑器。

4. 让更改生效，执行：

   ```sh
   source ~/.zshrc
   ```

   或重新启动终端。

## 步骤 3: 验证卸载

为了确认 Node.js 已经被从你的系统中彻底移除，可以在终端执行以下命令检查：

```sh
node -v
npm -v
```

如果终端显示错误消息，如 `command not found`，那么表示 Node.js 已经被成功卸载。

## 注意：

- 在进行卸载操作前，确保你已经备份了所有重要的 Node.js 项目和数据。
- 卸载 Node.js 可能会影响依赖于 Node.js 的其他软件或开发环境，确保在卸载前评估这些影响。
- 上述指令和文件路径可能根据你的系统配置有所不同，请根据实际情况进行调整。

按照这些步骤，你应该能够成功从 macOS 上卸载通过官方安装包安装的 Node.js。如果遇到任何问题，可以参考 Node.js 的官方文档或寻求社区的帮助。

mac卸载node

# 使用 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的交互至关重要，特别是在复杂的分布式环境和微服务架构下，它能够帮助我们更好地应对各种数据处理挑战。

如何卸载通过官方安装包安装的 Node.js

步骤 1: 删除 Node.js 文件

使用 NVM 管理 Node.js 版本

安装 NVM

对于 macOS 和 Linux 用户

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

概述

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

常见特性比较

Jedis

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

MySQL 5.7之前的SQL Mode变化