第17章_反射机制

该篇笔记，是因为想重新学一下Spring Cloud 和Spring Cloud Alibaba框架，但是b站尚硅谷的最新课程，使用SpringBoot3作为，单体服务的框架，而SpringBoot3最低要求JDK17，所以必须要学一下JDK8-JDK17之间的新特性。本来只想看，宋红康老师课程的第18章JDK8-17新特性，但是觉得反射的API有点忘记，遂顺便看了第17章_反射机制，故有此笔记。

本章专题与脉络

1.反射(Refection)的概念

1.1 反射的出现背景

Java 程序中，所有的对象都有两种类型：编译时类型和运行时类型，而很多时候对象的编译时类型和运行时类型不一致。 Object obj = new String("hello"); obj.getClass()

例如：某些变量或形参的声明类型是 Object 类型，但是程序却需要调用该对象运行时类型的方法，该方法不是 Object 中的方法，那么如何解决呢？

解决这个问题，有两种方案：

方案 1：在编译和运行时都完全知道类型的具体信息，在这种情况下，我们可以直接先使用 instanceof运算符进行判断，再利用强制类型转换符将其转换成运行时类型的变量即可。

方案 2：编译时根本无法预知该对象和类的真实信息，程序只能依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射。

1.2 反射概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助与Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为反射。

从内存加载上看反射：

1.3 Java反射机制研究及应用

Java反射机制提供的功能：

在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时获取泛型信息；
在运行时调用任意一个对象的成员变量和方法；
在运行时处理注解；
生成动态代理。

1.4 反射相关的API

java.lang.Class：代表一个类、java.lang.reflect.Method：代表类的方法、java.lang.reflect.Field：代表类的成员变量、java.lang.reflect.Constructor：代表类的构造器 java.lang.reflect.Type，类型接口，Class类实现类该接口...

1.5 反射的缺点

优点：

提高了Java程序的灵活性和扩展性，降低了耦合性，提高自适应能力。
允许程序创建和控制任何类的对象，无需提前硬编码目标类。

缺点：

反射的性能较低。
- 反射机制主要应用在对灵活性和扩展性要求很高的系统框架上。
反射代码会模糊程序内部逻辑，可读性较差。

2.理解Class类并获取CLass实例

要想解析一个类，必须要先获取到该类的Class对象。而解析一个类或用反射解决具体的问题就是使用相关API：

java.lang.Class
java.lang.reflect.*

可以说，Class对象是反射的根源。

2.1 理解Class

2.1.1 理论

在Object类中定义了一下的方法，此方法被所有子类继承：

public final native Class<?> getClass();//没有具体方法体，这是本地方法，底层是JNI机制，调用的写好的C\C++代码

以上的方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(Class/Interface/Enum/Annotation/Primitive Type/void/[])的有关信息。

Primitive Type代表的基本数据类，如int，long等八大基本数据类型。注意基本数据类型和其包装类的Class对象不是同一个。

Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在 JVM 中只会有一个Class实例
一个Class对象对应的是一个加载到 JVM 中的一个.class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

2.1.2 内存结构上

说明：上图中字符串常量池在 JDK6 中存储在方法区；JDK7及以后，存储在堆空间。

2.2 获取Class类的实例(四种方法)

/**
 * 获取Class实例的几种方式
 * 掌握前三种
 */
@Test
public void demo01() throws ClassNotFoundException {

    //前提：若已知具体的类，通过类的 class 属性获取，该方法最为安全可靠，程序性能最高
    //1.调用运行时类的静态属性：class
    Class clazz1 = User.class;
    System.out.println(clazz1);
	
    //前提：已知某个类的实例，调用该实例的 getClass()方法获取 Class 对象
    //2.调用运行时类的对象的getClass()方法
    User user = new User();
    Class clazz2 = user.getClass();

    System.out.println(clazz1 == clazz2);//true

    //前提：已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法forName()获取，
    可能抛出 ClassNotFoundException
    //3. 调用Class的静态方法forName(String className)
    String className = "com.changming06.example02_class.User";//全类名
    Class class3 = Class.forName(className);//使用较多，更体现反射的动态性
    System.out.println(class3 == clazz2);//true
    System.out.println(class3 == clazz1);//true
	
    //前提：可以用系统类加载对象或自定义加载器对象加载指定路径下的类型
    //4.使用类的加载器的方式
    Class clazz4 = ClassLoader.getSystemClassLoader().loadClass(className);
    System.out.println(clazz4 == clazz1);//true
}

User类

package com.changming06.example02_class;
/**
 * @author 长名06
 * @year 2024
 */
public class User {

    private String username;

    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }


}

2.3 那些类型有Class对象

简言之，所有 Java 类型！

（1）class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类（2）interface：接口（3）[]：数组（4）enum：枚举（5）annotation：注解@interface （6）primitive type：基本数据类型（7）void

Class c1 = Object.class;
Class c2 = Comparable.class;
Class c3 = String[].class;
Class c4 = int[][].class;
Class c5 = ElementType.class;
Class c6 = Override.class;
Class c7 = int.class;
Class c8 = void.class;
Class c9 = Class.class;

int[] a = new int[10];
int[] b = new int[100];
Class c10 = a.getClass();
Class c11 = b.getClass();
// 只要元素类型与维度一样，就是同一个 Class
System.out.println(c10 == c11);

2.4 Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	调用缺省构造函数，返回该 Class 对象的一个实例
getName()	返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称
Class getSuperClass()	返回当前 Class 对象的父类的 Class 对象
Class [] getInterfaces()	获取当前 Class 对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此 Class 所表示的实体的超类的Class
Constructor[] getConstructors()	返回一个包含某些 Constructor 对象的数组
Field[] getDeclaredFields()	返回 Field 对象的一个数组
Method getMethod(String name,Class … paramTypes)	返回一个 Method 对象，此对象的形参类型为 paramType

3.类的加载与ClassLoader的理解

3.1 类的生命周期

类在内存中完整的生命周期：加载-->使用-->卸载。其中加载过程又分为：装载、链接、初始化三个阶段。

3.2 类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、链接、初始化三个步骤来对该类进行初始化。如果没有意外，JVM 将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载。

类的加载又分为三个阶段：

（1）装载（Loading）

将类的.class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成

（2）链接（Linking）

①验证 Verify：确保加载的类信息符合 JVM 规范，例如：以 cafebabe 开头，没有安全方面的问题。

②准备 Prepare：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

③解析 Resolve：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

关于，解析的理解，虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。在类中假如有一个public String name的属性声明，因为要将类加载到虚拟机，也就是加载到内存中，在内存的物理结构中，存储字符串的格式是Ox0011(地址符) -> 代表具体数据的二进制代码，一个地址中存储一些数据。

public String name本质上是存储在文件中的一些字符串，不过这些字符串是写在.java的文件中，才有了特殊的意义。但其本质依旧是字符串，要想在内存中生成一个类的class对象，也就是体现该类结构的对象。则必须出现这些字符串，也就是说，可用申请一大块内存，将一个类中出现的字符串都存储在一大块内存中，但是这样对于出现在多个类中的字符串，就会在内存中出现数据冗余，占据多的内存，所以将类中的字符串，拆分成一个一个的字符串，进行单个存储，这样使用相同的字符串时，只用字符串的地址符就行了，提高字符串的利用率，降低占据的内存。只是个人浅薄认知，如果不对，还请大神教导。

（3）初始化（Initialization）

执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

3.3 类加载器（ClassLoader）

3.3.1 类加载器的作用

将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口。

类缓存：标准的 JavaSE 类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过 JVM 垃圾回收机制可以回收这些 Class 对象。

3.3.2 类加载器的分类(JDK8)

JVM 支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类，类加载器，但是 Java 虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader 的类加载器都划分为自定义类加载器。无论类加载器的类型如何划分，在程序中我们最常见的类加载器结构主要是如下情况：

1）启动类加载器（引导类加载器，Bootstrap ClassLoader）**

这个类加载使用 C/C++语言实现的，嵌套在 JVM 内部。获取它的对象时往往返回null。
它用来加载 Java 的核心库（JAVA_HOME/jre/lib/rt.jar 或 sun.boot.class.path 路径下的内容）。用于提供 JVM 自身需要的类。
并不继承自 java.lang.ClassLoader，没有父加载器。
出于安全考虑，Bootstrap 启动类加载器只加载包名为 java、javax、sun 等开头的类。
加载扩展类和应用程序类加载器，并指定为他们的父类加载器。

（2）扩展类加载器（Extension ClassLoader）

Java 语言编写，由 sun.misc.Launcher$ExtClassLoader 实现。
继承于 ClassLoader 类
父类加载器为启动类加载器
从 java.ext.dirs 系统属性所指定的目录中加载类库，或从 JDK 的安装目录的 jre/lib/ext子目录下加载类库。如果用户创建的 JAR 放在此目录下，也会自动由扩展类加载器加载。

（3）应用程序类加载器（系统类加载器，AppClassLoader）
java 语言编写，由 sun.misc.Launcher$AppClassLoader 实现
继承于 ClassLoader 类
父类加载器为扩展类加载器
它负责加载环境变量 classpath 或系统属性 java.class.path 指定路径下的类库
应用程序中的类加载器默认是系统类加载器。
它是用户自定义类加载器的默认父加载器
通过 ClassLoader 的 getSystemClassLoader()方法可以获取到该类加载器

（4）用户自定义类加载器（了解）

在 Java 的日常应用程序开发中，类的加载几乎是由上述 3 种类加载器相互配合执行的。在必要时，我们还可以自定义类加载器，来定制类的加载方式。
体现 Java 语言强大生命力和巨大魅力的关键因素之一便是，Java 开发者可以自定义类加载器来实现类库的动态加载，加载源可以是本地的 JAR 包，也可以是网络上的远程资源。
同时，自定义加载器能够实现应用隔离，例如 Tomcat，Spring 等中间件和组件框架都在内部实现了自定义的加载器，并通过自定义加载器隔离不同的组件模块。这种机制比 C/C++程序要好太多，想不修改 C/C++程序就能为其新增功能，几乎是不可能的，仅仅一个兼容性便能阻挡住所有美好的设想。
自定义类加载器通常需要继承于 ClassLoader。

3.3.3 查看某个类的类加载器对象

@Test
public void demo1(){
    //获取系统类加载器
    ClassLoader classLoader1 = ClassLoader.getSystemClassLoader();
    System.out.println(classLoader1);//sun.misc.Launcher$AppClassLoader@18b4aac2

    
    //查看某个类是哪个类加载器加载的
	ClassLoader classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
    
    //获取扩展类加载器
    ClassLoader classLoader2 = classLoader1.getParent();//获取类加载器的父加载器
    System.out.println(classLoader2);//sun.misc.Launcher$ExtClassLoader@28a418fc

    //获取引导类加载器：失败
    ClassLoader classLoader3 = classLoader2.getParent();
    System.out.println(classLoader3);//null
}

@Test
public void demo2(){
    //用户自定义使用的是系统类加载器加载的。
    ClassLoader classLoader = User.class.getClassLoader();
    System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

    //对于Java的核心类使用的是引导类加载器加载
    ClassLoader classLoader1 = String.class.getClassLoader();
    System.out.println(classLoader1);//null
}

4.反射的基本应用

有了 Class 对象，能做什么？

4.1 应用1：创建运行时类的对象

这是反射机制应用最多的地方。创建运行时类的对象有两种方式：

方式 1：直接调用 Class 对象的 newInstance()方法

要求： 1）类必须有一个无参数的构造器。2）类的构造器的访问权限需要足够。

方式 2：通过获取构造器对象来进行实例化

方式一的步骤：

1）获取该类型的 Class 对象

2）调用 Class 对象的 newInstance()方法创建对象

方式二的步骤：

1）通过 Class 类的 getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器

2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

3）通过 Constructor 实例化对象。

如果构造器的权限修饰符修饰的范围不可见，也可以调用 setAccessible(true)

/**
 * 这里只是为了演示，简化代码量，在实际开发中，不要在方法定义中，抛出顶层的异常
 * @throws Exception
 */
@Test
public void demo1() throws Exception{
    //获取到class对象，有多种方式，见上笔记
    Class clazz = Cat.class;

    Object obj = clazz.newInstance();
    System.out.println(obj);
}

@Test
public void demo2() throws Exception{
    Class clazz = Cat.class;
    //未使用泛型
    Constructor constructor = clazz.getDeclaredConstructor(String.class, boolean.class);
    constructor.setAccessible(true);
    //如果访问的构造器无权限，其未显示调用该方法设置为可访问会报java.lang.IllegalAccessException
    Object instance = constructor.newInstance("白色", true);
    System.out.println(instance);
}

4.2 应用2：获取运行时类的完整结构

可以获取：包、修饰符、类型名、父类（包括泛型父类）、父接口（包括泛型父接口）、成员（属性、构造器、方法）、注解（类上的、方法上的、属性上的）。

4.2.1 相关API

//1.实现的全部接口
public Class<?>[] getInterfaces() 
//确定此对象所表示的类或接口实现的接口。
    
//2.所继承的父类
public Class<? Super T> getSuperclass()
//返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。
    
//3.全部的构造器
public Constructor<T>[] getConstructors()
//返回此 Class 对象所表示的类的所有 public 构造方法。
    
public Constructor<T>[] getDeclaredConstructors()
//返回此 Class 对象表示的类声明的所有构造方法。
//Constructor 类中：
    
//取得修饰符: 
public int getModifiers();
//取得方法名称: 
public String getName();
//取得参数的类型：
public Class<?>[] getParameterTypes();

//4.全部的方法
public Method[] getDeclaredMethods()
//返回此 Class 对象所表示的类或接口的全部方法
public Method[] getMethods() 
//返回此 Class 对象所表示的类或接口的 public 的方法
    
//Method 类中：
public Class<?> getReturnType()
//取得全部的返回值
public Class<?>[] getParameterTypes()
//取得全部的参数
public int getModifiers()
//取得修饰符
public Class<?>[] getExceptionTypes()
//取得异常信息
    
//5.全部的 Field
public Field[] getFields()
//返回此 Class 对象所表示的类或接口的 public 的 Field。
    
public Field[] getDeclaredFields()
//返回此 Class 对象所表示的类或接口的全部 Field。
    
//Field 方法中：
public int getModifiers()
//以整数形式返回此 Field 的修饰符
public Class<?> getType() 
//得到 Field 的属性类型
public String getName() 
//返回 Field 的名称。
    
//6. Annotation 相关
get Annotation(Class<T> annotationClass)
getDeclaredAnnotations()
    
//7.泛型相关
//获取父类泛型类型：
Type getGenericSuperclass()
//泛型类型：ParameterizedType
//获取实际的泛型类型参数数组：
getActualTypeArguments()

//8.类所在的包
Package getPackage()

4.2.2 获取属性及其相关细节

/**
 * @author 长名06
 * 反射方式获取类中属性信息
 * @year 2024
 */
public class FieldsTest {

    @Test
    public void demo1(){
        Class clazz = Cat.class;
        Field[] fields = clazz.getFields();
        for(Field field : fields){
            System.out.println(field);
        }
    }

    @Test
    public void demo2(){
        Class clazz = Cat.class;
        Field[] fields = clazz.getDeclaredFields();
        for(Field field : fields){
            System.out.println(field);
        }
    }

    //权限符 变量类型 变量名
    @Test
    public void demo3(){
        Class clazz = Cat.class;
        Field[] fields = clazz.getDeclaredFields();
        for(Field field : fields){
            //1.权限修饰符
            /**
             * 0x 是十六进制
             * PUBLIC       = 0x00000001; 1 1
             * PRIVATE      = 0x00000002; 2 10
             * PROTECTED    = 0x00000004; 4 100
             * STATIC       = 0x00000008; 8 1000
             * FINAL        = 0x00000010; 1610000
             * ... 在Modifier类中定义了很多类似
             * public static final int FINAL = 0x00000010;的属性
             * 设计的思想是，就是用二进制的某一位是 1，来代表一种修饰符，整个二进制中只有一位是 1，其余都是 0
             * 这样，也就是getModifiers的计算得到的int的值是多个修饰符对应的值加一起(即是一串固定的二进制数)，
             * 有下面的好处
             *      Modifier#isPrivate
             *      public static boolean isPrivate(int mod) {
             *         return (mod & PRIVATE) != 0;
             *     }
             * 方便进行判断，该属性中是否包括某个修饰符
             * 因为修饰符，是和二进制中某位是一一对应的，getModifiers得到的结果是加运算，自然是有某个修饰符，与其对应的位置设为1，
             * 判断是否有该修饰符，只要把得到的值modifiers和对应的修饰符的值，进行逻辑与元素判断是否为0即可。
             */
            int modifiers = field.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");
            //判断是否具有public修饰符，其他类似，不在举例
            System.out.print(Modifier.isPublic(modifiers) + "\t");

            //2.数据类型
            Class<?> type = field.getType();
            System.out.print(type.getName() + "\t");

            //3.变量名
            String fieldName = field.getName();//引用类型是全类名，基本类型就是对应基本类型的关键字
            System.out.print(fieldName);

            System.out.println();
        }
    }

}

4.2.3 获取所有的方法及相关细节

/**
 * @author 长名06
 * @year 2024
 */
public class MethodTest {

    @Test
    public void demo1() throws Exception{

        Class<?> clazz = Class.forName("com.changming06.example_apply.data.Cat");

        Method[] methods = clazz.getMethods();

        for(Method m : methods){
            System.out.println(m);
        }
    }

    @Test
    public void demo2() throws Exception{
        Class<?> clazz = Class.forName("com.changming06.example_apply.data.Cat");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m);
        }
    }

    @Test
    public void demo3() throws Exception{
        Class<?> clazz = Class.forName("com.changming06.example_apply.data.Cat");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            //1.获取方法声明的注解
            Annotation[] annotations = m.getAnnotations();
            for (Annotation annotation : annotations){
                System.out.println(annotation);
            }

            //2.权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");

            //3.返回值类型
            System.out.print(m.getReturnType().getName() + "\t");

            //4.方法名
            System.out.print(m.getName());
            System.out.print("(");
            //5.形参列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                boolean isFirst = true;
                for(int i = 0; i < parameterTypes.length;i++){
                    Class c = parameterTypes[i];
                    if(i == parameterTypes.length - 1){
                        System.out.print(c.getName() + " arg_" + i);
                        break;
                    }
                    System.out.print("," + c.getName() + " arg_" + i + ",");
                }
            }
            System.out.print(")");

            //6.抛出的异常
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            if(exceptionTypes.length > 0){
                System.out.print("throws");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i == exceptionTypes.length - 1) {
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName() + ",");
                }
            }
            System.out.println();
        }
    }

}

4.2.4 获取其他结构（构造器，父类，接口，包，注解等）

/**
 * @author 长名06
 * @year 2024
 */
public class OtherTest {

    /**
     * 获取当前类中的所有的构造器
     */
    @Test
    public void demo1() {
        Class clazz = Cat.class;
        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor c : constructors) {
            System.out.println(c);
        }

    }

    /**
     * 获取运行时类的父类
     */
    @Test
    public void demo2() {
        Class clazz = Cat.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }

    /**
     * 获取运行时类的所在的包
     */
    @Test
    public void demo3() {
        Class clazz = Cat.class;
        Package aPackage = clazz.getPackage();//package是关键字
        System.out.println(aPackage);
    }

    /**
     * 获取运行时类的注解
     */
    @Test
    public void demo4() {
        Class clazz = Cat.class;
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation anno : annotations) {
            System.out.println(anno);//类上并无注解
        }
    }

    /**
     * 获取运行时类所实现的接口
     */
    @Test
    public void demo5() {
        Class clazz = Cat.class;

        Class[] interfaces = clazz.getInterfaces();//获取类实现接口的class对象的数组
        for (Class c : interfaces) {
            System.out.println(c);
        }
        System.out.println("--------");

        AnnotatedType[] annotatedInterfaces = clazz.getAnnotatedInterfaces();//获取带注解的接口的class对象的数组
        for (AnnotatedType anInterfaces : annotatedInterfaces) {
            if (anInterfaces.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation annotation = anInterfaces.getAnnotation(MyAnnotation.class);
                System.out.println(annotation.value());
            }
            System.out.println(anInterfaces);
        }
        System.out.println("--------");

        Type[] types = clazz.getGenericInterfaces();
        //获取当前clazz对象对应的类实现的带泛型的接口的class对象的数组，但是不带泛型的接口的class对象，也会在返回值中
        for (Type type : types) {
            //获取接口的全名称
            String typeName = type.getTypeName();
            //如果接口有泛型，可用将type转成ParameterizedType，
            //获取父类的泛型，与此类似。因为Type的本质是Class类的父接口，
            //其对象实例是一个个Class的对象，也就是一个个类或接口或其他有class对象的Java结构(void,基本类型等)的唯一的class对象
            //这样的理解条件下，接口和类的class无区别，因为在继承父类和实现父接口时，都可以指定泛型(在其定义了泛型的前提下)
            if (type instanceof ParameterizedType) {//只有是有泛型的class对象，才进行强转
                ParameterizedType parameterizedType = (ParameterizedType) type;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//获取其泛型列表数组
                System.out.println(Arrays.asList(actualTypeArguments));
            }


            System.out.println(typeName);
            System.out.println(type);//获取接口信息
        }
    }

    @Test
    public void demo6() {
        Class clazz = Cat.class;
        //获取带泛型的父类，Class类实现了Type接口
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);//如果有父类是有泛型的会出现泛型，没有输出父类

        if (genericSuperclass instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            System.out.println(((Class)actualTypeArguments[0]).getName());
        }
    }
}

4.2.5 获取泛型父类信息

public class GenericTest {
    public static void main(String[] args) {
        //（1）还是先获取 Class 对象
        Class clazz = Son.class;//四种形式任意一种都可以
        Type type = clazz.getGenericSuperclass();//获取父类
        // Father<String,Integer>属于 ParameterizedType
        ParameterizedType pt = (ParameterizedType) type;//父类的class对象，转成ParameterizedType可以获取泛型信息
        //（3）获取泛型父类的泛型实参列表
        Type[] typeArray = pt.getActualTypeArguments();
        for (Type type2 : typeArray) {
            System.out.println(type2);
        }
    }
}
//泛型形参：<T,U>
class Father<T,U>{
}
//泛型实参：<String,Integer>
class Son extends Father<String,Integer>{
}

4.2.6 获取内部类或外部类信息（了解）

public Class<?>[] getClasses()：返回所有公共内部类和内部接口。包括从超类继承的公共类和接口成员以及该类声明的公共类和接口成员。

public Class<?>[] getDeclaredClasses()：返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口。包括该类所声明的公共、保护、默认（包）访问及私有类和接口，但不包括继承的类和接口。

public Class<?> getDeclaringClass()：如果此 Class 对象所表示的类或接口是一个内部类或内部接口，则返回它的外部类或外部接口，否则返回 null。

Class<?> getEnclosingClass() ：返回某个内部类的外部类。

4.2.7 小结

1.在实际的操作中，取得类的信息的操作代码，并不会经常开发。

2.一定要熟悉 java.lang.reflect 包的作用，反射机制。

4.3 应用3：调用运行类的指定结构

4.3.1 调用指定的属性

在反射机制中，可以直接通过 Field 类操作类中的属性，通过 Field 类提供的set()和 get()方法就可以完成设置和取得属性内容的操作。

/**
①获取该类型的 Class 对象
Class clazz = Class.forName("包.类名");
②获取属性对象
Field field = clazz.getDeclaredField("属性名");
③如果属性的权限修饰符不是 public，那么需要设置属性可访问
field.setAccessible(true);
④创建实例对象：如果操作的是非静态属性，需要创建实例对象
Object obj = clazz.newInstance();
有公共的无参构造Object obj = 构造器对象.newInstance(实参...);//通过特定构造器对象创建实例对象
⑤设置指定对象 obj 上此 Field 的属性内容field.set(obj,"属性值");
如果操作静态变量，那么实例对象可以省略，用 null 表示
⑥取得指定对象 obj 上此 Field 的属性内容Object value = field.get(obj);
如果操作静态变量，那么实例对象可以省略，用 null 表示
*/

/**
 * 反射应用3-1 调用知道的属性
 *  public String color = "黑色";
 */
@Test
public void demo1() throws Exception {
    Class clazz = Cat.class;

    Cat cat = (Cat)clazz.newInstance();

    //只能获取到public修饰的
    Field colorField = clazz.getField("color");
    colorField.set(cat,"白色");
    System.out.println(colorField.get(cat));
}

@Test
public void demo2() throws Exception {
    Class clazz = Cat.class;

    Cat cat = (Cat)clazz.newInstance();

    //1.通过clazz.getDeclaredField(String fieldName)获取类中声明的属性，和访问修饰符是否能访问无关
    Field wildField = clazz.getDeclaredField("wild");
    //2.setAccessible(true)，确保能访问该属性
    wildField.setAccessible(true);
    //3.Field的实例，的get(Object object)方法获取object对象的fieldName属性
    //set(Object object,Object value)设置object对象的fieldName属性值
    wildField.set(cat,false);
    System.out.println(wildField.get(cat));
}

@Test
public void demo3() throws Exception {
    Class clazz = Cat.class;

    //1.通过clazz.getDeclaredField(String fieldName)获取类中声明的属性，和访问修饰符是否能访问无关
    Field wildField = clazz.getDeclaredField("price");
    //2.setAccessible(true)，确保能访问该属性
    wildField.setAccessible(true);
    //3.Field的实例，的get(Object object)方法获取object对象的fieldName属性
    //set(Object object,Object value)设置object对象的fieldName属性值
//        wildField.set(clazz,300.0);//对于类变量，传入的是该类的class对象用来获取和设置
//        System.out.println(wildField.get(clazz));
    //对于类变量，传入的是null值用来获取和设置也可以，因为类变量，在获取该属性时，是通过类.class获取的
    //相当于，创建该属性对象时，已经指明了该属性对象的类。而对象属性不行，是因为象属性，是和类的实例有关的，
    //必须得属于一个对象实例，谈对象属性才有意义。
    wildField.set(null,300.0);
    System.out.println(wildField.get(null));
}

关于 setAccessible 方法的使用：

Method 和 Field、Constructor 对象都有 setAccessible()方法。
setAccessible 启动和禁用访问安全检查的开关。
参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
- 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为 true。
- 使得原本无法访问的私有成员也可以访问
参数值为 false 则指示反射的对象应该实施 Java 语言访问检查。

4.3.2 调用指定的方法

/*（1）获取该类型的 Class 对象
Class clazz = Class.forName("包.类名");
（2）获取方法对象
Method method = clazz.getDeclaredMethod("方法名",方法的形参类型列表);
（3）创建实例对象
Object obj = clazz.newInstance();
（4）调用方法
Object result = method.invoke(obj, 方法的实参值列表);
如果方法的权限修饰符修饰的范围不可见，也可以调用
setAccessible(true)
如果方法是静态方法，实例对象也可以省略，用 null 代替
*/
/*********************** 调用指定方法 ***********************/

@Test
public void demo4() throws Exception {
    Class clazz = Cat.class;

    Cat cat = (Cat) clazz.newInstance();

    //注意int.class和Integer.class不一样，其他基本类型和其包装类同理
    //1.clazz.getDeclaredMethod(String methodName, Class... args)获取指定的方法
    Method showPriceMethod = clazz.getDeclaredMethod("showPrice", int.class);

    //2.设置可访问
    showPriceMethod.setAccessible(true);

    //3.通过Method实例调用invoke(Object object,Object... args)，即执行Method对于的方法的执行
    //returnValue返回值，就是方法的返回值
    //如果方法的返回值为void，则返回值是null
    Object returnValue = showPriceMethod.invoke(cat, 20);

    System.out.println(returnValue);
}

@Test
public void demo5() throws Exception {
    Class clazz = Cat.class;


    //注意int.class和Integer.class不一样，其他基本类型和其包装类同理
    //1.clazz.getDeclaredMethod(String methodName, Class... args)获取指定的方法
    Method showColorMethod = clazz.getDeclaredMethod("showColor");

    //2.设置可访问
    showColorMethod.setAccessible(true);

    //3.通过Method实例调用invoke(Object object,Object... args)，即执行Method对于的方法的执行
    //returnValue返回值，就是方法的返回值
    //如果方法的返回值为void，则返回值是null
    Object returnValue = showColorMethod.invoke(null);

    System.out.println(returnValue);
}

4.3.3 调用指定构造器

  /*********************** 调用指定构造器 ***********************/

@Test
public void demo6() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    Class clazz = Cat.class;

    //1.getDeclaredConstructor(Class... args)，根据传入对应构造器形参的class对象,获取指定的构造器
    Constructor constructor = clazz.getDeclaredConstructor(String.class, boolean.class);

    //2.设置可访问
    constructor.setAccessible(true);

    //3.反射创建对象
    Cat object = (Cat) constructor.newInstance("白色", true);

    System.out.println(object);
}

//使用Constructor替换clazz.newInstance();
@Test
public void demo7() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    Class clazz = Cat.class;

    Constructor constructor = clazz.getDeclaredConstructor();

    constructor.setAccessible(true);
    Object obj = constructor.newInstance();
    System.out.println(obj);

}

5. 应用 4：读取注解信息

一个完整的注解应该包含三个部分：（1）声明（2）使用（3）读取

5.1 声明注解

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.TYPE;

/**
 * @author 长名06
 * @year 2024
 */
@Target({TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {

    String value();

}

package com.changming06.example_other.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.FIELD;

/**
 * @author 长名06
 * @year 2024
 */
@Target({FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {

    String columnName();

    String columnType();

}

自定义注解可以通过四个元注解@Retention,@Target，@Inherited,@Documented，分别说明它的声明周期，使用位置，是否被继承，是否被生成到 API 文档中。
Annotation 的成员在 Annotation 定义中以无参数有返回值的抽象方法的形式来声明，我们又称为配置参数。返回值类型只能是八种基本数据类型、String 类型、Class类型、enum 类型、Annotation 类型、以上所有类型的数组。
可以使用 default 关键字为抽象方法指定默认返回值。
如果定义的注解含有抽象方法，那么使用时必须指定返回值，除非它有默认值。格式是“方法名 = 返回值”，如果只有一个抽象方法需要赋值，且方法名为 value，可以省略“value=”，所以如果注解只有一个抽象方法成员，建议使用方法名value。

5.2 使用自定义注解

/**
 * @author 长名06
 * @year 2024
 */
@Table("customer")
public class Customer {

    @Column(columnName = "cust_name",columnType = "varchar(20)")
    private String name;

    @Column(columnName = "cust_age",columnType = "int")
    public int age;

    public Customer() {
    }

    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

5.3 读取和处理自定义注解

自定义注解必须配上注解的信息处理流程才有意义。

我们自己定义的注解，只能使用反射的代码读取。所以自定义注解的声明周期必须是 RetentionPolicy.RUNTIME。

/**
 * @author 长名06
 * @year 2024
 */
public class AnnotationTest {

    //获取类声明上的注解
    @Test
    public void demo1(){
        Class<?> clazz = Customer.class;

        //想要反射的获取注解，则该注解必须被@Retention(RetentionPolicy.RUNTIME)元注解修饰
        //且必须是RetentionPolicy.RUNTIME类型，这样该注解信息才会保存到内存中

        //获取类声明的注解
        Table declaredAnnotation = clazz.getDeclaredAnnotation(Table.class);
        String annotationValue = declaredAnnotation.value();

        System.out.println(declaredAnnotation + "\t" + annotationValue);
    }

    //获取属性声明的注解
    @Test
    public void demo2() throws NoSuchFieldException {
        Class<?> clazz = Customer.class;
        //获取属性
        Field nameField = clazz.getDeclaredField("name");
        //获取属性声明的注解
        Column column = nameField.getDeclaredAnnotation(Column.class);

        System.out.println(column.columnName());
        System.out.println(column.columnType());

    }

}

6.体会反射的动态性

/**
 * @author 长名06
 * @year 2024
 */
public class ReflectTest {


    /**
     * 反射动态性
     * @param className
     * @return
     */
    public Object getInstance(String className) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        Class<?> clazz = Class.forName(className);
        Constructor<?> constructor = clazz.getDeclaredConstructor();
        return constructor.newInstance();
    }

    @Test
    public void demo() throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {

        String className = "com.changming06.example_other.dynamic.Person";
        System.out.println(getInstance(className));

    }


}

public class Apple implements Fruit{
    @Override
    public void squeeze() {
        System.out.println("榨一杯苹果汁");
    }
}

public class Banana implements Fruit{
    @Override
    public void squeeze() {
        System.out.println("榨一杯香蕉汁");
    }
}

public interface Fruit {

    void squeeze();

}

public class Juicer {

    public void run(Fruit f){
        f.squeeze();
    }

}

public class Orange implements Fruit{
    @Override
    public void squeeze() {
        System.out.println("榨一杯橘子汁");
    }
}

可以在，配置文件【config.properties】保存全类名com.changming06.example_other.exer.Apple，完整类的创建，然后创建Juicer类，完整run()方法执行。

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

posted @ 2024-08-21 21:57 长名06 阅读(81) 评论(0) 编辑收藏举报

刷新页面返回顶部