JAVA基础深化提高(八) | 反射技术

惊鸿化雨

已于 2023-08-07 11:31:26 修改

阅读量31

点赞数

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

于 2023-08-04 16:29:02 首次发布

本文链接：https://blog.csdn.net/weixin_65180200/article/details/132105510

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、反射机制介绍

1.1 什么是反射

Java 反射机制是Java语言一个很重要的特性，它使得Java具有了“动态性”。在Java程序运行时，对于任意的一个类，我们能不能知道这个类有哪些属性和方法呢？对于任意的一个对象，我们又能不能调用它任意的方法？答案是肯定的！这种动态获取类的信息以及动态调用对象方法的功能就来自于Java 语言的反射（Reflection）机制。

1.2 反射的作用

简单来说两个作用，RTTI（运行时类型识别）和DC（动态创建）。

我们知道反射机制允许程序在运行时取得任何一个已知名称的class的内部信息，包括其modifiers(修饰符)，fields(属性)，methods(方法)等，并可于运行时改变fields内容或调用methods。那么我们便可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间进行源代码链接，降低代码的耦合度；还有动态代理的实现等等；但是需要注意的是反射使用不当会造成很高的资源消耗！

二、创建对象过程

2.1 Java创建对象的三个阶段

在这里插入图片描述

2.2 创建对象时内存结构

Users user = new Users();

在这里插入图片描述

三、反射的具体实现

3.1 获取Class对象的三种方式

3.1.1 创建User类

public class Users extends ArrayList implements Serializable {
    private String username;
    public int userage;
    public Users(){

    }
    public Users(String username,int userage){
        this.username = username;
        this.userage = userage;
    }

    public Users(String username){
        this.username = username;
    }
    private Users(int userage){
        this.userage = userage;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }


    public int getUserage() {
        return userage;
    }

    public void setUserage(int userage) {
        this.userage = userage;
    }

    private void suibian(){
        System.out.println("Hello Oldlu");
    }
    @Override
    public String toString() {
        return "Users{" +
                "username='" + username + '\'' +
                ", userage=" + userage +
                '}';
    }
}

3.1.2 通过getClass()方法获取Class对象

public class GetClass1 {
    public static void main(String[] args) {
        Users users = new Users();
        Users users1 = new Users();
        Class clazz = users.getClass();
        System.out.println(clazz);
        System.out.println(clazz.getName());
        System.out.println(users.getClass() == users1.getClass());
    }
}

3.1.3 通过.class 静态属性获取Class对象

public class GetClass2 {
    public static void main(String[] args) {
          Class clazz = Users.class;
          Class clazz1 = Users.class;
        System.out.println(clazz);
        System.out.println(clazz.getName());
        System.out.println(clazz == clazz1);
    }
}

3.1.4 通过forName()获取Class对象

public class GetClass3 {
    public static void main(String[] args)throws Exception {
       Class clazz =  Class.forName("com.itbaizhan.Users");
       Class clazz2 = Class.forName("com.itbaizhan.Users");
        System.out.println(clazz);
        System.out.println(clazz.getName());
        System.out.println(clazz == clazz2);
    }
}

3.2 获取类的构造方法

方法名	描述
getDeclaredConstructors()	返回 Constructor 对象的一个数组，这些对象反映此 Class对象表示的类声明的所有构造方法。
getConstructors()	返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共（public）构造方法。
getConstructor(Class<?>…parameterTypes)	返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共（public）构造方法。
getDeclaredConstructor(Class<?>… parameterTypes)	返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。

3.2.1 获取构造方法

public class GetConstructor  {
    public static void main(String[] args) throws Exception {
        //获取Users的类对象
        Class clazz = Users.class;

        //获取类的构造方法
      Constructor[] arr =  clazz.getDeclaredConstructors();
      for(Constructor c :arr){
          System.out.println(c);
      }
        System.out.println("----------------------");

        Constructor[] arr1 =  clazz.getConstructors();
        for(Constructor c :arr1){
            System.out.println(c);
        }
        System.out.println("----------------------");

        Constructor constructor = clazz.getDeclaredConstructor(int.class);
        System.out.println(constructor);

        System.out.println("----------------------");

        Constructor constructor1 = clazz.getConstructor(null);
        System.out.println(constructor1);
    }
}

3.2.2 通过构造方法创建对象

public class GetConstructor2 {
    public static void main(String[] args)throws Exception {
        //获取类对象
        Class clazz = Users.class;

        //通过类对象，获取指定的构造方法对象
        Constructor c = clazz.getConstructor(String.class,int.class);

        //通过指定构造方法，创建对象
       Object o =  c.newInstance("Oldlu",18);

       //强制类型转换
        Users u = (Users) o;
        System.out.println(u);
    }
}

3.3 获取类的成员变量

方法名	描述
getFields()	返回Field类型的一个数组,其中包含 Field对象的所有公共(public)字段。
getDeclaredFields()	返回Field类型的一个数组,其中包含 Field对象的所有字段。
getField(String fieldName)	返回一个公共成员的Field指定对象。
getDeclaredField(String fieldName)	返回一个 Field指定对象。

3.3.1 获取成员变量

public class GetField {
    public static void main(String[] args)throws Exception {
        Class clazz = Users.class;

        Field[] arr = clazz.getFields();
        for(Field field:arr){
            System.out.println(field);
            System.out.println(field.getName());
        }
        System.out.println("----------------");

        Field[] arr1 = clazz.getDeclaredFields();
        for(Field field:arr1){
            System.out.println(field);
            System.out.println(field.getName());
        }
        System.out.println("----------------");

       Field field =  clazz.getField("userage");
        System.out.println(field);

        System.out.println("-----------------------");
        Field field1 = clazz.getDeclaredField("username");
        System.out.println(field1);
    }
}

3.3.2 操作成员变量

public class GetField2 {
    public static void main(String[] args)throws Exception {
        Class clazz = Users.class;

        Field field = clazz.getField("userage");
        //对象实例化
        Object o = clazz.getConstructor(null).newInstance();

        //为成员变量赋值新值。
        field.set(o,18);

        //获取成员变量的值
        Object o1 = field.get(o);
        System.out.println(o1);
    }
}

3.4 获取类的方法

方法名	描述
getMethods()	返回一个Method类型的数组,其中包含所有公共(public)方法。
getDeclaredMethods()	返回一个Method类型的数组,其中包含所有方法。
getMethod(String name, Class<?>…parameterTypes)	返回一个公共的Method方法对象。
getDeclaredMethod(String name, Class<?>…parameterTypes)	返回一个方法Method对象

3.4.1 获取方法

public class GetMethod {
    public static void main(String[] args) throws Exception{
        Class clazz = Users.class;

        Method[] arr = clazz.getMethods();
        for(Method m:arr){
            System.out.println(m);
            System.out.println(m.getName());
        }
        System.out.println("------------------------");
        Method[] arr1 = clazz.getDeclaredMethods();
        for(Method m:arr1){
            System.out.println(m);
            System.out.println(m.getName());
        }

        System.out.println("------------------------");
        Method method = clazz.getMethod("setUserage", int.class);
        System.out.println(method);
        System.out.println(method.getName());
        System.out.println("---------------------");
        Method method1 = clazz.getDeclaredMethod("suibian");
        System.out.println(method1);
        System.out.println(method1.getName());
    }
}

3.4.2 调用方法

public class GetMethod2 {
    public static void main(String[] args)throws Exception{
        Class clazz = Users.class;

        Method method = clazz.getMethod("setUsername", String.class);

        //实例化对象
        Object obj = clazz.getConstructor(null).newInstance();

        //执行该方法
        method.invoke(obj,"oldlu");

        //通过getUsersname获取值
         Method method1 = clazz.getMethod("getUsername");
         Object o = method1.invoke(obj);
        System.out.println(o);
    }
}

3.5 获取类的其他信息

public class GetClassInfo {
    public static void main(String[] args) {
        Class clazz = Users.class;

        //获取类名
        String className = clazz.getName();
        System.out.println(className);

        //获取类的包名
        Package p = clazz.getPackage();
        System.out.println(p.getName());

        //获取超类
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass.getName());

        //获取该类实现的所有的接口
        Class[] interfaces = clazz.getInterfaces();
        for(Class inter: interfaces){
            System.out.println(inter);
            System.out.println(inter.getName());
        }
    }
}

3.6 反射应用案例

class Reflect{
    public void method1(){
        System.out.println("Method1............");
    }
    public void method2(){
        System.out.println("Method2............");
    }
    public void method3(){
        System.out.println("Method3............");
    }
}

public class ReflectDemo {
    public static void main(String[] args)throws Exception {
        Reflect reflect = new Reflect();
        if(args != null && args.length > 0){
            //获取Reflect的类对象
            Class clazz = reflect.getClass();
            //获取Reflect中的所有方法
            Method[] methods = clazz.getMethods();
            for(String str :args){
                for(int i=0;i<methods.length;i++){
                    if(str.equalsIgnoreCase(methods[i].getName())){
                           methods[i].invoke(reflect);
                           break;
                    }
                }
            }
        }else{
            reflect.method1();
            reflect.method2();
            reflect.method3();
        }
    }
}

四、注解

从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)
Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在Annotation的 “name=value” 对中。
在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
未来的开发模式都是基于注解的， JPA是基于注解的， Spring2.5以上都是基于注解的， Hibernate3.x以后也是基于注解的，现在的Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式
使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成一个修饰符使用。用于修饰它支持的程序元素

4.1 常见JDK注解

常见的JDK注解包括：

@Override：该注解用于标记方法覆盖父类的方法，如果方法签名在父类中不存在，则编译器会报错。
@Deprecated：该注解用于标记已过时的方法、类或字段。编译器在使用被标记为@Deprecated的元素时会发出警告。
@SuppressWarnings：该注解用于压制编译器警告信息。可以使用特定的参数来指定要压制的警告类型。
@SafeVarargs：该注解用于标记方法中使用不安全的可变参数（varargs）时的安全性警告。用于抑制这种警告。
@FunctionalInterface：该注解用于标记接口是函数式接口，即只包含一个抽象方法的接口。该注解可以在编译时验证接口是否满足函数式接口的要求。
@SuppressWarnings：用于抑制编译器产生的警告。可以指定要压制的警告类型。
@SafeVarargs：用于抑制参数安全警告。
@Repeatable：该注解用于标记某个注解可以重复应用于同一元素上。在Java 8之前，每个注解只能应用一次。

@Override：

public class Parent {
    public void print() {
        System.out.println("Parent class");
    }
}

public class Child extends Parent {
    @Override
    public void print() {
        System.out.println("Child class");
    }
}

@Deprecated：

public class MyClass {
    /**
     * @deprecated This method is deprecated and should not be used anymore.
     */
    @Deprecated
    public void oldMethod() {
        // 方法实现
    }
}

@SuppressWarnings：

public class Example {
    @SuppressWarnings("unchecked")
    public void processList() {
        List<String> list = new ArrayList();
        // 忽略类型转换警告
        list.add("example");
        System.out.println(list);
    }
}

@SafeVarargs：

public class Example {
    @SafeVarargs
    public final void printList(List<String>... lists) {
        for (List<String> list : lists) {
            System.out.println(list);
        }
    }
}

@FunctionalInterface：

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

public class Example {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        System.out.println(add.calculate(2, 3)); // 输出：5
    }
}

@SuppressWarnings：

@SuppressWarnings("unused")
public class Example {
    private String unusedVariable;

    public void doSomething() {
        // 方法实现
    }
}

@SafeVarargs：

public class Example {
    @SafeVarargs
    public final void process(List<String>... lists) {
        for (List<String> list : lists) {
            System.out.println(list);
        }
    }
}

@Repeatable：

@Repeatable(Authors.class)
public @interface Author {
    String name();
}

public @interface Authors {
    Author[] value();
}

@Author(name = "John")
@Author(name = "Jane")
public class Example {
    // 类的定义
}

4.2 JDK元注解

JDK 的元 Annotation 用于修饰其他 Annotation 定义
JDK5.0提供了4个标准的meta-annotation类型，分别是：
- Retention
- Target
- Documented
- Inherited
@Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 的生命周期, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用@Rentention 时必须为该 value 成员变量指定值:
- RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释
- RetentionPolicy.CLASS:在class文件中有效（即class保留），当运行 Java 程序时, JVM不会保留注解。这是默认值
- RetentionPolicy.RUNTIME:在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会保留注释。程序可以通过反射获取该注释。
@Target: 用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。
JDK1.8@Target新增类型如下：
- ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
- ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
Java 8新增可重复注解：
@Documented: 用于指定被该元 Annotation 修饰的 Annotation 类将被javadoc 工具提取成文档。默认情况下， javadoc是不包括注解的。
- 定义为Documented的注解必须设置Retention值为RUNTIME。
@Inherited: 被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited 修饰的 Annotation, 则其子类将自动具有该注解。
- 比如：如果把标有@Inherited注解的自定义的注解标注在类级别上，子类则可以继承父类类级别的注解

4.3 通过反射获取注解

JDK 5.0 在 java.lang.reflect 包下新增了 AnnotatedElement 接口, 该接口代表程序中可以接受注解的程序元素
当一个 Annotation 类型被定义为运行时 Annotation 后, 该注解才是运行时可见, 当 class 文件被载入时保存在 class 文件中的 Annotation 才会被虚拟机读取
程序可以调用 AnnotatedElement对象的如下方法来访问 Annotation 信息

当我们使用注解时，通常每个注解只能在给定的目标（类、方法、字段等）上出现一次。然而，有时候我们可能需要在同一个目标上使用多次相同的注解。

Java 8引入了Repeatable注解来解决这个问题。通过将其他自定义注解标记为@Repeatable注解的容器注解，就可以在同一个目标上多次重复使用这个自定义注解。

具体步骤如下：

创建你自己的注解，并确保它具有@Repeatable注解修饰。例如：

@Inherited
@Target({ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(MyAnnotations.class)
public @interface MyAnnotation {
    String value() default "hello";
}

创建一个容器注解，用于包裹你的自定义注解。这个容器注解需要被定义为可以重复使用。例如：

@Inherited
@Target({ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {
    MyAnnotation[] value();
}

在目标上使用自定义注解。现在，你可以直接在同一个目标上多次重复使用被@Repeatable注解修饰的自定义注解，而无需使用容器注解。例如：

package com.dfrt.gb.annotation;

public class Person {
    @MyAnnotation("2935179254")
    private int id;
    @MyAnnotation(value = "张三")
    private String name;
    @MyAnnotation(value = "18")
    private String age ;

    public Person(){

    }

    @MyAnnotation(value = "注解展示")
    public String show(){
        return "展示";
    }

    @MyAnnotation(value = "注解1")
    @MyAnnotation(value = "注解2")
    public void many(){

    }
}

当使用反射获取注解时，可以使用getAnnotationsByType()方法来获取重复注解的数组。以下是根据上述例子编写的使用反射获取注解的示例代码：

package com.dfrt.gb.annotation;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class AnnotationTest {
    public static void main(String[] args)throws Exception {

        //
        Class<Person> clazz = Person.class;//获取Person的类对象

        Method show = clazz.getMethod("show");//获得show方法的反射信息

        String invoke = (String) show.invoke(new Person());//反射调用方法
        System.out.println(invoke);

        System.out.println("--------------------------------------");

        //获取所有的属性
        Field[] fields = clazz.getDeclaredFields();
        for (Field f:fields){
            // 判断方法上是否存在指定注解
            if (f.isAnnotationPresent(MyAnnotation.class)){
                //然后通过getAnnotation()方法获取注解实例，最后获取注解实例中的value属性值并打印出来
                System.out.println(f.getAnnotation(MyAnnotation.class).value());
            }
        }

        //获取所有的方法
        Method[] methods = clazz.getMethods();
        for (Method m: methods){
            // 判断方法上是否存在指定注解
            if (m.isAnnotationPresent(MyAnnotation.class)){
                //然后通过getAnnotation()方法获取注解实例，最后获取注解实例中的value属性值并打印出来
                System.out.println(m.getAnnotation(MyAnnotation.class).value());
            }
        }

        System.out.println("------------------");

        //获取多个相同类型注解的value
        Method many = clazz.getMethod("many");
        MyAnnotation[] annotations = many.getAnnotationsByType(MyAnnotation.class);

        for (MyAnnotation a :annotations){
            System.out.println(a);
            System.out.println(a.value());
        }
    }

}

执行上述代码，将输出以下内容：

展示
--------------------------------------
2935179254
张三
18
注解展示
------------------
@com.dfrt.gb.annotation.MyAnnotation(value=注解1)
注解1
@com.dfrt.gb.annotation.MyAnnotation(value=注解2)
注解2

上述代码中使用反射获取了MyClass类上的所有注解，并打印出来。然后使用getAnnotationsByType()方法获取了MyAnnotation注解，并打印出其中的值。接着，通过获取myMethod方法并获得方法上的注解，再进行打印。

这样，我们就可以利用反射机制获取重复注解的信息，实现更灵活和动态的注解处理。

在上述示例中，我们使用了@MyAnnotation注解，而不是使用容器注解@MyAnnotations。这样，我们就可以更加简洁地在同一个目标上多次重复使用同一个注解。

总结来说，Repeatable注解允许我们在同一个目标上多次使用同一个自定义注解，使得代码更加简洁、清晰，并提高了代码的可读性。

五、反射机制的效率

由于Java反射是要解析字节码，将内存中的对象进行解析，包括了一些动态类型，而JVM无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多！

5.1 反射机制的效率测试

public class Test {
    public static void main(String[] args) {
        try {
            //反射耗时
            long reflectStart = System.currentTimeMillis();
            Class clazz = Class.forName("com.itbaizhan.Users");
            Users users = (Users) clazz.getConstructor(null).newInstance();
            Method method = clazz.getMethod("setUsername", String.class);
            //忽略安全检查
            method.setAccessible(true);
            for(int i=0;i<100000000;i++){
                method.invoke(users,"Oldlu");
            }
            long reflectEnd = System.currentTimeMillis();

            //非反射方式的耗时
            long start = System.currentTimeMillis();
            Users users1 = new Users();
            for(int i=0;i<100000000;i++){
               users1.setUsername("oldlu");
            }
            long end = System.currentTimeMillis();

            System.out.println("反射执行时间："+(reflectEnd - reflectStart));
            System.out.println("普通方法执行时间："+(end-start));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.2 setAccessible方法

setAccessible()方法：

setAccessible是启用和禁用访问安全检查的开关。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查;默认值为false。

由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的。

public class Test2 {
    public static void main(String[] args) throws Exception{
        Users users = new Users();
        Class clazz = users.getClass();
        Field field = clazz.getDeclaredField("username");
        //忽略安全检查
        field.setAccessible(true);
        field.set(users,"Oldlu");
        Object obj =  field.get(users);
        System.out.println(obj);
        System.out.println("----------------");
        Method method = clazz.getDeclaredMethod("suibian");
        method.setAccessible(true);
        method.invoke(users);
    }
}

六、总结

Java 反射机制是Java语言一个很重要的特性，它使得Java具有了“动态性”。
反射机制的优点
- 更灵活。
- 更开放。
反射机制的缺点
- 降低程序执行的效率。
- 增加代码维护的困难。
获取Class类的对象的三种方式
- 运用getClass()。
- 运用.class 语法。
- 运用Class.forName()（最常被使用）。
反射机制的常见操作
- 动态加载类、动态获取类的信息（属性、方法、构造器）。
- 动态构造对象。
- 动态调用类和对象的任意方法。
- 动态调用和处理属性。
- 获取泛型信息。
- 处理注解。

惊鸿化雨

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JAVA基础深化提高(八) | 反射技术

本博客探讨了JAVA反射技术的重要性和应用。反射是一种强大的机制，使得我们可以在运行时动态地获取和操作类的信息，包括类的成员变量、方法和构造函数等。本文详细介绍了反射的基本概念、常见的反射操作，如获取类对象、调用方法、修改属性等。通过学习本文，读者将掌握如何灵活利用反射技术解决一些复杂问题，并提升代码的灵活性和可扩展性。无论是初学者还是有一定经验的开发者，都能从本博客中获得关于JAVA反射技术的深入理解和实践经验。
复制链接

扫一扫