加载流程
- C++创建Java虚拟机
- 并创建引导类加载器实例
- 创建JVM启动器sun.msi.Launcher
- getLauncher()创建Launcher实例
- getClassLoad()创建AppClassLoader
- loadClass("类路径")将类加载进内存
- 执行main方法XXX.main()
- 运行结束,JVM销毁
类加载的过程
加载-->验证-->准备-->解析-->初始化
加载
加载编译后的class文件到内存当中
验证
校验编译后的文件格式,是否符合规范
准备
给静态变量分配内存并赋默认值
解析
符号引用
任何形式的字面量,如java中的方法、符号
直接引用
- 直接指向目标的指针
- 相对偏移量
- 一个能间接定位到目标的句柄(虚拟地址)
动态链接
在程序运行时,将一些符号引用替换为直接引用
静态链接
在class文件编译时,将一些静态方法直接替换为直接引用(直接指向内存中的地址)
初始化
对静态变量赋初始值,并执行静态代码块
java中的类加载器
引导类加载器:主要负责加载jdk的位于jre下的lib目录下的核心类库
扩展类加载器:主要负责加载jdk的位于jre下的lib目录下的ext扩展目录
应用类加载器:主要负责加载自己应用中classpath路径下的类包
自定义加载器:主要负责加载用户自定义路径下的类包
双亲委派机制
在一个类被加载时,必然是由AppClassLoader先开始,因为在初始化Launcher的时候,得到的ClassLoader类型的对象是AppClassLoader
public class Launcher {
private static URLStreamHandlerFactory factory = new Launcher.Factory();
private static Launcher launcher = new Launcher();
private static String bootClassPath = System.getProperty("sun.boot.class.path");
private ClassLoader loader;
private static URLStreamHandler fileHandler;
//1.第一步实例化
public static Launcher getLauncher() {
return launcher;
}public Launcher() {
Launcher.ExtClassLoader var1;
try {
var1 = Launcher.ExtClassLoader.getExtClassLoader();
} catch (IOException var10) {
throw new InternalError("Could not create extension class loader", var10);
}try { //2.第二步,得到一个ClassLoader
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
} catch (IOException var9) {
throw new InternalError("Could not create application class loader", var9);
}
源码体现
protected Class> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 1.会检查类是否已经被加载
Class> c = findLoadedClass(name);
//若没有被加载
if (c == null) {
long t0 = System.nanoTime();
try {//2.则调用其父类加载器(扩展类加载器)的方法
if (parent != null) {
c = parent.loadClass(name, false);
} else { //3.若扩展类加载器不存在,则调用引导类加载器
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
} //4.若都加载不到则由自己加载 if (c == null) {
long t1 = System.nanoTime();
c = findClass(name);
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
双亲委派过程中类加载流程
- 由AppClassLoader调用父类ClassLoader的loadClass方法进行加载
- 检查是否有加载过,若有,直接返回;若无,则调用扩展类加载器进行加载
- 若扩展类加载器不存在,则由引导类加载器进行加载
- 若父类加载器都失败,则由应用程序加载器自己进行加载
双亲委派机制的作用
- 实现了沙箱安全机制:避免核心类库被随意修改,自己写的类似java.lang.String.class类不会被加载。
- 使得类不会被重复加载:当父类的加载器已经加载该类,子类的ClassLoader就没有必要再加载,保证被加载类的唯一性
全盘委托机制
即当前类依赖了其他的类对象,那么这个依赖的类也会有加载当前类的类加载器一起加载
自定义类加载器
从ClassLoader的源码可知,双亲委派机制在实现时调用的是它内部的loadClass()方法来作为加载的入口,通过findClass()方法来加载应用程序中自己写的类;所以要创建自定义的类加载器,需要:
- 实现ClassLoader类
- 重写loadClass方法中调用的findClass方法
public MyClassLoader(String classPath){
this.classPath = classPath;
}
protected Class> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
//本地方法,将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节数组
return defineClass(name,data,0,data.length);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private byte[] loadByte(String name) throws Exception{
name = name.replaceAll("\.","/");
FileInputStream fis = new FileInputStream(classPath + "/"+name+".class");
//一次读取多个字节,若是本地加载则无问题;若是网络操作,可能会因为通讯问题导致得到的字节数有遗漏或者为0
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
测试类
//1.初始化自定义类加载器,会先初始化父类ClassLoader,其中会把自定义加载器的父类加载器设置为APPClassLoader
//加载自定义的代码路径
MyClassLoader classLoader = new MyClassLoader("D:/test");
//获得Class对象
Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
打破双亲委派机制
已知双亲委派的实现是在类加载的时候体现的,因此,若是要打破该机制;就需要重写ClassLoader类中的loadC方法,改变其中的类加载方式。
在之前的自定义类加载器类中重写loadClass方法
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();
long t1 = System.nanoTime();
c = findClass(name);
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
Tomcat打破双亲委派机制
Tomcat作为一个web容器,要让多个应用都能运行起来需要什么?
- 应用依赖的不同版本的类库,应该独立且隔离。
- 应用依赖的相同版本的类库,应该共享。
- web容器依赖的类库和应用依赖的类库,应该独立且隔离
- web容器中的jsp支持修改,但jsp也会编译为class文件,所以web容器应该支持jsp的热部署
Tomcat为何不能使用默认的双亲委派机制
- 双亲委派机制保证了相同路径在的类只会被加载一次,那么多应用下就无法加载不同版本的类库。
Tomcat自定义加载器
tomcat的几个主要类加载器:
- commonLoader:Tomcat最基本的类加载器,加载路径中的class,可以被Tomcat容器本身以及各个Webapp访问;
- catalinaLoader:Tomcat容器私有的类加载器,加载路径中的class对于Webapp不可见;
- sharedLoader:各个Webapp共享的类加载器,加载路径中的class对于所有 Webapp可见,但是对于Tomcat容器不可见;
- WebappClassLoader:各个Webapp私有的类加载器,加载路径中的class只对当前 Webapp可见,比如加载war包里相关的类,每个war包应用都有自己的WebappClassLoader,实现相互隔离,比如不同war包应用引入了不同的spring版本,这样实现就能加载各自的spring版本;
public MyClassLoader(String classPath){
this.classPath = classPath;
}
protected Class> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
//本地方法,将一个字节数组转为Class对象,这个字节数组是class文件读取后最终的字节数组
return defineClass(name,data,0,data.length);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private byte[] loadByte(String name) throws Exception{
name = name.replaceAll("\.","/");
FileInputStream fis = new FileInputStream(classPath + "/"+name+".class");
//一次读取多个字节,若是本地加载则无问题;若是网络操作,可能会因为通讯问题导致得到的字节数有遗漏或者为0
int len = fis.available();
byte[] data = new byte[len];
fis.read(data);
fis.close();
return data;
//1.初始化自定义类加载器,会先初始化父类ClassLoader,其中会把自定义加载器的父类加载器设置为APPClassLoader
//加载自定义的代码路径
MyClassLoader classLoader = new MyClassLoader("D:/test");
//获得Class对象
Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("sout", null);
method.invoke(obj, null);
System.out.println(clazz.getClassLoader().getClass().getName());
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();
long t1 = System.nanoTime();
c = findClass(name);
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
if (resolve) {
resolveClass(c);
}
return c;
}
}



