【java8新特性系列】方法参数反射

BigDataMLApplication

已于 2023-12-24 09:14:21 修改

阅读量384

点赞数 2

分类专栏： java 文章标签：开发语言 java

于 2023-08-21 22:49:56 首次发布

本文链接：https://blog.csdn.net/wang2leee/article/details/132418353

版权

java 专栏收录该内容

117 篇文章 2 订阅

订阅专栏

java8 新特性方法参数反射

一. 由来

Method parameter reflection（方法参数反射）是Java 8中引入的新特性之一。在Java 8之前，通过反射机制可以获取方法的名称、返回类型和修饰符等信息，但无法直接获取方法的参数信息。而Java 8通过新增的Method类的getParameterTypes()方法，使得我们能够方便地获取方法的参数类型信息。

二. Method类的五个常用方法示例以及它们的说明：

下面是Method类的五个常用方法示例以及它们的说明：

getParameterCount()：获取方法的参数个数。
getParameterTypes()：获取方法的参数类型数组。
getParameters()：获取方法的Parameter对象数组，包含参数名称和修饰符等信息。
getParameterAnnotations()：获取方法的参数注解数组。
isVarArgs()：判断方法是否使用了可变参数。

getParameterCount()

说明：该方法用于获取方法的参数个数。

示例：

Method method = MyClass.class.getMethod("myMethod", String.class, int.class);
int parameterCount = method.getParameterCount();
System.out.println("参数个数：" + parameterCount);

输出结果：

参数个数：2

 
2. `getParameterTypes()`
 - 说明：该方法用于获取方法的参数类型数组，按照参数顺序排列。
 - 示例：
   ```java
   Method method = MyClass.class.getMethod("myMethod", String.class, int.class);
   Class<?>[] parameterTypes = method.getParameterTypes();
   for (Class<?> type : parameterTypes) {
       System.out.println("参数类型：" + type.getName());
   }
   ```
   输出结果：
   ```
   参数类型：java.lang.String
   参数类型：int
   ```

3. `getParameters()`
 - 说明：该方法用于获取方法的Parameter对象数组，包含参数名称和修饰符等信息。
 - 示例：
   ```java
   Method method = MyClass.class.getMethod("myMethod", String.class, int.class);
   Parameter[] parameters = method.getParameters();
   for (Parameter parameter : parameters) {
       System.out.println("参数名称：" + parameter.getName());
       System.out.println("参数修饰符：" + parameter.getModifiers());
   }
   ```
   输出结果：
   ```
   参数名称：arg1
   参数修饰符：0
   参数名称：arg2
   参数修饰符：0
   ```

4. `getParameterAnnotations()`
 - 说明：该方法用于获取方法的参数注解数组。
 - 示例：
   ```java
   Method method = MyClass.class.getMethod("myMethod", String.class, int.class);
   Annotation[][] parameterAnnotations = method.getParameterAnnotations();
   for (Annotation[] annotations : parameterAnnotations) {
       for (Annotation annotation : annotations) {
           System.out.println("参数注解：" + annotation.annotationType().getName());
       }
   }
   ```
   输出结果：（假设没有参数注解）
   ```
   // 没有输出结果，表示没有参数注解
   ```

5. `isVarArgs()`
 - 说明：该方法用于判断方法是否使用了可变参数。
 - 示例：
   ```java
   Method method = MyClass.class.getMethod("myMethod", String.class, int[].class);
   boolean isVarArgs = method.isVarArgs();
   System.out.println("是否为可变参数：" + isVarArgs);
   ```
   输出结果：
   ```
   是否为可变参数：true
   ```

以上是Method类的五个常用方法及其说明和示例。这些方法可以帮助我们在运行时获取方法的参数相关信息。

请注意，示例中的`MyClass`是一个自定义类名，您需要将其替换为实际使用的类名。

希望能对您有所帮助。

## **三. 多种主要用法**

Method parameter reflection具有以下多种主要用法：

- 动态代理：在使用动态代理时，我们通常需要通过Method parameter reflection来获取被代理方法的参数信息，以便进行相应的处理。
- 参数校验：通过Method parameter reflection，我们可以在运行时检查方法参数的类型和注解，实现参数校验的功能。
- 反射工具库：基于Method parameter reflection，我们可以开发出各种反射相关的工具库，如自动生成代码、实现AOP等。
- 测试框架：在测试框架中，Method parameter reflection可以帮助我们获取被测试方法的参数类型，从而准备相应的测试数据。
下面是Method parameter reflection的示例代码，演示了动态代理和参数校验两个常见用法：

1. 动态代理示例：
```java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface UserService {
  void saveUser(String name, int age);
}

class UserServiceImpl implements UserService {
  public void saveUser(String name, int age) {
      System.out.println("Saving user: " + name + ", age: " + age);
  }
}

class UserServiceProxy implements InvocationHandler {
  private Object target;

  public UserServiceProxy(Object target) {
      this.target = target;
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("Before method invocation");

      // 获取方法的参数信息
      Parameter[] parameters = method.getParameters();
      for (int i = 0; i < parameters.length; i++) {
          Parameter parameter = parameters[i];
          System.out.println("Parameter " + (i + 1) + ": " + parameter.getName() + ", Type: " + parameter.getType());
      }

      // 调用目标对象的方法
      Object result = method.invoke(target, args);

      System.out.println("After method invocation");

      return result;
  }
}

public class Main {
  public static void main(String[] args) {
      UserService userService = new UserServiceImpl();
      UserService proxy = (UserService) Proxy.newProxyInstance(
              UserService.class.getClassLoader(),
              new Class<?>[]{UserService.class},
              new UserServiceProxy(userService)
      );

      proxy.saveUser("Alice", 25);
  }
}

输出结果：

Before method invocation
Parameter 1: name, Type: class java.lang.String
Parameter 2: age, Type: int
Saving user: Alice, age: 25
After method invocation

参数校验示例：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
@interface NotEmpty {
}

class UserService {
    public void saveUser(@NotEmpty String name, int age) {
        System.out.println("Saving user: " + name + ", age: " + age);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        UserService userService = new UserService();
        Method method = UserService.class.getMethod("saveUser", String.class, int.class);

        // 获取方法的参数信息
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            // 检查参数是否带有自定义注解
            if (parameter.isAnnotationPresent(NotEmpty.class)) {
                String paramName = parameter.getName();
                Object paramValue = "Alice";

                // 执行参数校验逻辑
                if (paramValue == null || paramValue.toString().isEmpty()) {
                    throw new IllegalArgumentException("Parameter '" + paramName + "' cannot be empty.");
                }
            }
        }

        // 调用方法
        method.invoke(userService, "Alice", 25);
    }
}

输出结果：

Saving user: Alice, age: 25

反射工具库示例：

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

class ReflectionUtils {
    public static void printMethodParameters(Method method) {
        System.out.println("Method: " + method.getName());

        // 获取方法的参数信息
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameters.length; i++) {
            Parameter parameter = parameters[i];
            System.out.println("Parameter " + (i + 1) + ": " + parameter.getName() + ", Type: " + parameter.getType());
        }
    }
}

class UserService {
    public void saveUser(String name, int age) {
        System.out.println("Saving user: " + name + ", age: " + age);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        UserService userService = new UserService();
        Method method = UserService.class.getMethod("saveUser", String.class, int.class);

        ReflectionUtils.printMethodParameters(method);
    }
}

输出结果：

Method: saveUser
Parameter 1: name, Type: class java.lang.String
Parameter 2: age, Type: int

测试框架示例：

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

class TestFramework {
    public static void prepareTestData(Method method) {
        System.out.println("Preparing test data for method: " + method.getName());

        // 获取方法的参数信息
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            Class<?> paramType = parameter.getType();
            Object testData = null;

            // 根据参数类型准备相应的测试数据
            if (paramType.equals(String.class)) {
                testData = "Alice";
            } else if (paramType.equals(int.class)) {
                testData = 25;
            }

            System.out.println("Test data for parameter " + parameter.getName() + ": " + testData);
        }
    }
}

class UserService {
    public void saveUser(String name, int age) {
        System.out.println("Saving user: " + name + ", age: " + age);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        UserService userService = new UserService();
        Method method = UserService.class.getMethod("saveUser", String.class, int.class);

        TestFramework.prepareTestData(method);
    }
}

输出结果：

Preparing test data for method: saveUser
Test data for parameter name: Alice
Test data for parameter age: 25

四. 有没有其他类似命令

除了Method类提供的上述方法外，还有一些其他类似的命令可用于操作和获取方法参数信息。其中一些常见的类包括Executable、Parameter、AnnotatedType等。

Executable类：该类是Method类和Constructor类的共同父类，它提供了更多的方法来操作方法或构造函数的参数。
Parameter类：该类表示方法或构造函数的参数，通过它可以获取参数名称、修饰符和注解等信息。
AnnotatedType类：该类表示带有注解的类型，通过它可以获取方法参数的注解信息。

五. 区别

在Java 8之前，无法直接通过反射获取方法参数的信息，而只能通过获取方法的字节码对象（即Method对象）然后使用底层字节码分析工具来解析方法参数的信息。而引入Method parameter reflection后，可以直接通过Method对象的getParameterTypes()方法获取方法的参数类型数组，并且还可以通过getParameters()方法获取Parameter对象数组，从而方便地获取参数的详细信息。

6. 官方链接

Method (Java Platform SE 8 )

以上内容为Java 8新特性Method parameter reflection的相关介绍，希望对您有所帮助。

BigDataMLApplication

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
【java8新特性系列】方法参数反射

在Java 8之前，无法直接通过反射获取方法参数的信息，而只能通过获取方法的字节码对象（即Method对象）然后使用底层字节码分析工具来解析方法参数的信息。而引入Method parameter reflection后，可以直接通过Method对象的getParameterTypes()方法获取方法的参数类型数组，并且还可以通过getParameters()方法获取Parameter对象数组，从而方便地获取参数的详细信息。
复制链接

扫一扫