五个经典的破坏双亲委派场景,Java被啪啪打脸
Posted 编程一生
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了五个经典的破坏双亲委派场景,Java被啪啪打脸相关的知识,希望对你有一定的参考价值。
在《深入理解Java类加载机制,再也不用死记硬背了》这篇文章中提到,从JVM的角度看,加载的读取二进制流和初始化阶段,是开放了主导权给用户的。而剩下的所有部分都是JVM内部完成的。
那为什么要这样做呢?这是符合面向对象中的开闭原则和封装思想的设计。JVM将类加载内部复杂的实现封装了起来,拒绝开发者修改。只提供了一个拓展接口,用于二进制流的读取。
流程上搞懂了,那JVM是怎样使用代码来实现这些步骤的呢?这就要聊到Java的类加载器了。
类加载器
类加载器的分类是Java规范,属于抽象的概念。规范将类加载器分成启动类和非启动类两大类。
HotSpot对类加载器实现有以下分类(以下描述中省略了HotSpot定语):
启动类加载器是C/C++语言实现的,无法作为对象被程序引用。主要用来加载Java的核心类库。类库主要由Java启动参数指定,默认是$JAVA_HOME/lib。HotSpot还会对类名进行白名单校验来提高安全性。
非启动类加载器都是使用Java来实现,继承自java.lang.ClassLoader,可以作为类对象被程序引用。它也分成3种,简单说一下区别。
扩展类加载器ExtensionClassLoader加载的是$JAVA_HOME/lib/ext下或者启动时指定的类库。它目标是加载Java类库的扩展,是标准类库的补充。
应用类加载器ApplicationClassLoader加载的是环境变量classpath指定的类库。咱们平时使用maven的话,就是使用maven加载的类库和自己编写的代码。
用户类加载器就是用户自己定义的类加载器,也叫自定义类加载器。只要继承于应用类加载器即可。定义不同的类加载器会使用不同的命名空间。因为不同的命名空间是个隐含的限定名区分,是不同的对象。
双亲委派模型
双亲委派的目标是在默认情况下,一个限定名的类只会被一个类加载器加载并解析使用,这样在程序中,它就是唯一的,不会产生歧义。
在被动的情况下,当一个类加载器收到类加载请求,它不会首先自己去加载。而是传递给父加载器。这样,所有的类首先都会先由最上层的启动类加载器进行加载,只有父加载器无法完成类加载才会由子加载器完成。
白话来说:双亲委派模型中,如果类A调用了类B,那类B可能是类A在使用过程中被动加载进来的。那如果类A是用应用程序类加载器加载的,那么类B只能由应用程序类加载器或其父类或者上一层父类来加载。不能由自定义类加载器来来加载。
双亲委派模型并不是一个拥有强约束力的模型。它存在设计缺陷,在一些情况下可以被主动破坏。
五种经典的破坏双亲委派场景
第一次破坏
在《深入理解Java虚拟机》这本书中,记录了怎样破坏双亲委派:因为双亲委派机制原则在java.lang.ClassLoader的loadClass方法中。只要重写loadClass方法就可以破坏。书中还写了一个重写loadClass方法来进行破坏的小样例,这个小样例被称为双亲委派的第一次破坏。
Tomcat场景
这个破坏的样例有没有什么实际价值意义呢?还真有,后来Tomcat就使用这种方式对双亲委派进行破坏,来达到使用一个web容器部署两个或者多个应用程序,不同的应用程序,可能会依赖同一个第三方类库的不同版本,还要能保证每一个应用程序的类库都是独立、相互隔离的效果。
tomcat自定义了类加载器,重写loadClass方法使其优先加载自己目录下的class文件,来达到class私有的效果。不过咱们现在流行使用的都是嵌入式的web容器了,将来更多的场景还是一个应用程序使用一个单独的web容器。所以这种破坏双亲委派的价值在降低。
基于SPI的三种经典破坏场景
还有一种java特性叫做SPI,在《JAVA SPI(Service Provider Interface)原理、设计及源码解析》里,我不仅说了什么是SPI,还提到了三种经典场景都在使用,它们分别是jdbc、Dubbo、Eleasticsearch。没错,这三种经典场景通过SPI都使得双亲委派遭到破坏。下面以jdbc为例做说明。
jdbc驱动Driver在十几年前,我还手写过用DriverManager来加载的代码。
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "1234");
DriverManager初始化时是这样的,注意红框内容。
红框内容翻译一下就是说:由启动类加载器加载的DriverManager初始化时要去加载Driver驱动。
jdbc驱动由Serverloader.load加载。
而Serverloader.load里优先使用当前线程的类加载器而不是自身使用的类加载器来加载Driver。当前线程是使用方要么是应用类加载器要么是自定义类加载器,总归类A调用类B,B没有使用父类而使用了子类加载器,所以破坏了双亲委派。
双亲委派被破坏的补救措施
那朋友就问了,java.lang.ClassLoader把loadClass方法定义为final是不是就解决了双亲委派被破坏的问题呢?java.lang.ClassLoader的loadClass方法在Java很早的版本就有了,而双亲委派模型是在JDK1.2中引入的。Java是向下兼容的,所以不是不想改而是改不了了。一个补救措施是推荐使用findClass方法而不是直接重写loadClass。当然了,如果有人登录了服务器,把JDK文件给替换了,也就失效了。这个不在讨论范围。
如果文章对你有帮助,请点【在看】
如果文章你喜欢,请点【赞】
如果文章既没有帮助又不喜欢,或者有其他建议,欢迎【留言】或者直接加我微信 brmayi 反馈。
反馈是你的思考,我的成长,我们共同的进步源泉~
java虚拟机——双亲委派模型
双亲委派模型
一、双亲委派模型1、双亲委派执行过程2、类加载器3、双亲委派模型的目的4、双亲委派模型的实现二、破坏双亲委派模型1、第一次“被破坏”——JDK向前兼容2、第二次“被破坏”——逆向加载3、第三次“被破坏”——动态性追求
虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块被称为“类加载器”。
类加载器虽然只用于实现类的加载动作,但它在Java程序中起到的作用却远远不限于类加载阶段。对于任意一个类,都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。这句话可以表达得更通俗一些:比较两个类是否“相等”,只有在这两个类是由同一个类加载器加载的前提之下才有意义,否则,即使这两个类是来源于同一个Class文件,只要加载它们的类加载器不同,那这两个类就必定不相等。
这里所指的“相等”,包括代表类的Class对象的equals()
方法、isAssignableFrom()
方法、isInstance()
方法的返回结果,也包括了使用instanceof
关键字做对象所属关系判定等情况。
一、双亲委派模型
1、双亲委派执行过程
如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一个层次的类加载器都是如此。因此所有的加载请求最终都应该传送到顶层的启动类加载器中。
只有当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去加载。
2、类加载器
站在Java虚拟机的角度讲,只存在两种不同的类加载器:
一种是启动类加载器(Bootstrap ClassLoader),这个类加载器使用C++语言实现 ,是虚拟机自身的一部分;
另外一种就是所有其他的类加载器,这些类加载器都由Java语言实现,独立于虚拟机外部,并且全都继承自抽象类java.lang.ClassLoader。
从Java开发人员的角度来看,类加载器就还可以划分得更细致一些,绝大部分Java程序都会使用到以下三种系统提供的类加载器:
启动类加载器(BootstrapClassLoader):这个类加载器负责将存放在
<JAVA_HOME>\lib
目录中的,或者被-Xbootclasspath
参数所指定的路径中的,并且是虚拟机识别的(仅按照文件名识别,如rt.jar,名字不符合的类库即使放在lib目录中也不会被加载)类库加载到虚拟机内存中。启动类加载器无法被Java程序直接引用。扩展类加载器(ExtensionClassLoader):这个加载器由
sun.misc.Launcher$ExtClassLoader实现
,它负责加载<JAVA_HOME>\lib\ext
目录中的,或者被java.ext.dirs
系统变量所指定的路径中的所有类库,开发者可以直接使用扩展类加载器。应用程序类加载器(ApplicationClassLoader):这个类加载器由
sun.misc.Launcher$AppClassLoader
来实现。由于这个类加载器是ClassLoader
中的getSystemClassLoader()
方法的返回值,所以一般也称它为系统类加载器。它负责加载用户类路径(ClassPath)
上所指定的类库,开发者可以直接使用这个类加载器,如果应用程序中没有自定义过自己的类加载器,一般情况下这个就是程序中默认的类加载器。
我们的应用程序都是由这三种类加载器互相配合进行加载的,如果有必要,还可以加入自己定义的类加载器。这些类加载器之间的关系一般会如图所示。
图中所展示的类加载器之间的这种层次关系,就称为类加载器的双亲委派模型(Parents Delegation Model)。
双亲委派模型要求除了顶层的启动类加载器外,其余的类加载器都应当有自己的父类加载器。这里类加载器之间的父子关系一般不会以继承(Inheritance)的关系来实现,而是都使用组合(Composition)关系来复用父加载器的代码。
3、双亲委派模型的目的
使用双亲委派模型来组织类加载器之间的关系,有一个显而易见的好处就是Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类
java.lang.Object
,它存放在rt.jar
之中,无论哪一个类加载器要加载这个类,最终都是委派给启动类加载器进行加载,因此Object
类在程序的各种类加载器环境中都是同一个类。相反,如果没有使用双亲委派模型,由各个类加载器自行去加载的话,如果用户自己写了一个名为
java.lang.Object
的类,并放在程序的ClassPath
中,那系统中将会出现多个不同的Object类,Java类型体系中最基础的行为也就无从保证,应用程序也将会变得一片混乱。
4、双亲委派模型的实现
双亲委派模型对于保证Java程序的稳定运作很重要,但它的实现却非常简单,实现双亲委派的代码都集中在java.lang.ClassLoader的loadClass()
方法之中,如代码所示,逻辑清晰易懂:
先检查是否已经被加载过,
若没有加载则调用父加载器的
loadClass()
方法,若父加载器为空则默认使用启动类加载器作为父加载器。
如果父类加载失败,则在抛出ClassNotFoundException异常后,
再调用自己的
findClass()
方法进行加载。
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设计者推荐给开发者的类加载器实现方式。在Java的世界中大部分的类加载器都遵循这个模型,但也有例外。
1、第一次“被破坏”——JDK向前兼容
由于双亲委派模型在JDK 1.2之后才被引入,而类加载器和抽象类java.lang. ClassLoader
则在JDK 1.0时代就已经存在,面对已经存在的用户自定义类加载器的实现代码,Java设计者引入双亲委派模型时不得不做出一些妥协。为了向前兼容,JDK 1.2之后的java.lang.ClassLoader
添加了一个新的protected
方法findClass()
,在此之前,用户去继承java.lang.ClassLoader
的唯一目的就是为了重写loadClass()
方法,因为虚拟机在进行类加载的时候会调用加载器的私有方法loadClassInternal()
,而这个方法的唯一逻辑就是去调用自己的loadClass()
。双亲委派的具体逻辑就实现在这个loadClass()
方法之中,JDK 1.2之后已不提倡用户再去覆盖loadClass()
方法,而应当把自己的类加载逻辑写到findClass()
方法中,在loadClass()
方法的逻辑里如果父类加载失败,则会调用自己的findClass()
方法来完成加载,这样就可以保证新写出来的类加载器是符合双亲委派规则的。
/**
* Finds the class with the specified <a href="#name">binary name</a>.
* This method should be overridden by class loader implementations that
* follow the delegation model for loading classes, and will be invoked by
* the {@link #loadClass <tt>loadClass</tt>} method after checking the
* parent class loader for the requested class. The default implementation
* throws a <tt>ClassNotFoundException</tt>.
*
* @param name
* The <a href="#name">binary name</a> of the class
*
* @return The resulting <tt>Class</tt> object
*
* @throws ClassNotFoundException
* If the class could not be found
*
* @since 1.2
*/
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
2、第二次“被破坏”——逆向加载
双亲委派很好地解决了各个类加载器的基础类的统一问题(越基础的类由越上层的加载器进行加载),基础类之所以称为“基础”,是因为它们总是作为被用户代码调用的API,如果基础类又要调用回用户的代码,那该如何?
这并非是不可能的事情,一个典型的例子便是JNDI
服务,JNDI
现在已经是Java的标准服务,它的代码由启动类加载器去加载(在JDK 1.3时放进去的rt.jar),但JNDI
的目的就是对资源进行集中管理和查找,它需要调用由独立厂商实现并部署在应用程序的ClassPath
下的JNDI
接口提供者的代码,但启动类加载器不可能“认识”这些代码。
为了解决这个问题,Java设计团队只好引入了一个不太优雅的设计:线程上下文类加载器(Thread Context ClassLoader
)。这个类加载器可以通过java.lang.Thread
类的setContextClassLoaser()
方法进行设置,如果创建线程时还未设置,它将会从父线程中继承一个,如果在应用程序的全局范围内都没有设置过的话,那这个类加载器默认就是应用程序类加载器。
JNDI
服务使用这个线程上下文类加载器去加载所需要的SPI代码,也就是父类加载器请求子类加载器去完成类加载的动作
,这种行为实际上就是打通了双亲委派模型的层次结构来逆向使用类加载器,实际上已经违背了双亲委派模型的一般性原则。Java中所有涉及SPI的加载动作基本上都采用这种方式,例如JNDI
、JDBC
、JCE
、JAXB
和JBI
等。
/**
* Sets the context ClassLoader for this Thread. The context
* ClassLoader can be set when a thread is created, and allows
* the creator of the thread to provide the appropriate class loader,
* through {@code getContextClassLoader}, to code running in the thread
* when loading classes and resources.
*
* <p>If a security manager is present, its {@link
* SecurityManager#checkPermission(java.security.Permission) checkPermission}
* method is invoked with a {@link RuntimePermission RuntimePermission}{@code
* ("setContextClassLoader")} permission to see if setting the context
* ClassLoader is permitted.
*
* @param cl
* the context ClassLoader for this Thread, or null indicating the
* system class loader (or, failing that, the bootstrap class loader)
*
* @throws SecurityException
* if the current thread cannot set the context ClassLoader
*
* @since 1.2
*/
public void setContextClassLoader(ClassLoader cl) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}
public class ContextClassLoaserDemo {
public static void main(String[] args) {
Thread thread = new Thread();
//如果在应用程序的全局范围内都没有设置过的话,那这个类加载器默认就是应用程序类加载器
System.out.println(thread.getContextClassLoader());
thread.setContextClassLoader(new DIYContextClassLoader());
System.out.println(thread.getContextClassLoader());
}
static class DIYContextClassLoader extends ClassLoader {
//TODO 测试
}
}
控制台:
sun.misc.Launcher$AppClassLoader@58644d46
jvm.ContextClassLoaserDemo$DIYContextClassLoader@677327b6
3、第三次“被破坏”——动态性追求
由于用户对程序动态性的追求而导致双亲委派的第三次破坏,这里所说的“动态性”是指:代码热替换(HotSwap
)、模块热部署(Hot Deployment
)等,说白了就是希望应用程序能像我们的计算机外设那样,接上鼠标、U盘,不用重启机器就能立即使用,鼠标有问题或要升级就换个鼠标,不用停机也不用重启。
对于一些生产系统来说,关机重启一次可能就要被列为生产事故,这种情况下热部署就对软件开发者,尤其是企业级软件开发者具有很大的吸引力。Sun公司所提出的JSR-294
、JSR-277
规范在与JCP
组织的模块化规范之争中落败给JSR-291
(即OSGi R4.2
),目前OSGi已经成为了业界“事实上”的Java模块化标准,而OSGi实现模块化热部署的关键则是它自定义的类加载器机制的实现。
每一个程序模块(OSGi
中称为Bundle
)都有一个自己的类加载器,当需要更换一个Bundle
时,就把Bundle
连同类加载器一起换掉以实现代码的热替换。在OSGi
环境下,类加载器不再是双亲委派模型中的树状结构,而是进一步发展为更加复杂的网状结构,当收到类加载请求时,OSGi
将按照下面的顺序进行类搜索:
将以
java.*
开头的类委派给父类加载器加载。否则,将委派列表名单内的类委派给父类加载器加载。
否则,将
Import
列表中的类委派给Export
这个类的Bundle
的类加载器加载。否则,查找当前
Bundle
的ClassPath
,使用自己的类加载器加载。否则,查找类是否在自己的
Fragment Bundle
中,如果在,则委派给Fragment Bundle
的类加载器加载。否则,查找
Dynamic Import
列表的Bundle
,委派给对应Bundle
的类加载器加载。否则,类查找失败。
上面的查找顺序中只有开头两点仍然符合双亲委派规则,其余的类查找都是在平级的类加载器中进行的。
这里“被破坏”并不带有贬义的感情色彩,只要有足够意义和理由,突破已有的原则就可认为是一种创新。正如OSGi
中的类加载器并不符合传统的双亲委派的类加载器,并且业界对其为了实现热部署而带来的额外的高复杂度还存在不少争议,但在Java程序员中基本有一个共识:OSGi
中对类加载器的使用是很值得学习的,弄懂了OSGi
的实现,就可以算是掌握了类加载器的精髓。
声明:文章内容是本人的读书笔记,整理自:
《深入理解Java虚拟机》周志明著,第七章“虚拟机类加载机制”。
以上是关于五个经典的破坏双亲委派场景,Java被啪啪打脸的主要内容,如果未能解决你的问题,请参考以下文章