1.java类加载过程:
加载>>验证>>准备>>解析>>初始化>>使用>>卸载.
1.1加载:
在硬盘上查找并通过IO读取字节码文件.
1.2验证:
校验字节码文件的准确性.
1.3准备:
给类的静态变量分配内存,并赋予默认值.
1.4解析:
将符号引用替换为直接引用.该阶段会把一些静态方法(符号引用 比如main方法)替换为指向数据内存的指针或者句柄等(直接引用).这就是静态链接过程.(类加载期间完成).动态链接是在程序运行期间完成的符号引用替换为直接引用.
1.5初始化:
对类的静态变量初始化为指定的值.执行静态代码块.
2.类加载:
主类在运行过程中如果用到其它类会逐步加载这些类.jar包或war包里的类不是一次全部加载的,是使用时才加载.
public class loaderTest {
static {
System.out.println("loaderTest");
}
public static void main(String[] args) {
new loaderTestA();
System.out.println("loaderTest");
//loaderTestB不会加载,除非是new.
loaderTestB b = null;
}
}
class loaderTestA{
static {
System.out.println("loaderTestA");
}
public loaderTestA(){
System.out.println("init loaderTestA");
}
}
class loaderTestB{
static {
System.out.println("loaderTestB");
}
public loaderTestB(){
System.out.println("init loaderTestB");
}
}
2.1执行结果:
编辑
从结果可以看出运用到一个类的时候会先加载静态信息.
3.类加载器:
上面的类加载过程主要是通过类加载器实现的.java有如下几种类加载器.
3.1引导类加载器:负责加载支撑JVM运行的位于Jre的lib目录下的核心类库.比如,rt.jar charsets.jar等.
3.2扩展类加载器:负责加载支撑JVM运行的位于lib目录下的ext扩展目录中的Jar类包.
3.3应用程序类加载器:负责加载ClassPath路径下的类包.
3.4自定义类加载器:负责加载用户自定义路径下的类包.
3.1加载器demo:
public class JDKClassLoader {
public static void main(String[] args) {
System.out.println(String.class.getClassLoader());
System.out.println("==========================================");
System.out.println(DESKeyFactory.class.getClassLoader().getClass().getName());
System.out.println("==========================================");
System.out.println(JDKClassLoader.class.getClassLoader().getClass().getName());
}
}
因为引导类加载器是本地方法,所以打印出来是一个null.
4.双亲委派机制:
JVM类加载器是有亲子层级结构的如下图:
加载某个类的时候会先委托父加载器寻找目标类,找不到在委托上层父加载器加载,如果所有的父加载器在自己的加载路径下都找不到目标类.则在自己的类路径中查找并载入目标类.
4.1ClassLoader的loadClassloadClass源码:
//ClassLoader的loadClass方法，里面实现了双亲委派机制
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 检查当前类加载器是否已经加载了该类
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();
//都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类
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;
}
}
4.2为什么设计双亲委派进制:
4.2.1沙箱安全机制:可以防止核心类库API被篡改.
4.2.2避免类被重复加载:当父亲加载器已经加载了该类,就没有必要子类加载器在加载.保证类加载的唯一性.
4.2.3全盘负责委托机制:"全盘负责"是指当一个ClassLoader装载一个类时,除非显示的使用另外一个ClassLoader,该类所依赖及引用的类也由这个ClassLoader载入.
5.自定义类加载器:
自定义类加载器只需要实现java.lang.ClassLoader类,该类有两个核心方法,一个是loadClass.实现了双亲委派机制.还有一个方法是findClass,默认实现是空方法.所以自定义类加载器主要重写这个方法.
5.1Demo:
public class MyClassLoader extends ClassLoader {
//类加载路径.
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) {
byte[] data = new byte[0];
try {
data = loadByte(name);
} catch (Exception e) {
e.printStackTrace();
}
//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组.
return defineClass(name, data, 0, data.length);
}
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\\.", "/");
FileInputStream inputStream = new FileInputStream(classPath + "/" + name + ".class");
int size = inputStream.available();
byte[] data = new byte[size];
inputStream.read(data);
inputStream.close();
return data;
}
}
6打破双亲委派机制:
上面我们知道双亲委派实现的是ClassLoader的loadClass方法.所以我们可以重写这个方法来实现.
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class<?> c = findLoadedClass(name);
//如果不是我们指定的类路径,其余的类继续用父类加载.
if (!name.startsWith("com.loader.test")) {
this.getParent().loadClass(name);
}
if (c == null) {
long t0 = System.nanoTime();
if (c == null) {
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;
}
}
这样就可以打破双亲委派机制了.
大模型盛行,只能多学点东西.
如果大家喜欢我的分享的话,可以关注我的微信公众号
念何架构之路
