oracle ebs父子请求,3、双亲委派模型详解

3. 双亲委派模型

双亲委派模式要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器，请注意双亲委派模式中的父子关系并非通常所说的类继承关系，而是采用组合关系来复用父类加载器的相关代码，类加载器间的关系如下：

image

3.1 工作流程

工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式

image

3.2 应该叫做“父委派模型”而不是“双亲委派模型”

“双亲委派”有很强的误导性，这是个翻译问题，实际上在oracle官方文档上是这样描述的：

The Java platform uses a delegation model for loading classes. The basic idea is that every class loader has a “parent” class loader. When loading a class, a class loader first “delegates” the search for the class to its parent class loader before attempting to find the class itself.

java平台通过委派模型去加载类。每个类加载器都有一个父加载器。当需要加载类时，会优先委派当前所在的类的加载器的父加载器去加载这个类。如果父加载器无法加载到这个类时，再尝试在当前所在的类的加载器中加载这个类。

所以，java的类加载机制应该叫做“父委派模型”，而不是“双亲委派机制”，“双亲委派机制”这个名字太具有误导性了。

3.3 双亲委派优势

采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。

其次是考虑到安全因素，java核心api中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。

可能你会想，如果我们在classpath路径下自定义一个名为java.lang.SingleInterge类(该类是胡编的)呢？该类并不存在java.lang中，经过双亲委托模式，传递到启动类加载器中，由于父类加载器路径下并没有该类，所以不会加载，将反向委托给子类加载器加载，最终会通过系统类加载器加载该类。但是这样做是不允许，因为java.lang是核心API包，需要访问权限，强制加载将会报出如下异常

java.lang.SecurityException: Prohibited package name: java.lang

3.4 双亲委派什么时候被破坏

通过预加载的方式;

通过Thread.getContextClassLoader();

3.4.1 预加载

这里通过一个简单的例子，就拿sql连接来说：

(1)java.sql.DriverManager：rt.jar包中的类，通过Bootstrap加载器加载。

(2)DriverTest：开发人员自定义的实现了java.sql.Driver接口的类型，通过App加载器加载。

  开发人员通过DriverManager.registerDriver方法把自己实现的获取连接的Driver实现类加载并注册到DriverManager中。然后DriverManager.getConnection方法会遍历所有注册的Driver，并触发Driver的connect接口来获取连接。(即绕过在DriverManager所在的Bootstrap加载器，因为Bootstrap加载器不能加载开发人员实现的Driver类)

定义一个 DriverTest 类，实现rt.jar里面的java.sql.Driver接口

public class DriverTest implements Driver {

static {

try {

java.sql.DriverManager.registerDriver(new DriverTest());

System.out.println("who load DriverTest: " + DriverTest.class.getClassLoader());

} catch (SQLException E) {

throw new RuntimeException("Can't register driver!");

}

}

@Override

public Connection connect(String url, Properties info) throws SQLException {

return new Connection() {

//此处省略一堆代码......

}

}

//启动代码

public static void main(String[] args) {

try {

//由AppClassLoader加载DriverTest类

Class.forName("com.jenson.pratice.classloader.DriverTest");

System.out.println("who load DriverManager: "+DriverManager.class.getClassLoader());

//通过rt.jar中的DriverManager去获取链接，DriverManager由BootstrapClassLoader加载

Connection connection = DriverManager.getConnection("jdbc://");

} catch (Exception e) {

e.printStackTrace();

}

}

}

此时运行main方法打印：

who load DriverTest: sun.misc.Launcher$AppClassLoader@18b4aac2

who load DriverManager: null

Process finished with exit code 0

---------------------

  DriverManager是由Bootstrap加载器的，因而获取不了Bootstrap加载器，所以为null。从父委派模型的机制上看，因为rt.jar是由Bootstrap加载器加载的，所以里面的类，都不能用到rt.jar以外的类。

————————————————

那么DriverManager.getConnection是怎么调用DriverTest(App加载器)的getConnection方法呢？

因为父委派模型的限制，DriverManager不可能自己去加载DriverTest，DriverTest的加载实际上是由AppClassLoader完成的，DriverTest里面会往

DriverManager中注册一个驱动。

public class DriverTest implements java.sql.Driver {

static {

try {

//在这里注册

java.sql.DriverManager.registerDriver(new DriverTest());

} catch (SQLException E) {

throw new RuntimeException("Can't register driver!");

}

}

}

对于DriverManager而言，他不关注driver的加载，他只需要遍历“registeredDrivers”，然后检查驱动类是否能被“调用类的类加载器”识别，如果可以识别，则调用driver.connect方法(即DriverTest中的实现)

public class DriverManager{

private static Connection getConnection(

String url, java.util.Properties info, Class> caller) throws SQLException {

//省略一堆代码

for(DriverInfo aDriver : registeredDrivers) {

//在这里做安全校验

if(isDriverAllowed(aDriver.driver, callerCL)) {

try {

println(" trying " + aDriver.driver.getClass().getName());

//在这里调用DriverTest的connect方法

Connection con = aDriver.driver.connect(url, info);

if (con != null) {

// Success!

println("getConnection returning " + aDriver.driver.getClass().getName());

return (con);

}

} catch (SQLException ex) {

if (reason == null) {

reason = ex;

}

}

//省略一堆代码

整体的流程是这样的

image

3.4.2 Thread.getContextClassLoader()

1.通过调用Thread.getContextClassLoader()相当于直接拿到类加载器，自然不必通过向上递归走双亲委派了。

2.举个例子：rt.jar中的 javax.xml.parsers.FactoryFinder 中的 newInstance方法：

(1)在newInstance中会用到 getProviderClass 方法

(2)在getProviderClass中会用到 SecuritySupport.getContextClassLoader方法

(3)在SecuritySupport.getContextClassLoader中会用到Thread.currentThread().getContextClassLoader()拿到线程上下文类加载器

/**

* Create an instance of a class. Delegates to method

* getProviderClass() in order to load the class.

*

* 定义的JNDI接口

* @param type Base class / Service interface of the factory to instantiate

* JNDI的实现类名

* @param className Name of the concrete class corresponding to the service provider

* 加载器：如果为null，则通过线程的上下文加载器进行加载

* @param cl ClassLoader used to load the factory class. If null

* current Thread's context classLoader is used to load the factory class.

* 如果为true，则使用bootstrap加载器。

* @param useBSClsLoader True if cl=null actually meant bootstrap classLoader. This parameter

* is needed since DocumentBuilderFactory/SAXParserFactory defined null as context classLoader.

*/

static T newInstance(Class type, String className, ClassLoader cl,

boolean doFallback, boolean useBSClsLoader)

throws FactoryConfigurationError

{

//省略一堆代码

try {

//在这个方法里面，可以通过线程上下文加载器进行加载className对应的类

Class> providerClass = getProviderClass(className, cl, doFallback, useBSClsLoader);

//省略一堆代码

}

}

static private Class> getProviderClass(String className, ClassLoader cl,

boolean doFallback, boolean useBSClsLoader) throws ClassNotFoundException

{

try {

if (cl == null) {

if (useBSClsLoader) {

return Class.forName(className, false, FactoryFinder.class.getClassLoader());

} else {

//在这里，会获得线程的上下文加载器去加载类

//其中 ss是 SecuritySupport.java

cl = ss.getContextClassLoader();

if (cl == null) {

throw new ClassNotFoundException();

}

else {

return Class.forName(className, false, cl);

}

}

}

//省略一堆代码

}

class SecuritySupport {

ClassLoader getContextClassLoader() throws SecurityException{

return (ClassLoader)

AccessController.doPrivileged(new PrivilegedAction() {

public Object run() {

ClassLoader cl = null;

//try {

//获得线程的上下文加载器

cl = Thread.currentThread().getContextClassLoader();

//} catch (SecurityException ex) { }

if (cl == null)

cl = ClassLoader.getSystemClassLoader();

return cl;

}

});

}

3.5 tomcat的类加载机制

不只是Driver驱动的实现是这样，在tomcat、spring等等的容器框架也是通过一些手段去绕过“父委派机制”。例如下图中的tomat类加载器的结构：

image

从图中的委派关系中可以看出：

CommonClassLoader能加载的类都可以被Catalina - - - ClassLoader和SharedClassLoader使用，从而实现了公有类库的共用。

CatalinaClassLoader和Shared ClassLoader自己能加载的类则与对方相互隔离。

WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader实例之间相互隔离。

JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JasperLoader的实例，并通过再建立一个新的Jsp类加载器来实现JSP文件的HotSwap功能。

tomcat 违背了父委派模型吗？

tomcat 违背了父委派模型。因为双亲委派模型要求除了顶层的启动类加载器之外，其余的类加载器都应当由自己的父类加载器加载。

而tomcat 不是这样实现，tomcat 为了实现隔离性，没有遵守这个约定，每个webappClassLoader加载自己的目录下的class文件，不会传递给父类加载器。