Java SE —— 反射

1. 概述

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

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

# 动态语言 vs 静态语言
- 动态语言
是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。
通俗点说就是在运行时代码可以根据某些条件改变自身结构。 主要动态语言:Object-C、C#、JavaScript、PHP、Python、Erlang。

- 静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、 C++。

Java不是动态语言，但 Java 可以称之为“准动态语言”。即 Java 有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活!

2. 作用

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

# 通过直接 new 的方式或反射的方式都可以调用公共的结构，开发中到底用哪个？
建议：new 方式
当我们不知道要造什么对象，用什么方法的时候，需要利用反射的动态性，如接口映射（login 或 register）。

# 反射机制与面向对象中的封装性是否有矛盾？如何看待这两个技术？
不矛盾。

对于封装性我们 设计一个类的时候，属性、方法、构造器等等，该私有的时候私有(private)，该公共的时候公共(public)。
封装性给我们的启示是：当我们看到一个类写了一些私有的方法，一些公共的方法时就告诉我们私有的方法就不要用了，就用公共的方法就可以了。因为私有的方法可能类内部用了。这里体现了封装性。比如单例模式，你要想造对象就不要用私有的构造器了，我已经把对象造好了直接用就行。

反射告诉我们可以调，但是不建议调私有的方法，因为可能公共的方法更好，加了一些逻辑。

封装性解决的是：建议调哪个的问题。
反射解决的是：能不能调的问题。

3. Class 类

3.1 介绍

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

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

3.2 常用方法

3.3 获取 Class 实例的四种方式

[类.class]

前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠， 程序性能最高。

Class clazz = String.class;

[实例.getClass()]

前提：已知某个类的实例，调用该实例的 getClass() 方法获取 Class 对象。

Class clazz = "person".getClass();

[Class.forName(全限定类名)]

前提：已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法 forName() 获取，可能抛出 ClassNotFoundException。

Class clazz = Class.forName("java.lang.String");

[类加载器]

ClassLoader cl = this.getClass().getClassLoader();
Class clazz = cl.loadClass("全限定类名")

3.4 哪些类型可以有 Class 对象

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

4. 类的加载过程

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

加载

程序经过 javac.exe 命令后，会生成一个或多个字节码文件（.class 结尾）。

接着我们使用 java.exe 命令对某个字节码文件进行解析运行，就相当于将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口(即引用地址)。所有需要访问和使用类数据只能通过这个 Class 对象。这个加载的过程需要类加载器参与。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类。

链接

将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。

• 验证

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

• 准备

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

• 解析

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

初始化

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

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

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

public class ClassLoadingTest {
    public static void main(String[] args) {
				System.out.println(A.m); 
    }
}
class A {
    static {
				m = 300; 
    }
		static int m = 100; 
}
//第二步：链接结束后m=0
//第三步：初始化后，m的值由<clinit>()方法执行决定
// 			这个A的类构造器<clinit>()方法由类变量的赋值和静态代码块中的语句按照顺序合并 产生，类似于
//			<clinit>(){
//    		m = 300;
//    		m = 100;
// 			}

# 什么时候会发生类初始化？
类的主动引用（一定会发生类的初始化）
1. 当虚拟机启动，先初始化 main() 方法所在的类
2. new 一个类的对象
3. 调用类的静态成员（除了 final 常量）和静态方法
4. 使用 java.lang.reflect 包的方法对类进行反射调用
5. 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动引用（不会发生类的初始化）
1. 当访问一个静态域时，只有真正声明这个域的类才会被初始化
		当通过子类引用父类的静态变量，不会导致子类初始化
2. 通过数组定义类引用，不会触发此类的初始化
3. 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

举例：定义一个 Father 类，然后 A 继承 Father：

class Father {
    static int b = 2;
    static {
				System.out.println("父类被加载"); 
    }
}
class A extends Father {
    static {
				System.out.println("子类被加载");
				m = 300; 
    }
    static int m = 100;
		static final int M = 1; 
}

测试类：

public class ClassLoadingTest {
  	// main() 方法主动引用
		public static void main(String[] args) { 
      	//主动引用
        A a = new A();
      	//主动引用
        System.out.println(A.m);
        //主动引用
        Class.forName("com.hedon.A");
        //被动引用
				A[] array = new A[5];//不会导致 A 和 Father 的初始化
      	//被动引用
				System.out.println(A.b);//只会初始化 Father
      	//被动引用
        System.out.println(A.M);//不会导致 A 和 Father 的初始化
      
      	static{
          	System.out.println("main() 方法所在的类");
        }
		} 
}

5. 类加载器

5.1 类加载器的作用

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

5.2 类缓存

标准的 JavaSE 类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。

不过JVM垃圾回收机制可以回收这些 Class 对象。

5.3 ClassLoader

//当前类的类加载器 —— 系统加载器
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println("当前类的类加载器：" + classLoader);
//上一层 —— 拓展加载器
ClassLoader classLoader1 = classLoader.getParent();
System.out.println("上一层：" + classLoader1);
//再上一层 —— 引导类加载器
ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2);  //null,但不是没有，而是我们获取不到

6. 动态代理

6.1 JDK 动态代理 —— 有接口的情况

6.1.1 原理示意图

• 创建==接口实现类==代理对象，增强类的方法

  

6.1.2 代码实现

6.1.2.1 重要类及方法 —— Proxy.newProxyInstance()

三个参数：

• loader：类加载器
• interfaces：增强方法所在的类，这个类实现的接口，支持多个接口
• h：实现接口 InvocationHandler，创建代理对象，写增强的方法

6.1.2.2 创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

6.1.2.3 创建接口实现类

public class UserDaoImpl implements UserDao {

    @Override
    public int add(int a, int b) {
        System.out.println("add 方法执行了....");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("update 方法执行了....");
        return id;
    }
}

6.1.2.4 使用 Proxy 类创建代理对象

public class JDKProxy {

    public static void main(String[] args) {

        //创建接口实现类代理对象

        //第②个参数
        Class[] interfaces = {UserDao.class};

        //被代理对象
        UserDaoImpl userDao = new UserDaoImpl();

        //增强后的对象
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

        //调用增强后的方法
        int add = dao.add(1, 2);

        //输出结果
        System.out.println(add);

    }
}

//第③个参数
class UserDaoProxy implements InvocationHandler{

    //需要把对象传到这里面来，才能执行原先方法的功能，再在此基础上添加新的功能 =》 把被代理对象传到代理类中
    //可以通过有参构造进行传递
    private Object object;
    public UserDaoProxy(Object object){
        this.object = object;
    }

    //方法增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法之前
        System.out.println("方法之前执行...."+method.getName()+"，传递的参数："+ Arrays.toString(args));

        //被增强的方法执行
        Object res = method.invoke(object, args);

        //方法之后
        System.out.println("方法之后执行...."+object);

        return res;
    }
}

输出结果：

方法之前执行....add，传递的参数：[1, 2]
add 方法执行了....
方法之后执行....com.hedon.UserDaoImpl@5a07e868
3

Process finished with exit code 0

补充：可以用 method.getName() 来获取方法名，来决定具体增强哪些方法。

6.2 CGLIB 动态代理 —— 无接口的情况

6.2.1 原理示意图

• 创建==子类==的代理对象，增强类的方法