Class -- 08 -- Parameter类常用方法解析

最新推荐文章于 2024-05-27 09:38:13 发布
最新推荐文章于 2024-05-27 09:38:13 发布
阅读量8.6k 收藏 12
点赞数 4
分类专栏： Class 文章标签： class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Goodbye_Youth/article/details/83757757
版权

原文链接：Class – 08 – Parameter类常用方法解析

相关文章：

这次主要整理下 Java 中 Parameter 类的常用方法

一、Parameter 类的定义

  • Parameter 类位于 java.lang.reflect 包中，主要用于在程序运行状态中，动态地获取参数信息

  • 在 JDK8.0 之前，编译器会忽略我们编写代码时设定的参数名，因此会得到像 arg0、arg1 这样无意义的参数名，比如：当我们使用 mybatis 时，我们会用到 @Param 注解来使 mybatis 保留参数名称

  • 在 JDK8.0 及之后，Java 在语言层面 (使用反射 API 和 Parameter.getName() 方法) 和字节码层面 (使用新的 javac 编译器以及 -parameters 参数) 提供了支持，不过为了保证向下兼容，在 JDK8.0 及之后的版本中该特性是默认关闭的

  • 在 IDEA 中我们可以通过以下设置来完成
    在这里插入图片描述

  • 如果使用了 maven，可以配置 maven 的编译插件

    <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.0</version>
    <configuration>
        <compilerArgument>-parameters</compilerArgument>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
</plugin>

  • 示例如下

    public class ParameterTest {

    public void test(String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            // 正常编译得到: arg0 arg1
            // 加入-parameters后编译得到: key value
            System.out.println(parameter.getName());
        }
    }
}

二、Parameter 类常用方法

  • getAnnotatedType()

    • 返回一个 AnnotatedType 对象，该对象表示使用类型来指定由该参数对象表示的形式参数的类型

    • 通过其 getType() 方法，我们可以获取到对应的形参类型

      public class ParameterTest {

    public void test(String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            AnnotatedType annotatedType = parameter.getAnnotatedType();
            // class java.lang.String
            // class java.lang.String
            System.out.println(annotatedType.getType());
        }
    }
}

  • getAnnotation(Class<T> annotationClass)

    • 如果该参数对象存在指定类型的注解，则返回该注解，否则返回 null

    • 只有类级别的注解会被继承得到，对于其他对象而言，getAnnotation() 方法与 getDeclaredAnnotation() 方法作用相同

      @Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParameterAnnotation {

    String key();

    String value();
}

public class ParameterTest {

    public void test(@ParameterAnnotation(key = "key", value = "value") String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        ParameterAnnotation annotation = parameters[0].getAnnotation(ParameterAnnotation.class);
        // @lang.reflect.Parameter.ParameterAnnotation(key=key, value=value)
        System.out.println(annotation);
    }
}

  • getDeclaredAnnotation(Class<T> annotationClass)

    • 如果该参数对象存在指定类型的注解，则返回该注解，否则返回 null

    • 只有类级别的注解会被继承得到，对于其他对象而言，getAnnotation() 方法与 getDeclaredAnnotation() 方法作用相同

  • getAnnotationsByType(Class<T> annotationClass)

    • 如果该参数对象存在指定类型的注解，则返回该注解数组，否则返回 null

    • 只有类级别的注解会被继承得到，对于其他对象而言，getAnnotationsByType() 方法与 getDeclaredAnnotationsByType() 方法作用相同

    • getAnnotationsByType() 方法与 getAnnotation() 方法的区别在于：getAnnotationsByType() 方法会检查修饰该参数对象的注解是否为可重复类型注解，如果是则会返回修饰该参数对象的一个或多个注解

    • @Repeatable 用于声明注解为可重复类型注解

    • 当声明为可重复类型注解后，如果参数注解仍为一个，则 getAnnotation() 方法会正常返回，如果参数注解为多个，则 getAnnotation() 方法会返回 null

      @Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
// @Repeatable: 声明该注解为可重复类型注解
@Repeatable(RepeatableAnnotation.class)
public @interface ParameterAnnotation {

    String key();

    String value();
}

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@interface RepeatableAnnotation {
    ParameterAnnotation[] value();
}
	
public class ParameterTest {

    public void test(@ParameterAnnotation(key = "key1", value = "value1")
                     @ParameterAnnotation(key = "key2", value = "value2") String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        ParameterAnnotation annotation = parameters[0].getAnnotation(ParameterAnnotation.class);
        // null
        System.out.println(parameters[0].getAnnotation(ParameterAnnotation.class));
        ParameterAnnotation[] annotationsByType = parameters[0].getAnnotationsByType(ParameterAnnotation.class);
        // [@lang.reflect.ParameterAnnotation(key=key1, value=value1), @lang.reflect.ParameterAnnotation(key=key2, value=value2)]
        System.out.println(Arrays.toString(annotationsByType));
    }
}

  • getDeclaredAnnotationsByType(Class<T> annotationClass)

    • 如果该参数对象存在指定类型的注解，则返回该注解数组，否则返回null

    • 只有类级别的注解会被继承得到，对于其他对象而言，getAnnotationsByType() 方法与 getDeclaredAnnotationsByType() 方法作用相同

  • getAnnotations()

    • 返回该参数对象上的所有注解，如果没有注解，则返回空数组

    • 只有类级别的注解会被继承得到，对于其他对象而言，getAnnotations() 方法与 getDeclaredAnnotations() 方法作用相同

      @Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParameterAnnotation {

    String key();

    String value();
}

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {

    String key();

    String value();
}

public class ParameterTest {

    public void test(@ParameterAnnotation(key = "key1", value = "value1")
                     @TestAnnotation(key = "key2", value = "value2") String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        Annotation[] annotations = parameters[0].getAnnotations();
        // [@lang.reflect.ParameterAnnotation(key=key1, value=value1), @lang.reflect.TestAnnotation(key=key2, value=value2)]
        System.out.println(Arrays.toString(annotations));
    }
}

  • getDeclaredAnnotations()

    • 返回该参数对象上的所有注解，如果没有注解，则返回空数组

    • 只有类级别的注解会被继承得到，对于其他对象而言，getAnnotations() 方法与 getDeclaredAnnotations() 方法作用相同

  • getModifiers()

    • 返回修饰该参数对象修饰符的整数形式，使用 Modifier 类对其进行解码

      public class ParameterTest {

    public void test(final String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        // final
        System.out.println(Modifier.toString(parameters[0].getModifiers()));
    }
}

  • getName()

    • 返回参数对象名称

      public class ParameterTest {

    public void test(String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            // 正常编译得到: arg0 arg1
            // 加入-parameters后编译得到: key value
            System.out.println(parameter.getName());
        }
    }
}

  • getParameterizedType()

    • 返回一个类型对象，该对象表示该参数对象表示的泛型参数的类型 (保留泛型)

      public class ParameterTest<T> {

    public void test(T t, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", Object.class, String.class);
        Parameter[] parameters = method.getParameters();
        // T
        System.out.println(parameters[0].getParameterizedType().getTypeName());
    }
}

  • getType()

    • 返回一个 Class 对象，该 Class 对象表示该参数对象表示的声明参数的类型 (擦除泛型)

      public class ParameterTest<T> {

    public void test(T t, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", Object.class, String.class);
        Parameter[] parameters = method.getParameters();
        // class java.lang.Object
        System.out.println(parameters[0].getType());
    }
}

  • isAnnotationPresent(Class<? extends Annotation> annotationClass)

    • 如果该参数对象上有指定类型的注解，则返回 true，否则为 false

      public class ParameterTest {

    public void test(@ParameterAnnotation(key = "key", value = "value") String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        // true
        System.out.println(parameters[0].isAnnotationPresent(ParameterAnnotation.class));
    }
}

    • 如果该参数对象上的注解类型为可重复类型注解，则需要标明可重复注解而不是其子注解，才会返回 true，否则为 false

      @Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(RepeatableAnnotation.class)
public @interface ParameterAnnotation {

    String key();

    String value();
}

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@interface RepeatableAnnotation {
    ParameterAnnotation[] value();
}

public class ParameterTest {

    public void test(@ParameterAnnotation(key = "key1", value = "value1")
                     @ParameterAnnotation(key = "key2", value = "value2") final String key, String value) {
    }

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        // false
        System.out.println(parameters[0].isAnnotationPresent(ParameterAnnotation.class));
        // true
        System.out.println(parameters[0].isAnnotationPresent(RepeatableAnnotation.class));
    }
}

  • isVarArgs()

    • 如果该参数对象表示 可变参，则返回 true，否则为 false

      public class ParameterTest {

    public void test(String key, String ... values) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String[].class);
        Parameter[] parameters = method.getParameters();
        // false
        System.out.println(parameters[0].isVarArgs());
        // true
        System.out.println(parameters[1].isVarArgs());
    }
}

  • isNamePresent()

    • 如果该参数对象根据类文件能获取到名称，则返回 true，否则为 false

    • 当我们带上 -parameters 参数时，该参数对象就有了名称

      public class ParameterTest {

    public void test(String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        // 正常编译得到: false arg0
        // 加入-parameters 后编译得到: true key
        System.out.println(parameters[0].isNamePresent() + " " + parameters[0].getName());
    }
}

  • getDeclaringExecutable()

    • 返回声明该参数对象的可执行文件

      public class ParameterTest {

    public void test(String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        // public void lang.reflect.ParameterTest.test(java.lang.String,java.lang.String)
        System.out.println(parameters[0].getDeclaringExecutable());
    }
}

  • isImplicit()

    • 如果该参数对象为隐式参数，则返回 true，否则为 false

    • Java 编译器会为内部类的构造方法创建一个隐式参数

      public class ParameterTest {

    class InnerClass {
    
        public InnerClass(String key) {
        
        }
    }

    public static void main(String[] args) throws Exception {
        Constructor<InnerClass> declaredConstructor = InnerClass.class.getConstructor(ParameterTest.class, String.class);
        Parameter[] parameters = declaredConstructor.getParameters();
        for (Parameter parameter : parameters) {
            // 【final lang.reflect.ParameterTest this$0】 isImplicit() ===> true
            // 【java.lang.String key】 isImplicit() ===> false
            System.out.println("【" + parameter + "】 isImplicit() ===> " + parameter.isImplicit());
        }
    }
}

  • isSynthetic()

    • 如果该参数对象为合成参数，则返回 true，否则为 false

      public class ParameterTest {

    public void test(String key, String value) {}

    public static void main(String[] args) throws Exception {
        Method method = ParameterTest.class.getMethod("test", String.class, String.class);
        Parameter[] parameters = method.getParameters();
        // false
        System.out.println(parameters[0].isSynthetic());
    }
}
Gene Xu
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java | 参数（Parameter）
Blume 的博客
04-01 8043
参数（Parameter），是 Java 编程语言中位于方法和构造方法声明内的一种变量，用来为方法和构造方法提供额外的信息。参数始终被归类为“变量”（而不是“字段”）。
struts-config1.2配置实例
01-10
此外，`<display-name>`、`<description>` 和 `<icon>` 元素虽然不常用，但它们提供了关于配置文件的元信息，有助于文档化和理解配置。 在 Struts 1.x 版本中，配置文件遵循特定的 DTD（文档类型定义），如 `struts...
@Param注解的用法解析
Hello World
10-15 9044
@Param注解的用法解析一.xml形式二.注解形式 一.xml形式 实例一 @Param注解单一属性 dao层示例 Public User selectUser(@param(“userName”) String name, @param(“userpassword”) String password); xml映射对应示例 <select id=" selectUser" resultMap="BaseResultMap"> select * from user_user_
反射获取方法的参数类型和参数名
最新发布
不积跬步，无以至千里
05-27 268
【代码】反射获取方法的参数类型和参数名。
深入理解参数-@Param和 对象作为参数重要
weixin_48370579的博客
11-06 2578
深入理解参数 1.parameterType parameterType: 接口中方法参数的类型， 类型的完全限定名或别名。这个属性是可选的，因为 MyBatis可以推断出具体传入语句的参数，默认值为未设置(unset)。接口中方法的参数从 java 代码传入到mapper 文件的 sql 语句。 使用parameter的配置文件如下： <?xml version="1.0" en...
@Param注解原理
weixin_38954520的博客
02-05 2686
大部分文章告诉你在Mapper接口的方法参数上使用@Param注解，可是有的时候不用也没有问题，还有的时候用了@Param注解也还是报错，今天我们探究下这个注解原理，以后你碰到这个问题就不再懵逼了。
Springdoc中使用对象进行Query查询时格式类型解析错误
qq_43107784的博客
10-05 2985
springdoc
@Param注解的使用
qq_44733345的博客
10-09 1348
1.关于@Param @Param是MyBatis所提供的(org.apache.ibatis.annotations.Param)，作为Dao层的注解，作用是用于传递参数，从而可以与SQL中的的字段名相对应，一般在2=<参数数<=5时使用最佳。 2.原始的方法 当只有一个参数时，没什么好说的，传进去一个值也只有一个参数可以匹配。当存在多个参数时，传进去的值就区分不开了，这时可以考虑用Map，例如接口 public List<Role> findRoleByMap(Map&.
PHP基础精髓-建议收藏.pdf
11-17
本文将详细解析PHP的一些核心概念和常用功能。 1. 变量：在PHP中，变量以美元符号"$"开头，如 `$variable`。变量名必须以下划线或字母开头，不能包含特殊符号，并且是大小写敏感的。例如，`$myVariable`和`$...
abstractml-源码.rar
10-10
《抽象机器学习库——abstractml源码解析》 在当今数据驱动的时代，机器学习作为人工智能的重要分支，已经深入到各个领域。开源库如TensorFlow、PyTorch等为开发者提供了便利，但它们往往过于庞大，对于初学者或者...
Laravel开发-l5-swagger
08-28
L5-Swagger 使用 PHPDoc 注解来描述 API，这些注解会出现在控制器的方法和类中。以下是一些常用注解示例： - `@OA\Info`：定义 API 的基本信息，如标题、版本等。 - `@OA\Server`：指定 API 的服务器地址和变量。 -...
C#实现的封装CURD到SqlHelper类用法简单分析
08-28
本文将详细解析如何在C#中封装一个SqlHelper类，并结合App.config文件配置数据库连接，以及讲解其主要功能和使用方法。 首先，数据库连接字符串是访问数据库的关键信息，通常存储在项目的配置文件App.config中。在...
c# 配置类属性动态显示值(Linq)
05-26
2. **Lambda表达式**：是LINQ中另一种常用的语法，更面向函数编程。例如`collection.Where(item => item.Property == value)`，这与查询表达式的效果相同。 3. **Expression Trees**：在C#中，表达式树（Expression...
计算机编程常用术语中英对照.doc
07-07
2. **抽象类 (Abstract Class)**：包含抽象方法的类，不允许直接实例化，必须被子类继承并实现其抽象方法。 3. **存取 (Access)**：在编程中，指对变量、函数或对象的读取或修改。 4. **访问级别 (Access Level)**...
JAVA编程中常用的英文单词词汇汇总.doc
09-30
17. **Parameter**：参数，函数或方法中定义的输入值。 18. **Method**：方法，类中定义的可执行操作。 19. **Function**：函数，与方法类似，通常指的是独立于类的可调用单元。 20. **Member-variable**：成员...
C# Oracle存储过程工具类
01-14
本篇文章将详细解析"C# Oracle存储过程工具类"的相关知识点，以及如何使用这个工具类。 首先，Oracle Toolkit.cs 文件很可能是包含一个C#类，该类封装了与Oracle数据库进行交互的逻辑，特别是执行存储过程的功能。...
Java自定义注解参数ElementType.PARAMETER
雨落未成曲的博客
10-21 3339
Java自定义参数注解
Introduce Parameter Object (引入参数对象)
七月的南方博客
08-29 1178
Introduce Parameter Object (引入参数对象)
vue中parameterObject:{}使用
泗水六年的博客
05-14 1249
vue中parameterObject:{}使用： 解释： parameterObject:{}可以定义成空的，使用的时候赋值。 v-model.trim的使用：v-model的修饰符，一般用于控制数据同步的时机；.trim 自动过滤输入内容最开始和最后的空格，中间的会保留一个空格，多的会被过滤掉。 例如： <div v-if="addVisible"> <el-dialog :title="saveParameter?'新增参数':'修改参数'" :visible.sync=".
element-plus的cell-class-name方法
06-08
`element-plus`的`cell-class-name`方法是用于设置单元格的`class`属性的函数。该函数接受三个参数：`{ row, column, rowIndex, columnIndex }`，分别表示当前单元格所属的行数据、列数据、行索引和列索引。你可以在该方法中根据这些参数返回一个字符串，作为该单元格的`class`属性值。 例如，如果你需要在单元格中根据行数据的某个字段值来设置不同的样式，可以这样使用`cell-class-name`方法： ```html <el-table :data="tableData" :cell-class-name="cellClassName" > <el-table-column prop="name" label="姓名" ></el-table-column> <el-table-column prop="age" label="年龄" ></el-table-column> </el-table> ``` ```javascript // 在 methods 中定义 cellClassName 方法 methods: { cellClassName({ row }) { if (row.age < 18) { return 'cell-red'; } else if (row.age >= 18 && row.age < 30) { return 'cell-yellow'; } else { return 'cell-green'; } } } ``` 在上面的例子中，我们根据每行数据的`age`字段值的不同，返回不同的`class`属性值，从而实现了不同的样式效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值