Java SE 宋红康 days04-高级篇-反射

1. 需要掌握的点：

　　① 理解 Class 类并获取 Class 实例；

　　② 创建运行时类的对象；

　　③ 调用运行时类的指定结构；

2. 反射（Reflection）

　　正常方式：引入需要的“包类”的名称 ----> 通过 new 实例化 ----> 取得实例化对象

　　反射方式：实例化对象 ----> getClass() 方法 ----> 得到完整的“包类”名称

　　2.1 被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息；

　　　   并能直接操作任意对象的内部属性及方法。

　　2.2 加载完类之后，在堆内存的方法区中会产生Class类型的对象，这个对象就包含了完整的类的结构信息；

　　　   可以通过这个对象看到类的结构。（一个类对应一个Class对象）

3. Java反射机制提供的功能

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

4. 主要涉及的API

• 　　java.lang.Class：代表一个类
• 　　java.lang.reflet.Method：代表类的方法
• 　　java.lang.reflet.Field：代表类的成员变量
• 　　java.lang.reflet.Constructor：代表类的构造器

5. 关于 java.lang.Class 类的理解 

　　① 类的加载过程（8 有详细过程）：

　　　　程序警告javac.exe命令以后，会生成一个或多个字节码文件（.class结尾），接着我们使用java.exe命令对某个字节码文件进行解释运行；

　　　　相当于将某个字节码文件加载到内存中，这个过程叫类的加载；

　　　　加载到内存中的类，我们称为运行时类，此运行时类，就作为 Class 的一个实例。

　　② 言外之意，Class 的实例就对应着一个运行时类；

　　③ 加载到内存中的运行时类，会缓存一定的时间，在此事件之内，可以通过不同的方式来获取此运行类；

 6. 获取 Class 实例的4种方式（前三种掌握）

@Test
public void test3() throws Exception {
    // 方式一：调用运行时类的属性：.class
    Class<Person> clazz1 = Person.class;
    // 方式二：通过运行时类的对象，调用.getClass()方法
    Person p1 = new Person();
    Class clazz2 = p1.getClass();
    // 方式三：调用 Class 的静态方法：forName(String classPath)
    Class clazz3 = Class.forName("learning.practise.SGG.Person");
    // 方式四：使用类的加载器：ClassLoader
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    Class clazz4 = classLoader.loadClass("learning.practise.SGG.Person");
    System.out.println(clazz1 + "\n" + clazz2 + "\n" + clazz3 + "\n" + clazz4);
}

7. 哪些类型可以有 Class 对象

• 　　class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
• 　　interface：接口
• 　　[ ]：数组
• 　　enum：枚举
• 　　annotation：注解@interface
• 　　primitive type：基本数据类型
• 　　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;// void
Class c9 = Class.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);

8. 类的加载过程

　　当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过下面三个步骤对类进行初始化：

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

　　　　　　将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构；

　　　　　　然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。

　　　　　　所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

　　　　② 类的链接（Link）：将类的二进制数据合并到 JRE 中；

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

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

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

　　　　③ 类的初始化（Initialize）：JVM 负责对类进行初始化；　　　　　　

 　　　　　　执行类构造器的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。

　　　　　　　　（类构造器是构造类信息的，不是构造该类对象的构造器）。

　　　　　　当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

　　　　　　虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

9. 类的加载与ClassLoader

 　类加载器的作用：

　　　　类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构；

　　　　　　　　　　　然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

　　　　类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中；

　　　　　　　　它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

 　　

 

 

　　类加载器的分类及注意：

 　　　　对于自定义类，使用系统类加载器进行加载；

　　　　调用系统类加载器的getParent()：获取扩展类加载器；

　　　　调用扩展类加载器的getParent()：无法获取引导类加载器；引导类加载器主要负责加载java核心类库，无法加载自定义类；

10. 创建运行时类的对象

　　Class.newInstance()：调用此方法，创建对应的运行时类的对象；

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

　　　　① 运行时类必须提供无参构造器；

　　　　② 无参构造器的访问权限得够，通常设置为 public；

　　在 javabean 中要求提供一个 public 的无参构造器，原因：

　　　　① 便于通过反射，创建运行时类的对象；

　　　　② 便于子类继承此运行时类，默认调用 super() 时，保证父类有此构造器；

11. 获取运行时类的属性结构及其内部结构

　　Class.getFields()：获取当前运行时类及其父类中声明为 public 访问权限的属性；

　　Class.getdeclareFields：获取当前运行类当中所有属性（不包含父类，不考虑权限）；

　　　　获取属性后，可以用以下三个方法获取不同的对象：

　　　　　　Field.getModifiers()：获取权限修饰符

　　　　　　Field.getType()：获取数据类型

　　　　　　Field.getName()：获取变量名

---

　　Class.getMethods()：获取当前运行时类及其父类中声明为 public 访问权限的方法；

　　Class.getdeclareMethods：获取当前运行类当中所有方法（不包含父类，不考虑权限）；

　　　　获取方法后，可以用以下几种方法获取不同的部分：

Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method method : declaredMethods) {
    // 1. 获取方法声明的注释
    Annotation[] annos = method.getAnnotations();
    for (Annotation a : annos) {
        System.out.println(a);
    }
    // 2. 权限修饰符
    System.out.println(Modifier.toString(method.getModifiers()));
    // 3. 返回值类型
    System.out.println(method.getReturnType().getName() + "\t");
    // 4. 方法名
    System.out.println(method.getName() + "\t");
    // 5. 形参列表
    Class<?>[] parameterTypes = method.getParameterTypes();
    if ( !(parameterTypes == null && parameterTypes.length == 0)) {
        for (int i = 0; i < parameterTypes.length; i++) {
            System.out.println(parameterTypes[i].getName() + "args_" + i);
        }
    }
    // 6. 抛出的异常
    Class[] exceptionTypes = method.getExceptionTypes();
    if (!(exceptionTypes == null && exceptionTypes.length == 0)) {
        for (int i = 0; i < exceptionTypes.length; i++) {
            System.out.println(exceptionTypes[i].getName() + "args_" + i);
        }
    }
}

---

　　Class.getConstructors()：获取当前运行时类中声明为 public 的构造器；

　　Class.getdeclareConstructors()：获取当前运行类当中所有的构造器（不包含父类，不考虑权限）；

　　Class.getSuperclass()：获取运行时类的父类；Clazz superclass = clazz.getSuperclass()；

　　Class.getGenericSuperclass()：获取运行时类的带泛型的父类；Type genericSuperclass = clazz.getGenericSuperclass()；

　　获取运行时类的带泛型的父类的泛型：

　　　　　ParameterizedType  paramType  =  (ParameterizedType )  clazz.getgetGenericSuperclass；

　　　　　Type[ ]  actualTypeArguments  =  paramType.getActualTypeArguments()；// 获取泛型类型

---

12. 获取运行时类的接口（动态代理中会用到）、所在包、注解（框架里用的多）等

Class clazz = Person.class;
// 获取运行时类的接口
Class[] interfaces = clazz.getInterfaces();
for (Class c : interfaces) {
    System.out.println(c);
}
// 获取运行时类的父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for (Class c : interfaces1) {
    System.out.println(c);
}

// 获取运行时类所在的包
Package pack = clazz.getPackage();
System.out.println(pack);
// 获取运行时类声明的注解
Annotation[] annotations = clazz.getAnnotations();
for (Annotation anno : annotations) {
    System.out.println(anno);
}

13. 调用运行时类中指定属性

Class clazz = Person.class;
// 方法一 掌握
// 创建运行时类的对象
Object p = clazz.newInstance();
// 获取运行时类中指定变量名的属性
Field name = clazz.getDeclaredField("name");// 有可能是非静态的属性，要依托于对象，所以先创建对象
// 保证当前属性是可访问的
name.setAccessible(true);
// 设置当前属性的值
// set()：参数1 指明设置那个对象的属性，参数2 将此属性值设置为多少
name.set(p, "1001");
// 获取当前属性的值
// get()：参数1 获取那个对象的当前属性值
int pid = (int) name.get(p);



// 此方法通常不用，因为只能获取public权限的
// 创建运行时类的对象
Object p = clazz.newInstance();
// 获取指定的属性：要求运行时类中的属性声明为public
Field id = clazz.getField("id");// 有可能是非静态的属性，要依托于对象，所以先创建对象
// 设置当前属性的值
// set()：参数1 指明设置那个对象的属性，参数2 将此属性值设置为多少
id.set(p, 1001);
// 获取当前属性的值
// get()：参数1 获取那个对象的当前属性值
int pid = (int) id.get(p);

14. 调用运行时类中指定方法

Class clazz = Person.class;
// 创建运行时类的对象
Object p = clazz.newInstance();
// 1. 获取指定的某个方法
// getDeclaredMethod()：参数1 指明获取方法的名称；参数2 指明获取方法的形参列表
Method show = clazz.getDeclaredMethod("show", String.class);
// 2. 保证当前方法是可访问的
show.setAccessible(true);
// 3. 调用方法的 invoke()：参数1 方法调用者；方法2 给方法形参赋值的实参
// invoke()的返回值即为对应类中调用方法的返回值
Object returnValue   = show.invoke(p, "CHN");
System.out.println(returnValue);
/*******************************************************/
// 如何调用静态方法？
Method showDesc = clazz.getDeclaredMethod("showDesc");
showDesc.setAccessible(true);
// 如果调用的运行时类中的方法没有返回值，则此invoke()返回null
//Object returnVal = showDesc.invoke(Person.class);
Object returnVal = showDesc.invoke(null);
System.out.println(returnVal);// null

15. 调用运行时类中指定构造器

Class clazz = Person.class;
// 1. 获取指定的构造器
// getDeclaredConstructor()：参数 指明构造器的参数列表，无参用 类.class
Constructor constructor = clazz.getDeclaredConstructor(String.class);
// 2. 保证此构造器是可访问的
constructor.setAccessible(true);
// 3. 调用此构造器创建运行时类的对象
Person per = (Person) constructor.newInstance("Tom");
System.out.println(per);

16. 动态代理-反射应用

 　　AOP（Aspect Orient Programming）