在 Node.js 开发中，版本管理工具非常重要，可以帮助开发者方便地管理不同项目所需的 Node.js 版本-CSDN博客

本文探讨了使用Spring框架处理不同环境（如开发、测试、生产）的复杂应用配置问题，介绍了如何使应用环境感知，实现环境特定行为，包括加载额外上下文配置文件、使用JavaConfig以及结合两者的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在 Node.js 开发中，版本管理工具非常重要，可以帮助开发者方便地管理不同项目所需的 Node.js 版本。以下是一些常用的 Node.js 版本管理工具：

1. NVM（Node Version Manager）

简介：NVM 是最流行的 Node.js 版本管理工具之一。它允许用户在同一台机器上安装多个 Node.js 版本，并可以轻松切换。
特点：
- 可以安装、卸载和切换不同版本的 Node.js。
- 支持全局和项目级别的版本管理。
- 不需要管理员权限即可安装和管理 Node.js。

安装方法：

在终端中运行以下命令：

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

或者：

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

安装完成后，重新加载 shell 配置文件（如 .bashrc 或 .zshrc）：
```
source ~/.bashrc
```

使用示例：
- 安装特定版本的 Node.js：
```
nvm install 18.0.0
```
- 切换到某个版本：
```
nvm use 18.0.0
```
- 查看已安装的版本：
```
nvm ls
```

2. N（Node.js Version Manager）

简介：N 是一个轻量级的 Node.js 版本管理工具，基于 npm 开发。
特点：
- 简单易用，操作命令直观。
- 支持快速切换版本。
安装方法：
- 使用 npm 安装：
```
npm install -g n
```
使用示例：
- 安装最新版本的 Node.js：
```
n latest
```
- 安装特定版本：
```
n 18.0.0
```
- 切换到某个版本：
```
n use 18.0.0
```

3. Volta

简介：Volta 是一个现代化的 Node.js 版本管理工具，专注于性能和易用性。
特点：
- 通过缓存和优化，提供快速的版本切换。
- 支持项目级别的版本管理。
- 自动检测项目依赖的 Node.js 版本并切换。

安装方法：

在终端中运行以下命令：

curl https://get.volta.sh | bash

使用示例：
- 安装特定版本的 Node.js：
```
volta install node@18.0.0
```
- 在项目中指定 Node.js 版本：
```
cd my-project
volta pin node@18.0.0
```

4. Nodist

简介：Nodist 是一个 Windows 系统专用的 Node.js 版本管理工具。
特点：
- 专为 Windows 用户设计，操作简单。
- 支持多版本管理。
安装方法：
- 在 Windows 系统中，运行以下命令：
```
npm install -g nodist
```
使用示例：
- 安装特定版本的 Node.js：
```
nodist install 18.0.0
```
- 切换到某个版本：
```
nodist use 18.0.0
```

5. fnm（Fast Node Manager）

简介：fnm 是一个用 Rust 编写的高性能 Node.js 版本管理工具。
特点：
- 高性能，启动速度快。
- 支持多平台（Windows、macOS、Linux）。
- 支持项目级别的版本管理。

安装方法：

在终端中运行以下命令：

curl -fsSL https://fnm.vercel.app/install | bash

使用示例：
- 安装特定版本的 Node.js：
```
fnm install 18.0.0
```
- 切换到某个版本：
```
fnm use 18.0.0
```

选择建议

如果你使用的是 macOS 或 Linux，推荐使用 NVM 或 fnm，因为它们功能强大且社区支持良好。
如果你使用的是 Windows，可以尝试 Nodist 或 fnm，因为它们对 Windows 系统有较好的支持。
如果你更注重性能，可以尝试 fnm，它使用 Rust 编写，启动速度更快。

Node 版本管理工具能让你在同一台机器上轻松切换不同版本的 Node.js，下面为你介绍几款常用的工具及其安装和使用方法。

nvm（Node Version Manager）

nvm 是一款流行的跨平台 Node.js 版本管理工具，广泛应用于 Linux、macOS 以及 Windows（通过 WSL）系统。

安装步骤：

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

安装完成后，重启终端或者执行 source ~/.nvm/nvm.sh 使配置生效。

使用方法：

nvm install node        # 安装最新版本的 Node.js
nvm install 18.16.0     # 安装指定版本
nvm use 18.16.0         # 切换到指定版本
nvm list                # 查看已安装的版本
nvm current             # 查看当前使用的版本

n

n 是一个基于 Node.js 开发的版本管理工具，使用起来较为简单，不过它需要先安装 Node.js。

安装步骤：
```
npm install -g n
```

使用方法：

n latest                # 安装最新版本
n lts                   # 安装 LTS 版本
n 18.16.0               # 安装指定版本
n                       # 交互界面选择版本

fnm（Fast Node Manager）

fnm 是用 Rust 编写的版本管理工具，具有快速启动的特点，支持 Windows、Linux 和 macOS 系统。

安装步骤：

# macOS/Linux（使用 Homebrew）
brew install fnm

# 通用安装方法
curl -fsSL https://fnm.vercel.app/install | bash

使用方法：

fnm install 18.16.0     # 安装指定版本
fnm use 18.16.0         # 切换到指定版本
fnm default 18.16.0     # 设置默认版本
fnm list                # 查看已安装版本

版本管理工具的选择建议

nvm：适合需要在不同 Node.js 版本间频繁切换的开发者。
n：对于已经安装了 Node.js 且追求极简操作的用户是个不错的选择。
fnm：如果你的项目启动速度很重要，那么 fnm 会是理想的工具。

Windows 系统专用工具

nodist：这是 Windows 系统上的一款版本管理工具。
```
npm install -g nodist
```
Node.js 官方安装程序：如果你只需要一个稳定的 Node.js 版本，也可以直接从 Node.js 官网下载安装包。

这些工具都能帮助你高效管理 Node.js 版本，你可以根据自己的操作系统和使用习惯来选择合适的工具。
《Code Samples from SpringOne》是一份来自Spring技术大会的代码示例文档，主要展示了Spring生态系统的最新特性和最佳实践。以下是对其核心内容的解析：

1. Spring Boot 3 新特性

文档演示了Spring Boot 3的多项改进，包括：

GraalVM原生镜像支持：通过spring-boot-maven-plugin的native:compile目标生成轻量级容器镜像，启动时间缩短80%以上。

HTTP/3与WebClient增强：

WebClient client = WebClient.builder()
    .baseUrl("https://api.example.com")
    .clientConnector(new ReactorClientHttpConnector(
        HttpClient.create().http3()
    ))
    .build();

自动配置优化：引入@AutoConfiguration注解替代传统@Configuration，减少启动时的类扫描范围。

2. Spring Security 6 的 OAuth2 增强

展示了如何使用@RegisterOAuth2AuthorizedClient简化客户端注册：

@GetMapping("/resource")
public Mono<String> getResource(
    @RegisterOAuth2AuthorizedClient("my-client") OAuth2AuthorizedClient authorizedClient
) {
    // 使用已授权的客户端访问资源
}

新增的SecurityFilterChain配置支持基于URL模式的精确授权：

@Bean
SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/public/**").permitAll()
            .requestMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        )
        .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt)
        .build();
}

3. Spring Data Redis 事务与缓存

示例展示了Redis事务操作：

redisTemplate.execute(new SessionCallback<List<Object>>() {
    @Override
    public List<Object> execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        operations.opsForValue().set("key1", "value1");
        operations.opsForValue().increment("counter");
        return operations.exec();
    }
});

以及声明式缓存配置：

@Cacheable("products")
public Product getProduct(String id) {
    // 从数据库加载数据
}

@CacheEvict(value = "products", allEntries = true)
public void refreshProducts() {
    // 刷新缓存
}

4. Spring Cloud Gateway 路由断言工厂

文档演示了如何组合多种路由断言：

spring:
  cloud:
    gateway:
      routes:
        - id: user_route
          uri: lb://user-service
          predicates:
            - Path=/users/**
            - Method=GET,POST
            - Header=X-Request-Id, \d+
          filters:
            - RewritePath=/users/(?<segment>.*), /$\{segment}

5. Reactive 编程实践

包含了Flux和Mono的组合操作示例：

Flux<Integer> numbers = Flux.just(1, 2, 3, 4);
Flux<Integer> squares = numbers.map(n -> n * n);

Mono<List<Integer>> result = squares.collectList();
result.subscribe(System.out::println); // 输出 [1, 4, 9, 16]

以及WebFlux控制器：

@RestController
@RequestMapping("/api")
public class ReactiveController {
    @GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<DataPoint> streamData() {
        return dataService.getDataStream();
    }
}

总结

这些代码示例突出了Spring框架向响应式编程、云原生和容器化部署的演进趋势。核心亮点包括原生镜像支持带来的性能提升、Security的细粒度授权模型，以及Redis与Gateway在微服务架构中的深度集成。文档建议开发者优先采用函数式API和声明式配置，以提高代码的可维护性和性能。

SpringOne 是一个专注于 Spring 框架及相关技术的会议，通常会有许多技术分享和代码示例。以下是一些关于 SpringOne 代码示例的解析：

1. 环境感知（Environmental Awareness）

在 SpringOne 的一个演讲中，讨论了如何让应用程序感知其运行环境（如开发环境、测试环境、生产环境等），并根据环境动态调整配置。以下是几种实现方式：

加载额外的上下文配置文件：通过为不同环境加载特定的 Spring 配置文件，并利用 Bean 定义继承和覆盖，在配置阶段动态调整行为。
使用 JavaConfig：用 Java 代码代替 XML 定义环境依赖的 Bean，通过 JavaConfig 类决定创建哪些 Bean。
结合 JavaConfig 和继承：为每个环境创建扩展自通用基础配置的子类，利用 Java 的继承和多态特性。

2. 示例代码说明

示例代码展示了一个简单的服务和 DAO，用于通过名字查找姓氏。在默认情况下，仅定义了两个人（Alef 和演讲者）。在开发环境中，使用静态的 DAO 实现，始终返回“John Doe”；在验收环境中，添加了第三个人（Arjen）。通过集成测试验证应用程序在每个环境中的行为是否正确。

3. 环境检测方式

在这些示例中，通过系统属性（如 app.env）来判断应用程序的运行环境。其他方式可能包括检查数据库或 JNDI 注册表。

4. 代码运行方式

示例代码基于 Maven 构建，安装 Maven 后，可以通过以下命令运行测试：

mvn test：运行示例测试。
mvn -DdownloadSources=true eclipse:eclipse：生成 Eclipse 项目。
mvn package 或 mvn install：构建 JAR 和 WAR 文件。

5. 部署示例

示例中包含一个可通过 /[context-root]/env 访问的 Servlet。要查看不同环境下的行为，可以在启动服务器时添加系统属性 app.env，例如 -Dapp.env=D 会使应用程序以开发模式运行。

这些代码示例展示了 Spring 框架在处理复杂应用和多环境部署时的强大功能和灵活性。
Last week at SpringOne, Alef and I gave a talk on dealing with complex applications using Spring. Complexity in this case was considered both at the structural and dynamic level. As for the structural part of the talk, I covered that one in my previous blog posting. The dynamic part explained some possible solutions to deal with differences between your deployment environments. (testing, acceptance, production, etc.)
A lot of people asked me if I could provide them with the source of the demonstrations I gave during the talk. I’ve attached the sources to this blog entry and will explain briefly how this all works. Hopefully the talk itself will eventually become available on parleys.com later this year, so you can get some more background information on the topic.
Environmental Awareness: Support your runtime environment

In the talk I argued that dealing with differences between your environments by using custom build scripts that generate deployment units per environment comes with several disadvantages. One of those is that you cannot reuse your build artifacts (war or ear files) when your application promotes from for example your acceptance environment to your production environment. In order to address these disadvantages, you have to make your application environment aware: come up with some way to determine in what environment your app is running and then configure your app to react to that.

There are several ways to do this: in a Spring-application, the obvious way to enable environment-dependent behaviour is to have different bean definitions for each environment that requires non-default configuration. I’ve shown three ways to do that:

The first is to load extra context configuration files for certain environments. By using bean definition inheritance and overrides you can then take the appropriate actions at configuration time. When you use a ContextLoaderListener to configure your web application context, this requires some extra code, which is shown in the web project in the attached samples. BTW, credits for this idea should go to a former colleague of mine (Ezra, thanks!)
The second is to use JavaConfig instead of XML to define your environment-dependent beans. Where you determine what beans to create is then moved from determining what config files to load to your JavaConfig class.
The last sample combines the previous two to determine what JavaConfig class to use, where subclasses that extend a common base configuration are created for each environment. This showcases the power of having your configuration in an actual class: you can use regular java inheritance and polymorphism, which blurs the distinction between bean definition inheritance and class inheritance.

Other ways could include custom FactoryBean-implementations, for example.
The samples

The samples demonstrate the use of a simple service and dao that find a Person’s last name by first name. In the default case, only two persons are defined (Alef and I). In a development environment, we’ll use a static dao implementation instead that always returns a John Doe. In an acceptance environment, a third person (our collegue Arjen) is defined. The integration tests check if the correct behaviour is exposed by our application in each environment.

There are several ways you can check in what environment your application is running: for these samples, I’ve used a system property that is being used by the EnvironmentUtils class. Other ways could be to examine the database or a JNDI registry, for example.

Instead of just zipping up my Eclipse workspace, I’ve created a Maven sample UPDATE: Dave Turanski kindly updated the example to Spring 3.0: several people have tried to convince me to give Maven a second chance lately, after I had turned away from it in disgust a couple of years ago. I have to admit that Maven 2 is actually a lot better than Maven 1, although the generation of Eclipse workspace artifacts for web projects could use some improvement (like WTP 2 support). I missed some other stuff too, but that’s probably just an utter lack of experience on my part. The good thing is that I now do not have to package all the dependencies in my sample.

After installing Maven, you can run the sample tests by running ‘mvn test’ from the root directory. To generate Eclipse projects from the samples, run the following command: ‘mvn -DdownloadSources=true eclipse:eclipse’. To build the jars and war, use ‘mvn package’ or ‘mvn install’ to also add the build artifacts to your local repository.

The war contains a single servlet accessible as ‘/[context-root]/env’: to see the difference for each environment, start your servlet container with a system property called ‘app.env’ which holds the environment letter (D, T, A or P). So, -Dapp.env=D added to the startup line of your server would cause the application to run in development mode, which means that all last names returned will be ‘Doe’.

安装Maven之后，您可以通过从根目录运行“ mvn test”来运行示例测试。要从示例生成Eclipse项目，请运行以下命令：“ mvn -DdownloadSources = true eclipse：eclipse”。要构建罐子和战争，请使用“ mvn软件包”或“ mvn安装”将构建工件添加到本地存储库。

战争包含一个可通过’/ [context-root] / env’访问的servlet：要查看每种环境的不同，请使用一个名为’app.env’的系统属性启动servlet容器，该属性包含环境字母（D，T ，A或P）。因此，将-Dapp.env = D添加到服务器的启动行中会使该应用程序在开发模式下运行，这意味着返回的所有姓氏均为“ Doe”。