CT的Java基础学习笔记（十六）——反射

Java基础学习笔记整理了我从零开始学习Java时所学习到的内容。
以下内容参考尚硅谷Java教程。

十六、Java 反射

1 概述

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

框架 = 反射 + 注解 + 设计模式。

1.1 反射的动态性

以下代码表明了反射的动态性，在编译时并不确定会造哪个类的对象，在运行时才确定。

@Test
public void test2(){
    int num = new Random().nextInt(3);
    String classPath = "";
    switch (num){
        case 0:
            classPath = "java.util.Date";
            break;
        case 1:
            classPath = "java.lang.Object";
            break;
        case 2:
            classPath = "Person";
            break;
    }

    try {
        Object o = getInstance(classPath);
        System.out.println(o);
    } catch (Exception e) {
        e.printStackTrace();
    }

}
//返回一个classPath同名类的对象
public Object getInstance(String classPath)throws Exception{
    Class clazz = Class.forName(classPath);
    return clazz.newInstance();
}

1.2 反射机制提供的功能

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

1.3 相关API

java.lang.class：反射的源头
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.Constructor
…

2 Class类的理解与获取Class的实例

2.1 Class类的理解

1. 类的加载过程：
   程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class）。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就成为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
2. 换句话说，Class的实例就对应着一个运行时类。
3. 加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

2.2 获取Class实例的方式

@Test
public void test3() throws ClassNotFoundException {
    //方式一：使用.class获取
    Class clazz1 = Person.class;
    System.out.println(clazz1);
    //方式二：使用Person对象的getClass()方法获取
    Person p1 = new Person();
    Class clazz2 = p1.getClass();
    System.out.println(clazz2);
    //方式三：使用Class类的静态方法forName(String classPath)获取
    Class clazz3 = Class.forName("Person");
    System.out.println(clazz3);
    //方式四：使用类加载器获取：ClassLoader
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    Class clazz4 = classLoader.loadClass("Person");
    System.out.println(clazz4);
}

2.3 目前为止创建类的对象的方式

• 方式一：new + 构造器；
• 方式二：要创建Xxx类的对象，考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有静态方法存在。通过调用其静态方法，创建Xxx对象；
• 方式三：通过反射获取。

2.4 Class实例结构

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

3 类的加载过程

3.1 类加载器的作用

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

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

3.2 类加载器的分类

3.3 Java类编译、运行流程

3.4 使用ClassLoader加载src目录下的配置文件

@Test
public void test1() throws Exception {
    Properties pros = new Properties();
    //此时文件默认在当前module下
    //读取配置文件方式一：
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        pros.load(fis);

    //读取配置文件方式二：
    //默认文件位置在当前module下的src文件夹
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    InputStream is = classLoader.getResourceAsStream("jdbc.properties");
    pros.load(is);

    String user = pros.getProperty("user");
    String password = pros.getProperty("password");
    System.out.println("user = "+user+",password = "+password);
}

4 反射应用一：创建运行时类的对象

Class clazz = Person.class;
Person obj = clazz.newInstance();
System.out.println(obj);

newInstance()：调用此方法，创建对应运行时类的对象。内部调用了运行时类的空参构造器。

想要此方法正常的创建运行时类的对象，要求：

1. 运行时类必须提供空参的构造器；
2. 空参构造器的访问权限可以被访问。通常设置为public。

所以在Javabean中要求提供一个public的空参构造器，可以便于通过反射创造运行时类的对象。

5 反射应用二：创建运行时类的完整结构

获取属性

@Test
public void test1(){
    Class clazz = Person.class;
    //获取属性结构
    //getFields():获取当前运行时类的public修饰的属性
    Field[] fields = clazz.getFields();
    for(Field f: fields){
        System.out.println(f);
    }
    System.out.println();
    //getDeclaredField():获取当前运行时类中声明的所有属性（不包含父类）
    Field[] fields1 = clazz.getDeclaredFields();
    for(Field f:fields1){
        System.out.println(f);
    }
}

获取方法

@Test
public void test1(){
    Class clazz = Person.class;
    //getMethods():获取当前运行时类及其所有父类中public修饰的方法
    Method[] methods = clazz.getMethods();
    for(Method m :methods){
        System.out.println(m);
    }
    System.out.println();
    //getDeclaredMethods():获取当前运行时类中声明的所有方法，不包含父类中的
    Method[] methods1 = clazz.getDeclaredMethods();
    for(Method m :methods1){
        System.out.println(m);
    }
}

获取其他结构

/*
获取构造器
 */
@Test
public void test1(){
    Class clazz = Person.class;
    //获取当前运行时类中public修饰的构造器
    Constructor[] constructors = clazz.getConstructors();
    for(Constructor c :constructors){
        System.out.println(c);
    }
    System.out.println();
    //获取当前运行时类的所有构造器
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    for(Constructor c:declaredConstructors){
        System.out.println(c);
    }
}
/*
获取当前运行时类的父类
 */
@Test
public void test2(){
    Class clazz = Person.class;
    Class superclass = clazz.getSuperclass();
    System.out.println(superclass);
}
/*
获取带泛型的父类
 */
@Test
public void test3(){
    Class clazz = Person.class;
    Type genericSuperclass = clazz.getGenericSuperclass();
    System.out.println(genericSuperclass);
}
/*
获取带泛型的父类的泛型
 */
@Test
public void test4(){
    Class clazz = Person.class;
    Type genericSuperclass = clazz.getGenericSuperclass();
    ParameterizedType paramType = (ParameterizedType) genericSuperclass;
    //获取泛型类型
    Type[] actualTypeArguments = paramType.getActualTypeArguments();
    System.out.println(((Class)actualTypeArguments[0]).getName());
}
/*
获取运行时类的接口
 */
@Test
public void test5(){
    Class clazz = Person.class;
    Class[] interfaces = clazz.getInterfaces();
    for(Class i : interfaces){
        System.out.println(i);
    }
    System.out.println();

    Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
    for(Class i : interfaces1){
        System.out.println(i);
    }
}
/*
获取运行时类所在的包
 */
@Test
public void test6(){
    Class clazz = Person.class;
    Package pack = clazz.getPackage();
    System.out.println(pack);
}
/*
获取运行时类的注解
 */
@Test
public void test7(){
    Class clazz = Person.class;
    Annotation[] annotations = clazz.getAnnotations();
    for(Annotation a: annotations){
        System.out.println(a);
    }
}

6 反射应用三：调用运行时类的指定结构

6.1 调用指定的属性

/*
操作属性
 */
@Test
public void testField()throws Exception{
    Class clazz = Person.class;
    //1.创建运行时类的对象
    Person p = (Person) clazz.newInstance();
    //2.获取指定名的属性：getDeclaredField(String fieldName)
    Field name = clazz.getDeclaredField("name");
    //3.将非public的结构设置为可访问的
    name.setAccessible(true);
    //4.获取、设置指定对象的属性值
    name.set(p,"Tom");
    System.out.println(name.get(p));
}

6.2 调用指定的方法

/*
获取指定的方法
 */
@Test
public void testMethod()throws Exception{
    Class clazz = Person.class;
    Person p = (Person)clazz.newInstance();

    /*
    1.获取指定的某个方法
    getDeclaredMethod():参数1，指定获取方法的名称，参数2形参列表
     */
    Method show = clazz.getDeclaredMethod("show", String.class);
    //2.保证当前方法是可访问的
    show.setAccessible(true);
    //3.使用invoke()：参数1：方法的调用者 参数2：给方法形参赋值的实参
    //invoke()的返回值就是方法的返回值
    String returnValue = (String)show.invoke(p, "China");
    System.out.println(returnValue);
    System.out.println("*****************************");
    //调用静态方法
    Method showDesc = clazz.getDeclaredMethod("showDesc");
    showDesc.setAccessible(true);
    Object returnVal = showDesc.invoke(Person.class);
    System.out.println(returnVal);
}

6.3 调用指定的构造器

/*
获取指定的构造器
 */
@Test
public void testConstructor()throws Exception{
    Class clazz = Person.class;
    //1.获取指定的构造器：参数：指明构造器的参数列表
    Constructor constructor = clazz.getDeclaredConstructor(String.class);
    //2.将该构造器设为可访问的
    constructor.setAccessible(true);
    //3.调用此构造器创建运行时类的对象
    Person p = (Person) constructor.newInstance("Tom");
    System.out.println(p);
}