Marshall趙

获取参数名称

2023/08/07 零散知识点 共 28679 字，约 82 分钟
闷骚的程序员

1. proceedingJoinPoint如何获取到目标方法的参数？以及获取到目标方法的参数名称？

在 Spring AOP 中，如果你想在 proceedingJoinPoint 中获取目标方法的参数和参数名称，可以通过以下步骤实现：

1. 获取目标方法的参数

使用 ProceedingJoinPoint 的 getArgs() 方法可以获取到目标方法的参数。这个方法返回的是一个 Object 数组，数组中的每个元素对应目标方法的一个参数。

2. 获取参数名称

要获取参数名称，你可以使用反射来访问目标方法的参数名称。为了能够获取到参数名称，需要在编译时开启 -parameters 选项，或者使用 Java 8 及以上版本的 Method 类的 getParameters() 方法。

示例代码

以下是一个示例，展示如何在切面中获取目标方法的参数和参数名称：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 获取目标方法的参数
        Object[] args = proceedingJoinPoint.getArgs();

        // 获取目标方法的名称
        String methodName = proceedingJoinPoint.getSignature().getName();

        // 获取目标方法的类
        Class<?> targetClass = proceedingJoinPoint.getTarget().getClass();

        // 获取目标方法的参数类型
        Method method = targetClass.getMethod(methodName, getParameterTypes(args));

        // 获取参数名称
        String[] parameterNames = getParameterNames(method);

        // 打印参数及其名称
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        // 继续执行目标方法
        return proceedingJoinPoint.proceed();
    }

    private Class<?>[] getParameterTypes(Object[] args) {
        Class<?>[] parameterTypes = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            parameterTypes[i] = args[i].getClass();
        }
        return parameterTypes;
    }

    private String[] getParameterNames(Method method) {
        return Arrays.stream(method.getParameters())
                .map(parameter -> parameter.getName())
                .toArray(String[]::new);
    }
}

注意事项

  • 参数名称：确保在编译时使用 -parameters 选项，或者使用 Spring 的 @RequestParam 等注解来明确指定参数名称。
  • 反射性能：反射操作可能会影响性能，尽量在不影响性能的情况下使用。
  • 异常处理：在切面中，建议做好异常处理，以免影响目标方法的正常执行。

这样，你就可以在 AOP 切面中获取目标方法的参数及其名称了。

2. 还有其他方式吗？

除了使用 ProceedingJoinPoint 的 getArgs() 方法和反射来获取目标方法的参数及其名称外，还有其他几种方法可以实现这个目的：

1. 使用 AOP 代理的参数注解

如果你知道目标方法的参数名称，可以在切面中直接使用 Spring 的参数注解，如 @RequestParam、@PathVariable 等，获取参数值。需要注意的是，这种方法主要适用于 Web 应用程序。

示例代码：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.web.bind.annotation.RequestParam;

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Object[] args = joinPoint.getArgs();

        Annotation[][] parameterAnnotations = method.getParameterAnnotations();

        for (int i = 0; i < parameterAnnotations.length; i++) {
            for (Annotation annotation : parameterAnnotations[i]) {
                if (annotation instanceof RequestParam) {
                    String paramName = ((RequestParam) annotation).value();
                    System.out.println("Parameter Name: " + paramName + ", Value: " + args[i]);
                }
            }
        }
    }
}

2. 使用 AspectJ 的 @Around 注解和 JoinPoint

通过使用 AspectJ 的 @Around 注解和 JoinPoint，你可以在方法执行前后处理参数，获取更灵活的信息。

示例代码：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(JoinPoint joinPoint) throws Throwable {
        Object[] args = joinPoint.getArgs();

        // 获取目标方法的签名
        String methodName = joinPoint.getSignature().toShortString();

        // 打印参数
        System.out.println("Method: " + methodName);
        for (Object arg : args) {
            System.out.println("Argument: " + arg);
        }

        // 继续执行目标方法
        return ((ProceedingJoinPoint) joinPoint).proceed();
    }
}

3. 使用 Spring 提供的 @Validated 和自定义注解

如果你有自定义参数校验的需求，可以使用 Spring 的 @Validated 结合自定义注解，处理参数的值。

4. 使用 Bean Validation

可以结合 JSR-303 (如 Hibernate Validator) 对参数进行校验，之后在切面中根据参数的校验结果做进一步处理。这可以间接帮助你了解参数的结构和类型。

5. 使用 Spring 表达式语言 (SpEL)

在切面中，你可以使用 Spring 表达式语言来提取特定的参数值。这种方法相对较为复杂，但在一些复杂场景中会很有用。

总结

虽然 ProceedingJoinPoint 和反射是最常用的方法，但根据应用场景的不同，你可以结合参数注解、AspectJ 的特性、Spring Validation 或自定义逻辑来实现目标方法参数的获取。这些方法可以提高代码的灵活性和可读性。

3. 我的核心是获取目标方法每个参数的名称

要获取目标方法每个参数的名称，可以使用反射结合 Spring AOP 的 ProceedingJoinPoint，但是你必须确保在编译时启用了参数名称保留选项。以下是几种方法，详细介绍了如何获取目标方法每个参数的名称：

1. 使用 Method.getParameters() 方法

在 Java 8 及以上版本中，可以使用 Method.getParameters() 方法来获取方法参数的名称。请确保在编译时使用了 -parameters 选项。

示例代码

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 获取目标方法的名称
        String methodName = proceedingJoinPoint.getSignature().getName();

        // 获取目标方法的类
        Class<?> targetClass = proceedingJoinPoint.getTarget().getClass();

        // 获取参数类型
        Object[] args = proceedingJoinPoint.getArgs();
        Class<?>[] parameterTypes = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            parameterTypes[i] = args[i] != null ? args[i].getClass() : Object.class; // 处理 null 参数
        }

        // 获取目标方法
        Method method = targetClass.getMethod(methodName, parameterTypes);

        // 获取参数名称
        String[] parameterNames = getParameterNames(method);

        // 打印参数名称和对应的值
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        // 继续执行目标方法
        return proceedingJoinPoint.proceed();
    }

    private String[] getParameterNames(Method method) {
        return Arrays.stream(method.getParameters())
                .map(parameter -> parameter.getName())
                .toArray(String[]::new);
    }
}

2. 使用 Spring 的 @RequestParam 等注解

在 Web 应用中，可以直接在方法参数上使用注解，如 @RequestParam 来指明参数名称。在切面中通过反射获取这些注解信息，从而获得参数名称。

示例代码

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.example.controller.*.*(..))")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Object[] args = joinPoint.getArgs();

        // 获取参数注解
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();

        for (int i = 0; i < parameterAnnotations.length; i++) {
            for (Annotation annotation : parameterAnnotations[i]) {
                if (annotation instanceof RequestParam) {
                    String paramName = ((RequestParam) annotation).value();
                    System.out.println("Parameter Name: " + paramName + ", Value: " + args[i]);
                }
            }
        }
    }
}

3. 使用 Lombok 的 @Accessors 注解

如果你使用 Lombok，可以通过 Lombok 的 @Accessors 注解结合反射获取字段的名称。这种方式比较适合用于数据传输对象（DTO）或模型类。

4. 使用 AspectJ

AspectJ 直接支持对参数名称的访问，可以通过编译时织入来保留参数名称信息。配置 AspectJ 的项目并在切面中使用类似的逻辑。

总结

  • 使用反射和 Method.getParameters() 是获取参数名称的最通用和直接的方法。
  • 在 Web 应用中，可以利用 Spring 的参数注解如 @RequestParam 来指定参数名称。
  • 确保在编译时使用了 -parameters 选项，以便能够在运行时获取到参数的名称。

通过上述方法，你可以有效地获取目标方法每个参数的名称。

4. 使用AspectJ具体怎么处理？获取目标方法的参数名称

使用 AspectJ 获取目标方法的参数名称相对简单，AspectJ 通过编译时织入支持参数名称的保留，这使得你可以直接访问参数的名称而无需额外的配置或反射。下面是如何使用 AspectJ 来实现这一功能的具体步骤：

1. 配置 AspectJ

确保你的项目已经配置好 AspectJ。如果你在使用 Maven，可以添加以下依赖到你的 pom.xml 中：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version> <!-- 或最新版本 -->
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.7</version> <!-- 或最新版本 -->
</dependency>

2. 启用编译时织入

在使用 AspectJ 进行参数名称提取时，需要启用编译时织入（Compile-Time Weaving, CTW）。在项目的 META-INF/aop.xml 文件中添加以下配置：

<aspectj>
    <weaver>
        <include within="com.example.*"/> <!-- 包含你的应用包 -->
    </weaver>
    <aspects>
        <aspect name="com.example.aspect.MyAspect"/> <!-- 切面类的完整路径 -->
    </aspects>
</aspectj>

3. 编写切面

创建切面类，使用 @Aspect 注解来定义切面。在切面中，可以通过 @Around 注解定义环绕通知并获取参数名称。

示例代码

package com.example.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 获取目标方法
        String methodName = proceedingJoinPoint.getSignature().getName();
        Class<?> targetClass = proceedingJoinPoint.getTarget().getClass();

        // 使用反射获取目标方法的参数
        Method method = targetClass.getMethod(methodName, getParameterTypes(proceedingJoinPoint));

        // 获取参数名称
        String[] parameterNames = getParameterNames(method);

        // 获取参数值
        Object[] args = proceedingJoinPoint.getArgs();

        // 打印参数名称和对应的值
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        // 继续执行目标方法
        return proceedingJoinPoint.proceed();
    }

    private Class<?>[] getParameterTypes(ProceedingJoinPoint pjp) {
        return Arrays.stream(pjp.getArgs())
                .map(arg -> arg != null ? arg.getClass() : Object.class)
                .toArray(Class<?>[]::new);
    }

    private String[] getParameterNames(Method method) {
        return Arrays.stream(method.getParameters())
                .map(parameter -> parameter.getName())
                .toArray(String[]::new);
    }
}

4. 运行时注意事项

  • 确保使用 Java 8 及以上版本：因为参数名称的保留在 Java 8 及更高版本中支持。
  • 编译选项：在编译项目时，确保使用了 -parameters 选项，以便在字节码中保留参数名称信息。

5. 验证功能

确保目标方法在调用时可以正常获取参数名称和参数值。你可以通过简单的测试用例来验证切面的功能是否正常工作。

总结

通过使用 AspectJ 和编译时织入，获取目标方法的参数名称变得非常直接。你可以通过反射获取方法信息，并使用 Method.getParameters() 方法来提取参数名称。确保项目配置正确，以便无缝集成 AspectJ。

5. -parameters 这个选项具体如何配置？

要在 Java 项目中启用 -parameters 编译选项，以便在编译时保留方法参数的名称，你需要根据你的构建工具进行配置。以下是 Maven 和 Gradle 的具体配置步骤。

1. Maven 项目

在 Maven 项目中，可以通过配置 maven-compiler-plugin 来启用 -parameters 选项。

示例 pom.xml 配置

<project>
    ...
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version> <!-- 或最新版本 -->
                <configuration>
                    <source>1.8</source> <!-- 指定源版本 -->
                    <target>1.8</target> <!-- 指定目标版本 -->
                    <compilerArgs>
                        <arg>-parameters</arg> <!-- 启用参数名称保留 -->
                    </compilerArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ...
</project>

2. Gradle 项目

在 Gradle 项目中，可以通过配置 compileJava 任务来启用 -parameters 选项。

示例 build.gradle 配置

plugins {
    id 'java'
}

java {
    sourceCompatibility = '1.8' // 指定源版本
    targetCompatibility = '1.8' // 指定目标版本
}

tasks.withType(JavaCompile) {
    options.compilerArgs << '-parameters' // 启用参数名称保留
}

3. IntelliJ IDEA 配置

如果你使用 IntelliJ IDEA 作为 IDE，你可以在 IDE 中单独配置这个选项：

  1. 打开项目设置（File > Project Structure）。
  2. 选择 “Modules”，然后选择你的模块。
  3. 在 “Compiler” 标签页中，找到 “Additional command line parameters” 输入框。
  4. 添加 -parameters 到该输入框中。
  5. 点击 “Apply” 和 “OK” 保存更改。

4. Eclipse 配置

如果你使用 Eclipse，以下是启用 -parameters 选项的方法：

  1. 右击你的项目，选择 “Properties”。
  2. 转到 “Java Compiler”。
  3. 点击 “Compiler compliance level” 下拉菜单，选择你需要的 Java 版本（确保选择 1.8 或更高版本）。
  4. 点击 “Configure project specific settings”。
  5. 在 “Compiler options” 中，找到 “Additional command line arguments”。
  6. 添加 -parameters。
  7. 点击 “Apply” 和 “OK” 保存更改。

5. 验证参数名称保留

启用 -parameters 后，编译代码时，方法参数的名称会被保留在生成的字节码中。可以通过反射验证这一点：

Method method = YourClass.class.getMethod("yourMethod", YourParameterClass.class);
String parameterName = method.getParameters()[0].getName(); // 获取参数名称
System.out.println(parameterName);

总结

通过在你的构建工具中配置 -parameters 选项，你可以在编译 Java 代码时保留方法参数的名称。这对于反射和其他动态特性非常有用，尤其是在 AOP 等场景中。确保你的项目正确配置后，即可在运行时访问参数名称。

6. 必须写在arg内吗？

在 Maven 和 Gradle 中，-parameters 选项确实需要作为参数传递给编译器。具体来说，以下是关于如何配置它的说明：

Maven 配置

在 Maven 中，-parameters 必须放在 <arg> 标签内，以便在执行编译时传递给 Java 编译器。

示例代码

<project>
    ...
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version> <!-- 使用适当版本 -->
                <configuration>
                    <source>1.8</source> <!-- 指定源版本 -->
                    <target>1.8</target> <!-- 指定目标版本 -->
                    <compilerArgs>
                        <arg>-parameters</arg> <!-- 必须在这里 -->
                    </compilerArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ...
</project>

Gradle 配置

在 Gradle 中，-parameters 也需要在 options.compilerArgs 列表中，以确保在编译时传递给 Java 编译器。

示例代码

tasks.withType(JavaCompile) {
    options.compilerArgs << '-parameters' // 必须在这里
}

IntelliJ IDEA 和 Eclipse 配置

对于 IntelliJ IDEA 和 Eclipse，虽然具体界面不同，但原则上都是通过特定的输入框来指定编译器的额外参数。在这两个 IDE 中，你也需要确保将 -parameters 作为单独的参数输入，而不是其他地方的配置。

小结

是的，-parameters 选项必须在指定的 arg 标签或编译器参数列表中。它不会被自动识别，如果不在正确的位置，编译器将不会启用该选项，因此在使用 AOP 和反射访问参数名称时，你将无法获取参数名称。

7. 我的配置中还多了一个false

在 Maven 的 maven-compiler-plugin 配置中，<debug> 标签用于控制是否在编译的类文件中包含调试信息。设置为 false 意味着在编译时不生成调试信息，这通常是为了减小生成的类文件的大小。

示例 Maven 配置

以下是包含 <debug> 标签的完整示例配置：

<project>
    ...
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version> <!-- 使用适当版本 -->
                <configuration>
                    <source>1.8</source> <!-- 指定源版本 -->
                    <target>1.8</target> <!-- 指定目标版本 -->
                    <debug>false</debug> <!-- 不生成调试信息 -->
                    <compilerArgs>
                        <arg>-parameters</arg> <!-- 必须在这里 -->
                    </compilerArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ...
</project>

说明

  • <debug>false</debug>: 设置为 false 时，编译器将不会在类文件中包含调试信息。这可能会导致在调试时缺乏信息（例如，变量名、行号等），但可以减小生成的 .class 文件的体积。
  • <arg>-parameters</arg>: 这个选项确保方法参数名称在字节码中被保留，允许你在运行时通过反射获取参数名称。

影响

  • 如果你在开发或调试阶段，建议将 <debug> 设置为 true 以保留调试信息，以便于在 IDE 中进行调试。
  • 在生产环境中，通常建议将其设置为 false，以减小最终构建的体积。

总结

你可以根据需要在 Maven 配置中包含 <debug> 标签。它与 -parameters 的使用是独立的，可以根据项目需求灵活配置。确保你了解这种配置对调试和生产构建的影响，以便在适当的环境中使用。

8. 说白了还是如何获取目标方法参数名称的问题，我想废弃javassist的方式，改用其他的方式，请告诉我所有可能的方式，比如我已经引入了mapstruct和lombok等

如果你希望获取目标方法的参数名称，而不依赖于 Javassist，可以考虑以下几种方式来实现这一需求，包括使用 Lombok、MapStruct、Spring AOP、AspectJ，以及 Java 自身的反射机制。以下是每种方法的详细说明：

1. Java 反射与编译器参数

在 Java 8 及以上版本中，可以通过反射获取方法参数的名称，但必须在编译时启用 -parameters 选项。

示例代码

import java.lang.reflect.Method;

public class ParameterNameExample {

    public void exampleMethod(String param1, int param2) {}

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = ParameterNameExample.class.getMethod("exampleMethod", String.class, int.class);
        String[] parameterNames = Arrays.stream(method.getParameters())
                                        .map(parameter -> parameter.getName())
                                        .toArray(String[]::new);

        System.out.println(Arrays.toString(parameterNames)); // 输出: [param1, param2]
    }
}

2. Spring AOP

使用 Spring AOP，可以在切面中访问方法参数，但获取参数名称需要结合 Java 反射。

示例代码

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
        String[] parameterNames = Arrays.stream(method.getParameters())
                                        .map(parameter -> parameter.getName())
                                        .toArray(String[]::new);

        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        return pjp.proceed();
    }
}

3. AspectJ

使用 AspectJ 可以更直接地获取参数名称，尤其是在使用编译时织入时。

示例代码

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Method method = ((MethodSignature) pjp.getSignature()).getMethod();
        String[] parameterNames = Arrays.stream(method.getParameters())
                                        .map(parameter -> parameter.getName())
                                        .toArray(String[]::new);

        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        return pjp.proceed();
    }
}

4. Lombok

Lombok 本身并不直接支持获取方法参数名称，但可以结合其他技术使用。通过 Lombok 的 @Data 注解自动生成的 getter 方法，可以在运行时访问字段名。结合反射可达到类似效果。

示例代码

import lombok.Data;

@Data
public class Example {
    private String param1;
    private int param2;

    public void exampleMethod(String param1, int param2) {
        // Method logic
    }
}

5. MapStruct

MapStruct 主要用于对象映射，但可以在自定义映射方法中通过反射获取参数名称。

示例代码

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

@Mapper
public interface ExampleMapper {
    
    @Mapping(source = "sourceField", target = "targetField")
    Target map(Source source);
}

// 使用反射获取参数名称
Method method = ExampleMapper.class.getMethod("map", Source.class);
String[] parameterNames = Arrays.stream(method.getParameters())
                                .map(parameter -> parameter.getName())
                                .toArray(String[]::new);

6. 使用 ASM 或 ByteBuddy

如果需要更底层的字节码操作，可以使用 ASM 或 ByteBuddy 进行字节码修改。这些库可以用来动态地处理类和方法，包括参数名称。

ASM 示例代码

import org.objectweb.asm.*;

public class ParameterNameVisitor extends ClassVisitor {
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        return new MethodVisitor(Opcodes.ASM9) {
            @Override
            public void visitParameter(String name, int access) {
                System.out.println("Parameter Name: " + name);
            }
        };
    }
}

总结

  • Java 反射：简单直接，但需要启用 -parameters。
  • Spring AOP：适合在 Spring 应用中使用，结合反射获取参数名称。
  • AspectJ：编译时织入可以直接获取参数名称，配置稍微复杂。
  • Lombok：间接使用，主要用于生成 getter/setter 方法。
  • MapStruct：适合用于对象映射，结合反射获取参数名称。
  • ASM 或 ByteBuddy：适合需要底层字节码操作的场景。

选择合适的方法取决于你的项目需求和现有的技术栈。如果主要使用 Spring，Spring AOP 或 AspectJ 是不错的选择。如果需要更复杂的字节码操作，ASM 或 ByteBuddy 可能更合适。

9. AspectJ这种方式请详细描述一下

使用 AspectJ 来获取目标方法参数名称是一种强大而灵活的方式，尤其适用于需要精确控制切入点和横切关注点的场景。以下是关于如何使用 AspectJ 来实现这一功能的详细说明。

AspectJ 概述

AspectJ 是一种基于 Java 的面向切面编程（AOP）扩展，它允许开发人员在编译时、类加载时或运行时将行为插入到现有代码中。通过使用 AspectJ，可以在方法执行前、后、异常抛出时等时刻插入自定义逻辑。

配置 AspectJ

  1. 引入依赖：首先，你需要在项目中添加 AspectJ 的相关依赖。

    • Maven:
      <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version> <!-- 使用适当的版本 -->
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.7</version> <!-- 使用适当的版本 -->
</dependency>
    • Gradle:
      implementation 'org.aspectj:aspectjweaver:1.9.7' // 使用适当的版本
implementation 'org.aspectj:aspectjrt:1.9.7' // 使用适当的版本

  2. 编译选项：确保在编译时启用 AspectJ 编织。如果使用 Maven，需使用 aspectj-maven-plugin。

    • Maven 示例:
      <build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.1</version> <!-- 使用适当的版本 -->
            <configuration>
                <complianceLevel>1.8</complianceLevel> <!-- 指定 Java 版本 -->
                <source>1.8</source>
                <target>1.8</target>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.aspectj</groupId>
                        <artifactId>aspectjrt</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>test-compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

创建切面

接下来，你需要创建一个切面（Aspect），在其中定义横切关注点的逻辑。以下是如何创建切面来获取目标方法的参数名称。

示例切面代码

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class ParameterAspect {

    @Around("execution(* com.example.service.*.*(..))") // 具体的切入点表达式
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 获取目标方法
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
        
        // 获取参数名称
        String[] parameterNames = Arrays.stream(method.getParameters())
                                        .map(parameter -> parameter.getName())
                                        .toArray(String[]::new);

        // 获取参数值
        Object[] args = pjp.getArgs();

        // 输出参数名称和参数值
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        // 执行目标方法
        return pjp.proceed();
    }
}

关键步骤说明

  1. 切面定义：使用 @Aspect 注解定义切面类，使用 @Component 注解使其成为 Spring 管理的 Bean。

  2. 切入点表达式：@Around("execution(* com.example.service.*.*(..))") 定义了切入点，匹配 com.example.service 包中所有的方法。你可以根据需要调整切入点表达式，以选择特定的方法。

  3. 获取目标方法：通过 pjp.getSignature() 获取方法签名，并从中提取方法对象。

  4. 获取参数名称：通过 method.getParameters() 获取参数数组，然后使用流式 API 提取参数名称。

  5. 获取参数值：通过 pjp.getArgs() 获取实际传递给方法的参数值。

  6. 执行目标方法：通过 pjp.proceed() 调用目标方法，确保原始方法逻辑被保留。

启用参数名称

为了确保参数名称可用，必须在编译时使用 -parameters 选项。请确保在 Maven 或 Gradle 中正确配置。

运行与调试

在启动应用时，切面将被织入，任何符合切入点表达式的方法调用都会触发 around 方法，输出参数名称和参数值。

总结

使用 AspectJ 可以灵活而强大地获取目标方法参数名称。通过将切面与 Spring AOP 结合使用，能够轻松地在现有代码中插入横切逻辑。确保在编译时启用参数名称支持（-parameters），这样在使用反射时可以获得完整的参数名称信息。

10. 不是，我使用的就是spring boot，还需要显式引入aspectJ和编译时启动吗

在 Spring Boot 项目中使用 AspectJ 可以选择不同的方式来实现 AOP 功能。你可以使用 Spring AOP，这通常更简单，只需要依赖 Spring 的 AOP 支持，而不需要显式引入 AspectJ。以下是关于在 Spring Boot 中使用 AspectJ 的不同方法的详细说明。

1. 使用 Spring AOP（无需显式 AspectJ）

Spring AOP 是基于代理的，通常更容易集成到 Spring Boot 项目中。可以使用 Spring AOP 实现基本的切面编程，而不需要显式引入 AspectJ 的库。

步骤

  1. 添加依赖：只需添加 Spring AOP 的依赖。

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

  2. 创建切面：创建一个切面类，使用 @Aspect 和 @Component 注解。

    import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class MyAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
           
        // 获取参数名称
        String[] parameterNames = Arrays.stream(method.getParameters())
                                        .map(parameter -> parameter.getName())
                                        .toArray(String[]::new);

        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            System.out.println("Parameter Name: " + parameterNames[i] + ", Value: " + args[i]);
        }

        return pjp.proceed();
    }
}

  3. 启用参数名称支持：确保在编译时启用 -parameters 选项。对于 Maven，你需要在 pom.xml 中配置。

    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <compilerArgs>
                    <arg>-parameters</arg>
                </compilerArgs>
            </configuration>
        </plugin>
    </plugins>
</build>

2. 使用 AspectJ 进行编译时织入

如果你需要更复杂的切面功能，例如切面在方法调用时能够处理静态方法或者类构造函数，AspectJ 编译时织入是更合适的选择。这种方式会引入 AspectJ 的编织器。

步骤

  1. 添加依赖：在你的 pom.xml 中添加 AspectJ 的依赖。

    <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.7</version>
</dependency>

  2. 配置编译时织入：添加 AspectJ Maven 插件以启用编译时织入。

    <build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.1</version>
            <configuration>
                <complianceLevel>1.8</complianceLevel>
                <source>1.8</source>
                <target>1.8</target>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.aspectj</groupId>
                        <artifactId>aspectjrt</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>test-compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

  3. 创建切面：与之前的方法相同，创建一个切面类来处理切入逻辑。

3. 总结

  • Spring AOP：更简单，通常足够满足大多数需求，只需添加 Spring AOP 依赖，无需显式引入 AspectJ 库。
  • AspectJ：适用于需要复杂切面功能的场景，需要显式引入 AspectJ 并进行编译时织入配置。

注意：无论选择哪种方式，都必须启用参数名称支持（-parameters），以确保在运行时能够获取到方法参数的名称。

最佳实践

在大多数 Spring Boot 项目中，建议首先尝试使用 Spring AOP。如果发现需要更复杂的切面功能，再考虑引入 AspectJ 进行编译时织入。这样可以保持项目的简洁性和可维护性。

11. 就是说，method.getParameter这个实际上和AspectJ本身没有任何关系是吗？

是的，method.getParameters() 这个方法与 AspectJ 本身没有直接关系。它是 Java 反射 API 的一部分，用于获取方法的参数信息。

具体说明：

  • Java 反射 API：Method 类的 getParameters() 方法可以用来获取与方法相关的参数信息，包括参数的名称、类型等。这是 Java 标准库的一部分，不依赖于任何 AOP 框架。

  • AspectJ 与 Spring AOP：

    • AspectJ 是一个全面的切面编程框架，它提供了更丰富的功能，包括在编译时、类加载时和运行时的切面织入。
    • Spring AOP 是基于代理的，通常用于方法级别的拦截，但它的切面实现仍然可以使用 Java 反射 API，包括 Method 类的方法。

参数名称的获取

要获取目标方法的参数名称，确实需要确保在编译时使用 -parameters 选项。没有这个选项，即使使用 getParameters() 方法，获取到的参数名称也会是默认值（如 arg0、arg1 等），而不是你在方法声明中使用的具体名称。

总结

  • 使用 method.getParameters() 获取参数信息与 AspectJ 的使用方式无关。
  • 在使用 Spring AOP 或 AspectJ 时，你都可以利用 Java 反射 API 来访问方法的参数信息，但要确保编译时配置正确，以便能获取到有意义的参数名称。

如果你正在寻找一种简化方法来处理 AOP 和参数名称的获取，使用 Spring AOP 并确保在编译时配置 -parameters 是一种有效的选择。

12. 那使用javassist，需要开启-parameters选项吗？

在使用 Javassist 时，是否需要开启 -parameters 选项取决于你获取方法参数名称的方式。

1. Javassist 概述

Javassist 是一个字节码操作库，允许在运行时或编译时修改 Java 类的字节码。与 Java 反射不同，Javassist 能够在运行时动态生成和修改类。

2. 获取参数名称

  • 使用 Javassist 获取方法的参数名称时，通常不需要 -parameters 选项。Javassist 直接访问字节码，并且可以在运行时获取到方法参数的信息。
  • 然而，参数名称的有效性和准确性取决于你如何定义和处理这些参数。如果在编译时没有使用 -parameters，Java 反射将无法获取到具体的参数名称，只能获取到默认名称（如 arg0、arg1）。

3. 示例

如果你使用 Javassist 来修改或获取方法参数，可以直接通过其 API 来实现。例如：

import javassist.*;

public class Main {
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.example.YourClass");

        CtMethod m = cc.getDeclaredMethod("yourMethod");
        CtClass[] paramTypes = m.getParameterTypes();

        for (CtClass paramType : paramTypes) {
            System.out.println("Parameter Type: " + paramType.getName());
        }

        // 如果需要获取参数名称
        // 注意，Javassist 默认无法获取到参数名称，通常需要通过其他方式或自定义来获取。
    }
}

4. 总结

  • Javassist 本身并不依赖于 -parameters 选项，但如果你的目标是通过 Java 反射获取参数名称，你仍然需要使用 -parameters 选项。
  • 使用 Javassist，获取参数信息和修改字节码通常是更直接和灵活的方式，特别是如果你需要动态地生成或修改类。

如果你主要依赖于反射来获取参数名称，那么确保使用 -parameters 选项是很重要的，但如果是通过 Javassist 修改或获取类信息，通常不需要该选项。

13. 我的代码中看到了使用LocalVariableAttribute去获取方法参数名称的

在 Javassist 中，使用 LocalVariableAttribute 来获取方法的参数名称是一种常见的方式。这种方法从编译时生成的调试信息中提取局部变量表，包括方法的参数名称。不过，这种方式的前提是必须编译代码时启用了 调试信息，即通过 -g 选项，而不是 -parameters 选项。

1. LocalVariableAttribute 概述

LocalVariableAttribute 是 Javassist 的类，用于获取方法的局部变量表，其中也包括方法的参数名称。这个表只会在编译时生成调试信息时存在。

  • 当使用 -g 选项（启用调试信息）编译代码时，Java 编译器会生成局部变量表，Javassist 可以读取该表并获取到方法参数的名称。
  • 如果没有使用 -g 选项，则 LocalVariableAttribute 中不会包含方法参数的名称，获取到的将是默认的占位符（如 arg0、arg1 等）。

2. 获取方法参数名称的代码示例

以下是使用 LocalVariableAttribute 获取方法参数名称的示例代码：

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;

public class Main {
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.example.YourClass");

        // 获取指定方法
        CtMethod method = cc.getDeclaredMethod("yourMethod");

        // 获取方法信息
        MethodInfo methodInfo = method.getMethodInfo();
        CodeAttribute codeAttribute = methodInfo.getCodeAttribute();

        // 获取局部变量表
        LocalVariableAttribute localVarAttribute = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
        if (localVarAttribute == null) {
            System.out.println("No local variable information available.");
            return;
        }

        // 获取参数名称
        int paramStart = Modifier.isStatic(method.getModifiers()) ? 0 : 1;  // 如果是静态方法，参数从0开始，否则从1开始
        for (int i = 0; i < method.getParameterTypes().length; i++) {
            String paramName = localVarAttribute.variableName(i + paramStart);
            System.out.println("Parameter " + (i + 1) + ": " + paramName);
        }
    }
}

3. 使用 -g 编译选项

为了确保 Javassist 的 LocalVariableAttribute 能正确获取到方法参数的名称，编译时需要启用调试信息，也就是在编译代码时加上 -g 选项。

Maven 项目中配置：

在 Maven 项目中，可以通过配置 maven-compiler-plugin 来启用调试信息：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <debug>true</debug>
            </configuration>
        </plugin>
    </plugins>
</build>

这将确保在编译时生成调试信息（包括局部变量表），从而可以通过 LocalVariableAttribute 获取到方法参数的名称。

4. 总结

  • 使用 Javassist 的 LocalVariableAttribute 可以从调试信息中提取方法参数的名称。
  • 必须启用 -g 选项（编译时生成调试信息），否则 Javassist 无法获取到方法的真实参数名称。
  • Javassist 直接操作字节码，与使用 -parameters 选项获取参数名称的 Java 反射方式不同。-parameters 是用于反射获取参数名称，而 Javassist 通过字节码读取调试信息。

14. 也就是说，使用javassist的LocalVariableAttribute ，必须在maven中设置true吗？

是的，使用 Javassist 的 LocalVariableAttribute 来获取方法参数名称时，必须在 Maven 中启用调试信息，即通过 <debug>true</debug> 来确保编译时生成局部变量表。

具体原因：

  • LocalVariableAttribute 依赖于局部变量表，而局部变量表只有在编译时生成调试信息时才会被包含在字节码中。
  • 默认情况下，Java 编译器不会包含局部变量表，以减少字节码的大小。因此，如果你想使用 LocalVariableAttribute 获取参数名称，必须确保编译器生成了这部分信息。

在 Maven 中启用调试信息的方式：

你可以在 pom.xml 中配置 maven-compiler-plugin 来启用调试信息。具体配置如下：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <debug>true</debug> <!-- 开启调试信息 -->
            </configuration>
        </plugin>
    </plugins>
</build>

启用调试信息后：

  • 在编译时生成调试信息，包括局部变量表。
  • LocalVariableAttribute 将能够获取到方法参数的名称。
  • 如果不启用调试信息，LocalVariableAttribute 无法访问参数的真实名称，只能得到默认名称（如 arg0、arg1 等）。

总结

  • 是的，你需要在 Maven 中通过 <debug>true</debug> 选项启用调试信息，以便 Javassist 的 LocalVariableAttribute 能够正确获取到方法参数的名称。
  • 这个调试信息的生成与 Java 的反射方式不同，它主要是让 LocalVariableAttribute 访问字节码中的局部变量表。

15. 为什么我本地将设置为false，使用LocalVariableAttribute 依然能够正确获取到参数名称？

出现这种情况的原因可能是 编译器 在你的本地环境中仍然 默认生成了局部变量表 或 局部变量表的其他配置 导致了参数名称依然可用，甚至当 <debug>false</debug> 时。

这里有几个可能的原因和解释：

1. IDE 或编译器的默认行为

  • IDE 设置：你的 IDE（例如 IntelliJ IDEA 或 Eclipse）可能自动为你添加了调试信息，即使你在 Maven 中显式将 <debug>false</debug>。例如，某些 IDE 会在开发模式下强制生成调试信息，即使项目配置中没有明确指定。
  • 编译器行为：不同的 JDK 和编译器版本有时会生成不同的默认字节码。即使 debug 设置为 false，某些编译器版本仍可能会包含一些调试信息（包括局部变量表）。例如，编译器可能保留了局部变量表，但删除了其他调试信息（如行号、源文件名）。

2. 局部变量表的特例

  • 局部变量表独立于其他调试信息：局部变量表本身是字节码的一部分，并且可以单独控制。在某些情况下，即使你禁用了全局的调试信息，局部变量表仍然可能会被保留。这可能依赖于编译器的实现。

3. Javassist 机制

  • Javassist 并不直接依赖 -parameters 或 debug 设置，它依赖的是字节码中的局部变量表。如果局部变量表依然存在，即使调试信息被关闭，LocalVariableAttribute 仍然能够获取到参数名称。

4. 编译选项的影响

  • 如果你使用的是 Java 8 或更高版本，默认的编译选项可能包括局部变量表生成，除非你显式禁用。某些项目或者编译工具链可能启用了细粒度的调试信息生成方式，保留了局部变量信息。

5. 项目的其他依赖和插件

  • 你的项目可能引入了其他依赖或 Maven 插件，这些插件可能会影响编译过程并确保生成局部变量表。比如有些代码质量或测试工具会强制保留部分调试信息。

如何验证是否生成了局部变量表？

  1. 查看字节码： 你可以通过 javap 工具查看生成的 .class 文件是否包含局部变量表：
    javap -v YourClass.class

    查看输出中的 LocalVariableTable 是否存在。如果存在，即使 <debug> 被设置为 false，也意味着局部变量表仍被保留。

  2. 检查 IDE 的编译设置： 确认 IDE 编译设置中是否启用了调试信息生成（即使你在 Maven 中禁用了它）。你可以在 IDE 的编译器设置中确认是否启用了类似 “Include debug information” 的选项。

总结

即使你将 <debug> 设置为 false，局部变量表可能仍然存在，原因可能是 IDE 或编译器的默认行为，或 Maven 插件的配置影响了编译过程。如果你想确保完全禁用局部变量表，可以尝试在 IDE 和 Maven 中都明确禁用调试信息，并通过 javap 来检查生成的字节码文件。

文档信息

Search

    Table of Contents