<think>我们正在处理一个任务：
使用OpenRewrite将Spring中通过
@Autowired字段
注入的方式改为
构造函数
注入。根据引用，我们知道Spring官方推荐
使用构造函数
注入，因为它可以确保依赖的不可变性和完全初始化，避免空指针异常等问题。
OpenRewrite是一个用于源
代码重构的工具，可以自动进行
代码转换。我们需要一个OpenRewrite的recipe（配方）来实现将字段
注入改为
构造函数
注入。步骤：1.识别所有
使用@Autowired注解的字段（包括private、protected等）。2.删除这些字段上的
@Autowired注解。3.为这些字段创建一个
构造函数（如果类中不存在
构造函数的话），或者修改现有的
构造函数以包含这些字段作为
参数。4.在
构造函数中将这些
参数赋值给字段。5.同时，我们需要确保在Spring配置中能够通过
构造函数
注入（Spring会自动处理，只要存在一个
构造函数，并且
参数类型在Spring容器中可找到）。注意：如果类中已经存在一个
构造函数，我们需要将新的依赖
参数添加到这个
构造函数中（注意，如果已经有一个带
参数的
构造函数，那么我们需要将新的依赖加入到这个
构造函数的
参数列表中，并确保在创建对象时传入）。但是，我们需要注意，如果类中已经有一个无参
构造函数和一个有参
构造函数，那么我们需要考虑合并？实际上，Spring支持多个
构造函数，但需要用
@Autowired来指定
使用哪一个。但我们的目标是消除
@Autowired，所以我们希望只有一个
构造函数（用于
注入所有必需的依赖）。因此，这个recipe可能需要：-删除无参
构造函数（如果存在且没有其他用途），或者-将现有的有参
构造函数扩展，加入新的依赖。然而，这可能会很复杂，因为可能有多个字段
注入，并且可能已经存在多个
构造函数。因此，一个保守的做法是：为每个类创建一个包含所有被
@Autowired注解字段的
构造函数，并删除这些字段上的
@Autowired。但是，如果类中已经有一个
构造函数（无论是有参还是无参），我们可以考虑以下情况：-如果已经有一个
构造函数，那么我们就将当前字段
注入的依赖加入到这个
构造函数的
参数中（如果这个
构造函数已经包含了部分依赖，那么我们就添加缺失的依赖）。-如果类中有多个
构造函数，那么我们需要选择一个（通常选择
参数最多的那个，或者
使用@Autowired注解的那个
构造函数）来添加这些字段依赖。但是，在转换后，我们希望只有一个
构造函数（即用于依赖
注入的那个），因此可能需要删除其他
构造函数？这并不总是安全的，因为其他
构造函数可能用于其他目的（比如测试）。所以，更安全的做法是：只修改一个
构造函数（通常是主
构造函数）来包含所有必需的依赖，并保留其他
构造函数（但需要确保它们调用主
构造函数，或者通过其他方式初始化依赖？）。这可能会超出简单的recipe范围。因此，OpenRewrite可能有一个现成的recipe来处理这种转换？我们可以
使用`org.openrewrite.java.spring.No
AutowiredAnnotation`这个recipe吗？或者`org.openrewrite.java.spring.UseConstructorInjection`？实际上，OpenRewrite有一个名为`org.openrewrite.java.spring.No
AutowiredAnnotation`的recipe，它用于移除字段上的`
@Autowired`注解，并创建一个包含这些字段的
构造函数（如果不存在的话）。同时，它也会移除setter方法上的`
@Autowired`。但是，我们还需要考虑：-如果类中已经有一个
构造函数，那么它会将新的依赖添加到现有
构造函数中吗？还是创建一个新的
构造函数？-如果类中已经存在一个
构造函数，并且
参数列表与要添加的依赖不完全相同，那么它会合并吗？根据OpenRewrite的文档，`No
AutowiredAnnotation` recipe会：-移除字段上的`
@Autowired`-移除setter方法上的`
@Autowired`-然后，它会为这些字段生成一个
构造函数（如果不存在
构造函数的话）。如果已经存在一个
构造函数，它会将新的依赖作为
参数添加到这个
构造函数的
参数列表中（如果该字段还没有在
构造函数中初始化的话）。但是，注意：如果字段已经在一个
构造函数中被初始化（即该字段已经在
构造函数中有赋值），那么就不会再添加。因此，我们可以
使用这个recipe。操作步骤：1.在项目的根目录下创建一个名为`rewrite.yml`的配置文件（或者
使用OpenRewrite的Maven/Gradle插件）。2.配置recipe为`org.openrewrite.java.spring.No
AutowiredAnnotation`。示例配置（rewrite.yml）：```type: specs.openrewrite.org/v1beta/recipename: com.yourorg.No
AutowiredAnnotationExampledisplayName:Remove
@AutowiredrecipeList:-org.openrewrite.java.spring.No
AutowiredAnnotation```然后运行OpenRewrite（通过Maven或Gradle插件）来应用这个recipe。但是，我们还需要注意：这个recipe可能会将setter方法上的
@Autowired也移除，并可能将setter方法转换为
构造函数
注入（通过将setter方法的
参数添加到
构造函数中）。但我们的需求是字段
注入改为
构造函数
注入，所以setter方法
注入不在本次讨论范围内（但recipe会一起处理）。另外，如果类中已经存在一个
构造函数，并且该
构造函数已经初始化了部分字段，那么recipe会将剩余的字段（被
@Autowired注解的）添加到这个
构造函数的
参数中，并在
构造函数体内初始化。但是，如果类中已经有一个有参
构造函数，但没有初始化所有字段，那么recipe会修改这个
构造函数，添加缺失的字段作为
参数，并在
构造函数体内初始化这些字段。然而，如果类中已经有一个无参
构造函数，那么recipe会将其转换为有参
构造函数，
参数就是所有被
@Autowired注解的字段（在转换后，无参
构造函数会被删除？）。实际上，recipe会修改现有的无参
构造函数，将其改为有参（
参数就是这些字段），并在
构造函数体内进行赋值。但是，如果类中已经存在多个
构造函数，那么recipe会选择其中一个（可能是第一个？）进行修改。这可能会导致问题，因为多个
构造函数可能用于不同目的。因此，在应用recipe后，需要手动检查。因此，建议在应用recipe后，进行
代码审查和测试。另外，OpenRewrite还提供了一个叫做`org.openrewrite.java.spring.AutoConstructor`的recipe，它会将字段
注入改为
构造函数
注入，并且只作用于标记了`@Component`、`@Service`等Spring注解的类。但是，我们这里没有提到这个recipe，所以还是
使用`No
AutowiredAnnotation`。总结：
使用`org.openrewrite.java.spring.No
AutowiredAnnotation`recipe可以自动将字段
注入改为
构造函数
注入。步骤：1.在项目中配置OpenRewrite（Maven或Gradle）。2.创建rewrite.yml配置文件，包含上述recipe。3.运行OpenRewrite（例如：`mvn rewrite:run`或 `gradlewrewriteRun`）。注意：在运行之前，请确保备份
代码或
使用版本控制，因为重构可能不完美，需要手动调整。示例转换：转换前：
```javaimport org.springframework.
beans.factory.annotation.
Autowired;import org.springframework.stereotype.Service;@Servicepublicclass UserService {
@AutowiredprivateUserRepositoryuserRepository;
}```转换后：
```javaimport org.springframework.stereotype.Service;@Servicepublicclass UserService {privatefinal UserRepository userRepository;publicUserService(UserRepositoryuserRepository) {this.userRepository= userRepository;}}
```可以看到，
@Autowired被移除，并生成了一个
构造函数。如果类中已经有一个
构造函数，比如：转换前：
```java@Servicepublicclass UserService {
@AutowiredprivateUserRepositoryuserRepository;private finalEmailServiceemailService;public UserService(EmailServiceemailService) {this.emailService= emailService;}}
```转换后：```java@Servicepublic classUserService{private finalUserRepositoryuserRepository;private finalEmailServiceemailService;public UserService(EmailServiceemailService, UserRepository userRepository){this.emailService =emailService;this.userRepository =userRepository;}
}```注意：
构造函数的
参数顺序可能会根据字段的声明顺序？或者字母顺序？实际上，OpenRewrite可能会按照字段在类中出现的顺序来添加
参数。但具体实现需要看OpenRewrite的源码。因此，我们推荐
使用`org.openrewrite.java.spring.No
AutowiredAnnotation`recipe来实现这个转换。相关问题：1.
使用OpenRewrite进行重构后，如何验证
代码的正确性？2.除了移除
@Autowired字段
注入，OpenRewrite还能进行哪些Spring相关的重构？3.如果类中已经存在多个
构造函数，OpenRewrite如何处理？4.在转换过程中，OpenRewrite如何确保依赖的顺序？5.
使用构造函数
注入后，如何解决循环依赖问题？</think>###
使用 OpenRewrite 将 Spring
@Autowired 字段
注入改为
构造函数
注入
OpenRewrite 是一个自动化源
代码重构工具，可高效实现 `
@Autowired` 字段
注入到
构造函数
注入的转换。以下是详细步骤：
#### 1. **添加 OpenRewrite 依赖**
在 Maven 项目的 `pom.xml` 中添加：
```xml
<build>
<plugins>
<plugin>
<groupId>org.openrewrite.maven</groupId>
<artifactId>rewrite-maven-plugin</artifactId>
<version>5.8.1</version>
<configuration>
<activeRecipes>
<recipe>org.openrewrite.java.spring.No
AutowiredAnnotation</recipe>
</activeRecipes>
</configuration>
<dependencies>
<dependency>
<groupId>org.openrewrite.recipe</groupId>
<artifactId>rewrite-spring</artifactId>
<version>5.7.0</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
```
#### 2. **执行转换命令**
运行以下 Maven 命令：
```bash
mvn rewrite:run
```
#### 3. **转换机制详解**
OpenRewrite 的 `No
AutowiredAnnotation` Recipe 会：
- **识别注解**：扫描所有 `
@Autowired` 字段（包括 `private UserRepository userRepository;`）。
- **生成
构造函数**：
- 若类无
构造函数，创建包含所有依赖
参数的新
构造函数。
- 若已有
构造函数，将新依赖合并到
参数列表中。
- **移除注解**：删除字段上的 `
@Autowired`。
- **添加初始化**：在
构造函数中插入字段赋值语句（如 `this.userRepository = userRepository;`）。
- **添加 `@RequiredArgsConstructor`**：若适用，为无业务逻辑的类添加
Lombok 注解。
#### 4. **转换示例**
**转换前**：
```java
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Autowired
private EmailService emailService;
}
```
**转换后**：
```java
@Service
public class UserService {
private final UserRepository userRepository;
private final EmailService emailService;
public UserService(UserRepository userRepository, EmailService emailService) {
this.userRepository = userRepository;
this.emailService = emailService;
}
}
```
#### 5. **验证与调整**
- **编译检查**：运行 `mvn clean compile` 验证语法。
- **测试覆盖**：执行单元测试确保业务逻辑不受影响。
- **手动调整**：
- 若存在循环依赖，需重构
代码设计（如引入 `@Lazy` 或拆分功能）。
- 多
构造函数场景需手动指定 `
@Autowired` 注解（但应尽量避免）。
#### 优势说明
- **不可变性**：`final` 字段确保依赖不可变[^1]。
- **空指针安全**：消除字段
注入的未初始化风险[^3]。
- **可测试性**：
构造函数
注入更易模拟依赖进行单元测试[^4]。
> **注意**：转换后需删除
Lombok 的 `@RequiredArgsConstructor`（若手动生成
构造函数），避免重复
代码。
---
### 相关问题
1. **OpenRewrite 转换后如何解决循环依赖问题？**
构造函数
注入天然不支持循环依赖，需通过设计模式（如事件驱动）或
代码重构解决。
2. **转换过程中 OpenRewrite 如何处理
Lombok 注解？**
OpenRewrite 会优先保留现有
构造函数。若类含 `@AllArgsConstructor`，可能直接复用而非新建。
3. **除了字段
注入，OpenRewrite 能否转换 setter
注入？**
是。`No
AutowiredAnnotation` Recipe 会同时移除 setter 方法上的 `
@Autowired`，并合并
参数到
构造函数。
4. **转换后如何验证依赖项是否全部被正确初始化？**
通过 Spring 启动测试（如 `@SpringBootTest`）检查上下文加载是否成功，或
使用断言验证
构造函数
参数。
5. **OpenRewrite 是否支持 Kotlin 项目的自动转换？**
是。需
使用 `rewrite-kotlin` 插件，转换逻辑类似（如主
构造函数生成）。
[^1]:
构造函数
注入确保依赖不可变性和对象完整性
[^2]: Spring 官方推荐 controller 层
使用构造函数
注入
[^3]: 字段
注入存在空指针异常风险
[^4]:
构造函数
注入提升可测试性和
代码健壮性
本文介绍如何使用Lombok的@RequiredArgsConstructor注解简化Spring框架中Controller和服务层的依赖注入过程，使得代码更加简洁易读。
扫一扫
2169
到【灌水乐园】发言
