Java反射

何为反射
双亲委派机制
打破双亲委派机制
SPI

何为反射

在Java中，如果想动态获取一个运行时的类信息如属性、方法等，你会想到何种方法呢？

方法之一，就是运用本文想要阐述的反射机制了。在编写代码的时候，有时在引用第三方类又或者作为一个公共服务给外界使用时，有些属性、方法等信息在编译阶段并不能获取到，需要在运行时才能确定下来。这种机制又叫做RTTI （Run-Time Type Identification，运行时类型识别），而实现这个机制的过程又可以称为反射。

例如我们的JDBC，作为Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，它并不知道我们想使用它来连接哪种类型的数据库，是H2还是MySQL，又或是Oracle...

只有等到运行时，我们通过Class.forName加载具体的驱动，才能知道连接的是哪种具体类型的库。

cpp 复制代码

// 连接库表
Class.forName(driver);
Connection conn = DriverManager.getConnection(url, user, password);

之前我们分析过Java的类加载机制，而反射能起作用的原理其实就是利用class类文件加载进JVM后，类信息对于JVM来说是透明的，而保存这些运行时的信息是有一个专门的Class类的，通过获取该Class类对象，我们达到获取类信息的目的。即利用类加载器加载目标类，生成对应的Class对象，从而达到反射的目的。

cpp 复制代码

Class c = Class.forName("com.company.C"); // 加载C类
Object o = c.newInstance(); // 创建实例
Method method = o.getClass().getDeclaredMethod("test"); // 获取一个叫test的方法
System.out.println( method.invoke(o, null)); // 执行

双亲委派机制

首相将一个.class类文件加载进JVM时是需要我们的类加载器 的。而类加载器再加载某个class类文件时，并不会立刻就执行，而是把它委托给上一级别的类加载器。递归上述的过程，直到顶层的BootstrapClassLoader，如果这时还没有加载过，则考虑自己是否能够加载，不能的话就不断下沉到子加载器，递归这个操作，如果都不能加载，抛出ClassNotFoundException。上述机制即为双亲委派。

其作用如下：

防止重复加载同一个.class。
保证核心类不能被篡改。

打破双亲委派机制

首先，我们要要知道Java种提供如下几种类加载器：

BootstrapClassLoader（启动类加载器）C++编写，构造ExtClassLoader和AppClassLoader。
ExtClassLoader （标准扩展类加载器）java编写，加载扩展库。
AppClassLoader（系统类加载器）java编写，加载程序所在的目录。
CustomClassLoader（用户自定义类加载器）java编写,用户自定义的类加载器,可加载指定路径的class文件，

即然要打破双亲委派机制，那我们需要事先知道双亲委派机制是在哪里运行的。如下，通过分析ClassLoad源码种的loadClass方法，我们可以知道双亲委派的流程。

cpp 复制代码

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                    // 递归
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

现在我们既然要打破双亲委派，那我们可以考虑覆盖这个方法勒！由于Java支持CustomClassLoader（用户自定义类加载器），那不妨写一个自定义类加载器，通过继承ClassLoader ，重写loadClass方法，将自己的目标类用自己的加载器加载，其他的则还是走双亲委派的方式。

cpp 复制代码

 protected Class<?> loadClass(String name, boolean resolve)
                throws ClassNotFoundException
        {
            synchronized (flag) {
                // 尝试加载
                Class<?> c = findLoadedClass(name);
                if ("目标类名称".equals(name)){
     			 c = findClass(name);
			 }else{
     			// 交由父加载器去加载
     			 c = this.getParent().loadClass(name);
 			  }
                return c;
            }
        }

SPI

SPI（Service provider interface），即服务提供发现接口。其实个人理解就是一种编码规范，在此规范之下，我们可以灵活设计一个可插拔的组件。譬如JDBC4.0之后，就支持了SPI方式来加载java.sql.Driver的实现类。

根据规范，我们只需要定义一个接口（譬如Test接口，带有一个test方法），具体的实现可以交给不同的"厂商"（它们都需要实现这个接口）。接着我们只需要利用ServiceLoader类进行加载，就能执行"厂商"们具体实现的方法（test）了。

而"厂商"的职责除去对接口进行实现，还需要在resources目录下新建一个 META-INF/services/目录，并创建一个以接口的全限定名为名称的文件，内容为实现类的全限定名。（发射创建具体实现对象时需要用到）

关于SPI打破双亲委派机制，首先我们需要了解一下双亲委派机制的可见性原则：假定 A 作为 B 的父加载器，A 加载的类对 B 是可见的；然而 B 加载的类对 A 却是不可见的。

而在SPI种，却可以打破这一原则。以java.sql.Driver 为例子，java.sql.DriverManager （启动类加载器进行加载）通过扫包的方式拿到指定的实现类（系统应用类加载器加载的实现类），完成DriverManager的初始化。

而要做到上述这点，Java也提供了两种方式（其实双亲委派模型并非强制模型）。

Thread.currentThread().getContextClassLoader()
ClassLoader.getSystemClassLoader()

而SPI中，使用的是第一种方式。通过从线程上下文（ThreadContext）获取 classloader ，借助这个classloader 可以拿到实现类的 Class。

cpp 复制代码

public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }