如何使用OpenRewrite精准修改带有特定注解的方法参数

type: specs.openrewrite.org/v1beta/recipe
name: org.example.MandatoryRequestParameter
displayName: Make Spring `RequestParam` mandatory
description: Add `required` attribute to `RequestParam` and set the value to `true`.
recipeList:
  - org.openrewrite.java.AddOrUpdateAnnotationAttribute:
      annotationType: org.springframework.web.bind.annotation.RequestParam
      attributeName: required
      attributeValue: "true"

<plugin>
  <groupId>org.openrewrite.maven</groupId>
  <artifactId>rewrite-maven-plugin</artifactId>
  <version>4.38.0</version> <!-- 使用最新版本 -->
  <configuration>
    <activeRecipes>
      <recipe>org.example.MandatoryRequestParameter</recipe>
    </activeRecipes>
  </configuration>
  <dependencies>
    <dependency>
      <groupId>org.openrewrite.recipe</groupId>
      <artifactId>rewrite-spring</artifactId>
      <version>5.3.0</version> <!-- 包含Spring相关配方，可能需要根据实际情况调整 -->
    </dependency>
  </dependencies>
</plugin>

import org.openrewrite.ExecutionContext;
import org.openrewrite.Recipe;
import org.openrewrite.TreeVisitor;
import org.openrewrite.java.AddOrUpdateAnnotationAttribute;
import org.openrewrite.java.JavaIsoVisitor;
import org.openrewrite.java.JavaVisitor;
import org.openrewrite.java.UsesType;
import org.openrewrite.java.tree.J;
import org.openrewrite.java.tree.JavaType;
import org.openrewrite.java.tree.TypeUtils;

import javax.validation.constraints.NotNull; // 导入此注解以供检查

public class MandatoryRequestParameter extends Recipe {

    private static final String REQUEST_PARAM_FQ_NAME = "org.springframework.web.bind.annotation.RequestParam";
    private static final String NOT_NULL_FQ_NAME = "javax.validation.constraints.NotNull"; // NotNull注解的完全限定名

    @Override
    public @NotNull String getDisplayName() {
        return "Make Spring RequestParam mandatory conditionally";
    }

    @Override
    public String getDescription() {
        return "Adds 'required=true' to @RequestParam annotations on method parameters that also have @NotNull.";
    }

    @Override
    protected TreeVisitor<?, ExecutionContext> getSingleSourceApplicableTest() {
        // 优化：只有当源文件引用了RequestParam或NotNull注解时才运行此Visitor
        return new UsesType<>(REQUEST_PARAM_FQ_NAME);
    }

    @Override
    protected @NotNull JavaVisitor<ExecutionContext> getVisitor() {

        // 预先创建AddOrUpdateAnnotationAttribute的Visitor实例
        // 这样可以避免在每次visitAnnotation时都创建新实例
        JavaIsoVisitor addAttributeVisitor = new AddOrUpdateAnnotationAttribute(
                REQUEST_PARAM_FQ_NAME, "required", "true", false
        ).getVisitor();

        return new JavaIsoVisitor<ExecutionContext>() {
            @Override
            public J.Annotation visitAnnotation(J.Annotation annotation, ExecutionContext ctx) {
                J.Annotation a = super.visitAnnotation(annotation, ctx);

                // 1. 检查当前注解是否为 @RequestParam
                if (!TypeUtils.isOfClassType(a.getType(), REQUEST_PARAM_FQ_NAME)) {
                    return a;
                }

                // 2. 通过Cursor获取其父级，即J.VariableDeclarations（方法参数声明）
                // 确保父级是J.VariableDeclarations类型
                J.VariableDeclarations variableDeclaration = getCursor().getParent(2).getValue(); // 向上两级，Annotation -> J.Annotation.Arguments -> J.VariableDeclarations
                if (variableDeclaration == null) {
                    return a; // 如果无法获取到VariableDeclarations，则返回
                }

                // 3. 检查该方法参数是否同时带有 @NotNull 注解
                boolean hasNotNull = variableDeclaration.getLeadingAnnotations().stream()
                        .anyMatch(ann -> TypeUtils.isOfClassType(ann.getType(), NOT_NULL_FQ_NAME));

                if (hasNotNull) {
                    // 如果条件匹配，则将修改操作委托给预先创建的addAttributeVisitor
                    // 关键在于传递当前的a和ctx以及getCursor()，确保上下文正确
                    return (J.Annotation) addAttributeVisitor.visit(a, ctx, getCursor());
                }
                return a;
            }
        };
    }
}

import org.junit.jupiter.api.Test;
import org.openrewrite.java.JavaParser;
import org.openrewrite.test.RecipeSpec;
import org.openrewrite.test.RewriteTest;

import static org.openrewrite.java.Assertions.java;

class MandatoryRequestParameterTest implements RewriteTest {

    @Override
    public void defaults(RecipeSpec spec) {
        spec.recipe(new MandatoryRequestParameter())
            .parser(JavaParser.fromJavaVersion().classpath("spring-web", "validation-api")); // 确保classpath包含相关依赖
    }

    @Test
    void requiredRequestParamWithNotNull() {
        rewriteRun(
            java(
                """
                  import org.springframework.web.bind.annotation.RequestParam;
                  import javax.validation.constraints.NotNull;

                  class ControllerClass {
                      public String sayHello (
                          @NotNull @RequestParam(value = "name") String name, // 应该被修改
                          @RequestParam(value = "lang") String lang, // 不应被修改
                          @NotNull String address, // 不应被修改，因为它不是RequestParam
                          @NotNull @RequestParam(value = "age") Long age // 应该被修改
                      ) {
                         return "Hello";
                      }
                  }
                """,
                """
                  import org.springframework.web.bind.annotation.RequestParam;
                  import javax.validation.constraints.NotNull;

                  class ControllerClass {
                      public String sayHello (
                          @NotNull @RequestParam(required = true, value = "name") String name,
                          @RequestParam(value = "lang") String lang,
                          @NotNull String address,
                          @NotNull @RequestParam(required = true, value = "age") Long age
                      ) {
                         return "Hello";
                      }
                  }
                """
            )
        );
    }
}