# 在 macOS 上安装 NVM 的教程

NVM（Node Version Manager）是一个流行的工具，用于管理多个 Node.js 版本。通过 NVM，你可以在同一台机器上安装和切换不同版本的 Node.js，这对于开发多个项目，特别是它们需要不同版本的 Node.js 时，非常有用。这篇教程将指导你如何在 macOS 上通过官方安装脚本安装 NVM。

## 前提条件

- macOS 操作系统。
- 对终端（Terminal）有基本的了解。
- 有管理员权限，以便在需要时执行安装。



## 安装步骤

### 步骤 1: 打开终端

在你的 macOS 上打开终端（Terminal）。你可以通过在 Finder 中打开 `应用程序` > `实用工具` > `终端`，或者使用 Spotlight 搜索 `终端` 来快速访问。

### 步骤 2: 下载并运行安装脚本

在终端中，输入以下命令来下载并运行 NVM 的安装脚本。你可以选择使用 `curl` 或 `wget` 命令。如果你的系统中没有安装 `wget`，请使用 `curl` 命令。

使用 `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
```

这些命令会自动下载 `nvm` 的安装脚本并执行它。安装脚本会将 NVM 安装到你的用户目录下，并更新你的 shell 配置文件（如 `.bash_profile`, `.zshrc`, `.profile`, 或 `.bashrc`），以便能够在新的终端会话中直接使用 `nvm` 命令。

### 步骤 3: 使安装生效

安装完成后，为了让 NVM 在当前终端会话中可用，你需要重新加载你的 shell 配置文件。这可以通过以下命令完成，这取决于你使用的 shell 类型：

如果你使用 Bash 或 Zsh，可以通过 source 命令重新加载配置文件：

```bash
source ~/.bash_profile  # 如果你使用的是 bash
```

或者

```bash
source ~/.zshrc  # 如果你使用的是 zsh
```

### 步骤 4: 验证安装

为了验证 NVM 是否已成功安装，你可以在终端中运行以下命令：

```bash
nvm --version
```

如果安装成功，命令将输出 NVM 的版本号。

### 步骤 5: 使用 NVM 安装 Node.js

现在你可以通过 NVM 安装 Node.js 了。例如，要安装最新版本的 Node.js，你可以运行：

```bash
nvm install node
```

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

```bash
nvm install 14.17.0
```

## 总结

恭喜！你现在已经成功在 macOS 上安装了 NVM，并且知道如何通过 NVM 安装特定版本的 Node.js 了。NVM 是管理多个 Node.js 版本的强大工具，可以极大地提升你的开发效率。

在 macOS 上安装 NVM 的教程

# 如何卸载通过官方安装包安装的 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。

在 macOS 上安装 NVM 的教程

前提条件

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

步骤 1: 删除 Node.js 文件

使用 NVM 管理 Node.js 版本

安装 NVM

对于 macOS 和 Linux 用户

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

概述

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

常见特性比较

Jedis