类加载器
1.启动类加载器:
负责加载支持JVM运行的位于JRE的lib目录下的核心类库,比如rt.jar、charset.jar等
2.扩展类加载器:
负责加载支持JVM运行的位于JRE的lib目录下的ext扩展目录中的jar包
3.应用程序类加载器:
负责加载ClassPath路径下的类包,主要就是加载你自己写的那些类
4.自定义类加载器:
负责加载用户自定义路径下的类包
// 示例
public class JdkClassLoaderTest {
public static void main(String[] args) {
System.out.println(String.class.getClassLoader());
System.out.println(com.sun.crypto.provider.DESKeyFactory.class.getClassLoader().getClass().getName());
System.out.println(JdkClassLoaderTest.class.getClassLoader().getClass().getName());
System.out.println(ClassLoader.getSystemClassLoader().getClass().getName());
}
}
// 结果
null // 启动类加载器是C++语言实现,所以打印不出来
sun.misc.Launcher$ExtClassLoader
sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$AppClassLoader
自定义一个类加载器
// 示例
public class MyClassLoaderTest {
static class MyClassLoader extends ClassLoader {
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
//defineClass将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节数组。
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
}
public static void main(String[] args) throws Exception {
MyClassLoader classLoader = new MyClassLoader("D:\\study\\jvm\\MyClassLoader");
Class clazz = classLoader.loadClass("com.sly.demo.jvm.classloader.User");
Object obj = clazz.newInstance();
Method method= clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
}
}
// 结果
使用自定义类加载器加载
com.sly.demo.jvm.classloader.MyClassLoaderTest$MyClassLoader
双亲委派机制
1.首先,检查一下指定名称的类是否已经加载过,如果加载过了,就不需要再加载,直接返回。
2.如果此类没有加载过,那么,再判断一下是否有父加载器;如果有父加载器,则由父加载器加载(即调用parent.loadClass(name, false);)。或者是调用bootstrap类加载器来加载。
3.如果父加载器及bootstrap类加载器都没有找到指定的类,那么调用当前类加载器的findClass方法来完成类加载。
双亲委派机制说简单点就是,先找父亲加载,不行再由儿子自己加载
设计双亲委派机制原因
沙箱安全机制:自己写的java.lang.String.class类不会被加载,这样便可以防止核心API库被随意篡改
避免类的重复加载:当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次,保证被加载类的唯一性
打破双亲委派
以Tomcat类加载为例:
1.一个web容器可能需要部署两个应用程序,不同的应用程序可能依赖同一个第三方类库的不同版本,不能要求同一个类库在同一个服务器只有一份,因此要保证每个应用程序的类库都是独立的,保证相互隔离。
2.部署在同一个web容器中相同的类库相同的版本可以共享。否则,如果服务器有10个应用程序,那么要有10份相同的类库加载进虚拟机。
3.web容器也有自己依赖的类库,不能与应用程序的类库混淆。基于安全考虑,应该让容器的类库和程序的类库隔离开来。
4.web容器要支持jsp的修改,我们知道,jsp 文件最终也是要编译成class文件才能在虚拟机中运行,但程序运行后修改jsp已经是司空见惯的事情, web容器需要支持 jsp 修改后不用重启。
tomcat的几个主要类加载器:
commonLoader:Tomcat最基本的类加载器,加载路径中的class可以被Tomcat容器本身以及各个Webapp访问;
catalinaLoader:Tomcat容器私有的类加载器,加载路径中的class对于Webapp不可见;
sharedLoader:各个Webapp共享的类加载器,加载路径中的class对于所有Webapp可见,但是对于Tomcat容器不可见;
WebappClassLoader:各个Webapp私有的类加载器,加载路径中的class只对当前Webapp可见;
每个webappClassLoader加载自己的目录下的class文件,不会传递给父类加载器,打破了双亲委派机制。
如何打破双亲委派
可以通过重写类加载器的loadClass()方法实现
// 示例
public class BlockDelegationClassLoaderTest {
static class BlockDelegationClassLoader extends ClassLoader {
private String classPath;
public BlockDelegationClassLoader(String classPath) {
this.classPath = classPath;
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
//defineClass将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节数组。
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
@Override
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) {
/*
* 直接执行findClass()...什么意思呢? 首先会使用自定义类加载器加载类, 不在向上委托, 直接由
* 自己执行
*
* jvm自带的类还是需要由引导类加载器自动加载
*/
if (!name.startsWith("com.sly.demo.jvm.classloader")) {
c = this.getParent().loadClass(name);
} else {
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
}
public static void main(String[] args) throws Exception {
BlockDelegationClassLoader classLoader = new BlockDelegationClassLoader("D:\\study\\jvm\\MyClassLoader");
Class clazz = classLoader.loadClass("com.sly.demo.jvm.classloader.User");
Object obj = clazz.newInstance();
Method method= clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
}
}
// 结果
使用自定义类加载器加载
com.sly.demo.jvm.classloader.BlockDelegationClassLoaderTest$BlockDelegationClassLoader
查看类加载过程
添加jvm参数
-verbose:class
// 示例
@Test
public void test1() {
new A();
System.out.println("============load test============");
new B();
}
// 结果 可以看到类A和类B都加载了
[Loaded com.sly.demo.jvm.classloader.A from file:/D:/workspace/idea/demo-jvm/target/classes/]
============class A init============
============load test============
[Loaded com.sly.demo.jvm.classloader.B from file:/D:/workspace/idea/demo-jvm/target/classes/]
============class B init============
// 示例
@Test
public void test2() {
new A();
System.out.println("============load test============");
B b = null;
}
// 结果 可以看到类A加载了,类B没有加载因为没有使用到
[Loaded com.sly.demo.jvm.classloader.A from file:/D:/workspace/idea/demo-jvm/target/classes/]
============class A init============
============load test============
[Loaded org.junit.runner.notification.RunNotifier$7 from file:/D:/devenvironment/repository/junit/junit/4.12/junit-4.12.jar]