关于 Java 类加载器的这一点，市面上没有任何一本图书讲到

一、一个程序员的思考

大家都知道，Tomcat 处理业务，靠什么？最终是靠我们自己编写的 Servlet。你可能说你不写 servlet，你用 spring MVC，那也是人家帮你写好了，你只需要配置就行。在这里，有一个边界，Tomcat 算容器，容器的相关 jar 包都放在它自己的 安装目录的 lib 下面； 我们呢，算是业务，算是webapp，我们的 servlet ，不管是自定义的，还是 spring mvc 的DispatcherServlet，都是放在我们的 war 包里面 WEB-INF/lib下。 看过前面文章的同学是晓得的， 这二者是由不同的类加载器加载的。在 Tomcat 的实现中，会委托 webappclassloader 去加载WAR 包中的 servlet ，然后 反射生成对应的 servlet。后续有请求来了，调用生成的 servlet 的 service 方法即可。

在 org.apache.catalina.core.StandardWrapper#loadServlet 中，即负责 生成 servlet：

org.apache.catalina.core.DefaultInstanceManager#newInstance(java.lang.String)
@Override
public Object newInstance(String className) throws IllegalAccessException, InvocationTargetException, NamingException, InstantiationException, ClassNotFoundException {
Class<?> clazz = loadClassMaybePrivileged(className, classLoader);
return newInstance(clazz.newInstance(), clazz);
}

在上图中，会利用 instanceManager 根据参数中指定的 servletClass 去生成 servlet 实例。newInstance 代码如下，主要就是用 当前 context 的classloader 去加载 该 servlet，然后 反射生成 servlet 对象。

我们重点关注的是那个红框圈出的强转：为什么由 webappclassloader 加载的对象，可以转换 为 Tomcat common classloader 加载的 Servlet 呢？ 按理说，两个不同的类加载器加载的类都是互相隔离的啊，不应该抛一个 ClassCastException 吗？说真的，我翻了不少书，从来没提到这个，就连网上也很含糊。

再来一个，关于SPI的问题。  在 SPI 中，主要是由 java 社区指定规范，比如 JDBC，厂家有那么多，mysql，oracle，postgre，大家都有自己的 jar包，要是没有 JDBC 规范，我们估计就得针对各个厂家的实现类编程了，那迁移就麻烦了，你针对 mysql 数据库写的代码，换成 oracle 的话，代码不改是肯定不能跑的。所以， JCP组织制定了 JDBC 规范，JDBC 规范中指定了一堆的 接口，我们平时开发，只需要针对接口来编程，而实现怎么办，交给各厂家呗，由厂家来实现 JDBC 规范。这里以代码举例，oracle.jdbc.OracleDriver 实现了 java.sql.Driver，同时，在 oracle.jdbc.OracleDriver 的 static 初始化块中，有下面的代码：

static {
try {
if (defaultDriver == null) {
defaultDriver = new oracle.jdbc.OracleDriver();
DriverManager.registerDriver(defaultDriver);
}
// 省略
}

其中，标红这句，就是 Oracle Driver 要向 JDBC 接口注册自己，java.sql.DriverManager#registerDriver(java.sql.Driver)的实现如下：

java.sql.DriverManager#registerDriver(java.sql.Driver)

public static synchronized void registerDriver(java.sql.Driver driver)
throws SQLException {

registerDriver(driver, null);
}

可以看到，registerDriver(java.sql.Driver) 方法的参数为 java.sql.Driver，而我们传的参数为 oracle.jdbc.OracleDriver 类型，这两个类型，分别由不同的类加载器加载（java.sql.Driver 由 jdk 的 启动类加载器加载，而 oracle.jdbc.OracleDriver ，如果为 web应用，则为 tomcat 的 webappclassloader 来加载，不管怎么说，反正不是由 jdk 加载的），这样的两个类型，连 类加载器都不一样，怎么就能正常转换呢，为啥不抛 ClassCastException？

二、不同类加载器加载的类，可以转换的关键

经过上面两个例子的观察，不知道大家发现没， 我们都是把一个实现，转换为一个接口。也许，这就是问题的关键。我们可以大胆地推测，基于类的双亲委派机制，在 加载 实现类的时候，jvm 遇到 实现类中引用到的其他类，也会触发加载，加载的过程中，会触发 loadClass，比如，加载 webappclassloader 在 加载 oracle.jdbc.OracleDriver 时，触发加载 java.sql.Driver，但是 webappclassloader 明显是不能去加载 java.sql.Driver 的，于是会委托给 jdk 的类加载，所以，最终，oracle.jdbc.OracleDriver 中 引用的 java.sql.Driver ，其实就是由 jdk 的类加载器去加载的。 而 registerDriver(java.sql.Driver driver) 中的 driver 参数的类型 java.sql.Driver 也是由 jdk 的类加载器去加载的，二者相同，所以自然可以相互转换。

这里总结一句（不一定对），在同时满足以下几个条件的情况下：

• 前置条件1、接口 jar包 中，定义一个接口 Test

• 前置条件2、实现 jar 包中，定义 Test 的实现类，比如 TestImpl。（但是不要在该类中包含该 接口，你说没法编译，那就把接口 jar包放到 classpath）

• 前置条件3、接口 jar 包由 interface_classLoader 加载，实现 jar 包 由 impl_classloader 加载，其中 impl_classloader 会在自己无法加载时，委派给 interface_classLoader

则，定义在 实现jar 中的Test 接口的实现类，反射生成的对象，可以转换为 Test 类型。

猜测说完了，就是求证过程。

三、求证

1、定义接口 jar

D:\classloader_interface\ITestSample.java

/**
* desc:
*
* @author :
* creat_date: 2019/6/16 0016
* creat_time: 19:28
**/
public interface ITestSample {
}

cmd下，执行：

D:\classloader_interface>javac ITestSample.java
D:\classloader_interface>jar cvf interface.jar ITestSample.class
已添加清单
正在添加: ITestSample.class(输入 = 103) (输出 = 86)(压缩了 16%)

此时，即可在当前目录下，生成 名为 interface.jar 的接口jar包。

2、定义接口的实现 jar

在不同目录下，新建了一个实现类。

D:\classloader_impl\TestSampleImpl.java

/**
* Created by Administrator on 2019/6/25.
*/
public class TestSampleImpl implements  ITestSample{

}

编译，打包：

D:\classloader_impl>javac -cp D:\classloader_interface\interface.jar TestSampleI
mpl.java

D:\classloader_impl>jar -cvf impl.jar TestSampleImpl.class
已添加清单
正在添加: TestSampleImpl.class(输入 = 221) (输出 = 176)(压缩了 20%)

请注意上面的标红行，不加编译不过。

3、测试

测试的思路是，用一个urlclassloader 去加载 interface.jar 中的 ITestSample，用另外一个 URLClassLoader 去加载 impl.jar 中的 TestSampleImpl ，然后用java.lang.Class#isAssignableFrom 判断后者是否能转成前者。

import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

/**
* desc:
*
* @author : caokunliang
* creat_date: 2019/6/14 0014
* creat_time: 17:04
**/
public class MainTest {

public static void testInterfaceByOneAndImplByAnother()throws Exception{
URL url = new URL("file:D:\\classloader_interface\\interface.jar");
URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url});
Class<?> iTestSampleClass = urlClassLoader.loadClass("ITestSample");

URL implUrl = new URL("file:D:\\classloader_impl\\impl.jar");
URLClassLoader implUrlClassLoader = new URLClassLoader(new URL[]{implUrl}, urlClassLoader);
Class<?> testSampleImplClass = implUrlClassLoader.loadClass("TestSampleImpl");

System.out.println("实现类能转否？："  + iTestSampleClass.isAssignableFrom(testSampleImplClass));

}

public static void main(String[] args) throws Exception {
testInterfaceByOneAndImplByAnother();
}

}

打印如下：

4、延伸测试1

如果我们做如下改动，你猜会怎样？ 这里的主要差别是：

改之前，urlClassloader 作为 parentClassloader：

URLClassLoader implUrlClassLoader = new URLClassLoader(new URL[]{implUrl}, urlClassLoader);

改之后，不传，默认会以 jdk 的应用类加载器作为 parent：

URLClassLoader implUrlClassLoader = new URLClassLoader(new URL[]{implUrl});

打印结果是：

Exception in thread "main" java.lang.NoClassDefFoundError: ITestSample
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:760)
at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
at java.net.URLClassLoader.defineClass(URLClassLoader.java:455)
at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
at java.net.URLClassLoader$1.run(URLClassLoader.java:367)
at java.net.URLClassLoader$1.run(URLClassLoader.java:361)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:360)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
at MainTest.testInterfaceByOneAndImplByAnother(MainTest.java:23)
at MainTest.main(MainTest.java:33)
Caused by: java.lang.ClassNotFoundException: ITestSample
at java.net.URLClassLoader$1.run(URLClassLoader.java:372)
at java.net.URLClassLoader$1.run(URLClassLoader.java:361)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:360)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
... 13 more

结果就是，第23行，Class<?> testSampleImplClass = implUrlClassLoader.loadClass("TestSampleImpl"); 这里报错了，提示找不到 ITestSample。

这就是因为，在加载了 implUrlClassLoader 后，触发了对 ITestSample 的隐式加载，这个隐式加载会用哪个加载器去加载呢，没有默认指明的情况下，就是用当前的类加载器，而当前类加载器就是 implUrlClassLoader ，但是这个类加载器开始加载 ITestSample 573 ，它是遵循双亲委派的，它的parent 加载器 即为 appclassloader，（jdk的默认应用类加载器），但appclassloader 根本不能加载 ITestSample，于是还是还给 implUrlClassLoader ，但是 implUrlClassLoader 也不能加载，于是抛出异常。

5、延伸测试2

我们再做一个改动， 改动处和上一个测试一样，只是这次，我们传入了一个特别的类加载器，作为其 parentClassLoader。 它的特殊之处在于，almostSameUrlClassLoader 和 前面加载 interface.jar 的类加载器一模一样，只是是一个新的实例。

URLClassLoader almostSameUrlClassLoader = new URLClassLoader(new URL[]{url});
URLClassLoader implUrlClassLoader = new URLClassLoader(new URL[]{implUrl}, almostSameUrlClassLoader);

这次，看看结果吧，也许你猜到了？

这次没报错了，毕竟 almostSameUrlClassLoader 知道去哪里加载 ITestSample，但是，最后的结果显示，实现类的 class 并不能 转成 ITestSamp 281d le。

6、延伸测试3

说实话，有些同学可能对 java.lang.Class#isAssignableFrom 不是很熟悉，我们换个你更不熟悉的，如何？

URL implUrl = new URL("file:D:\\classloader_impl\\impl.jar");
URLClassLoader almostSameUrlClassLoader = new URLClassLoader(new URL[]{url});
URLClassLoader implUrlClassLoader = new URLClassLoader(new URL[]{implUrl}, almostSameUrlClassLoader);
Class<?> testSampleImplClass = implUrlClassLoader.loadClass("TestSampleImpl");
Object o = testSampleImplClass.newInstance();
Object cast = iTestSampleClass.cast(o); // 将 o 转成 接口的那个类
System.out.println(cast);

结果：

如果换成下面这样，就没啥问题：

URL implUrl = new URL("file:D:\\classloader_impl\\impl.jar");
URLClassLoader almostSameUrlClassLoader = new URLClassLoader(new URL[]{url});
URLClassLoader implUrlClassLoader = new URLClassLoader(new URL[]{implUrl}, urlClassLoader);
Class<?> testSampleImplClass = implUrlClassLoader.loadClass("TestSampleImpl");
Object o = testSampleImplClass.newInstance();
Object cast = iTestSampleClass.cast(o);
System.out.println(cast);

执行：