Java ClassLoader的一些事

Dear 丶 2022-12-17 08:43 217阅读 0赞

在Java中，存在着类加载的机制。

除了委托机制以外，还遵循以下规则：

1、java命令启动main线程时，会使用该线程的类加载器去加载第一个类；

2、以后的类加载，无论是父类还是使用到的类，都会使用之前类的加载器去加载；

3、可以使用loadClass自主加载，来改变后续类的类加载器。

对于类加载器的使用，这里我说明几点：

1、类加载器的类型主要分为四类：

【1】Bootstrp loader ：

Bootstrp加载器是用C++语言写的，它是在Java虚拟机启动后初始化的，它主要负责加载`%JAVA_HOME%/jre/lib`,`-Xbootclasspath`

参数指定的路径以及`%JAVA_HOME%/jre/classes`中的类。

【2】ExtClassLoader

Bootstrp loader加载ExtClassLoader,并且将ExtClassLoader的父加载器设置为Bootstrp loader.ExtClassLoader是用Java写的，

具体来说就是 sun.misc.Launcher$ExtClassLoader，ExtClassLoader主要加载`%JAVA_HOME%/jre/lib/ext`，此路径下的所有

classes目录以及`java.ext.dirs`系统变量指定的路径中类库。

【3】AppClassLoader   
Bootstrp loader加载完ExtClassLoader后，就会加载AppClassLoader,并且将AppClassLoader的父加载器指定为 ExtClassLoader。

·AppClassLoader也是用Java写成的，它的实现类是 sun.misc.Launcher$AppClassLoader，另外我们知道ClassLoader中有个

`getSystemClassLoader`方法,此方法返回的正是AppclassLoader.AppClassLoader主要负责加载classpath所指定的位置的类或者

是jar文档，它也是Java程序默认的类加载器。

【4】用户自定义的类加载器

类加载的过程：ClassLoader.loadClass(String name, boolean resolve)

1、**Class<?> c = findLoadedClass(name);**

**检查已经被加载的类，如果没有被加载过则会往下继续执行,如果被加载过，就直接返回已经加载过的类。**

**2、if (parent != null)**

**\{  
              c = parent.loadClass(name, false);  
      \} else \{  
                c = findBootstrapClassOrNull(name);  
        \}**

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;
            }
        }

**判断该加载器的parent是否为空，**

**如果不为空，则调用父类的loadClass函数；**

如果为空，则即为findBootstrapClassOrNull(name);判断是否已经被Bootstrp loader 加载。

3、如果以上均未加载成功，则findClass(name)

ps：不同加载器加载的同一个类是不相同的，不同类加载器加载的具有集成关系的类是可以转换的。

### 自定义ClassLoader： ###

打破双亲委派，必须进行在构造函数里添加：

package application;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2020, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2020-10-23 6:32
     * @Version: 1.0
     * @Description:
     */
    public class Student {
        private String name;
        private int age;
        private boolean sex;
        private String address;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public boolean isSex() {
            return sex;
        }
    
        public void setSex(boolean sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
        
        
    }

package application;
    
    import java.io.ByteArrayOutputStream;
    import java.io.InputStream;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2020, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2020-10-23 6:31
     * @Version: 1.0
     * @Description:
     */
    public class MineClassLoader extends ClassLoader{
        private static final String CONST_STR = "application.Student";
        public MineClassLoader(){
            //打破双亲委派
            super(null);
        }
        @SneakyThrows
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            InputStream resourceAsStream = null;
            ByteArrayOutputStream byteArrayOutputStream = null;
            if (CONST_STR.equalsIgnoreCase(name)){
                try {
                    resourceAsStream = MineClassLoader.class.getResourceAsStream("/application/Student.class");
                    byteArrayOutputStream = new ByteArrayOutputStream();
                    int length = -1;
                    byte [] buffer = new byte[10240];
                    while ((length = resourceAsStream.read(buffer))!=-1){
                        byteArrayOutputStream.write(buffer,0,length);
                    }
                }
                catch (Exception e){
                    e.printStackTrace();
                }
                finally {
                    resourceAsStream.close();
                    byteArrayOutputStream.close();
                }
            }
            return defineClass(CONST_STR,byteArrayOutputStream.toByteArray(),0,byteArrayOutputStream.toByteArray().length);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d0bDE5OTI_size_16_color_FFFFFF_t_70][]

public Launcher() {
            Launcher.ExtClassLoader var1;
            try {
                var1 = Launcher.ExtClassLoader.getExtClassLoader();
            } catch (IOException var10) {
                throw new InternalError("Could not create extension class loader", var10);
            }
    
            try {
                this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
            } catch (IOException var9) {
                throw new InternalError("Could not create application class loader", var9);
            }
    
            Thread.currentThread().setContextClassLoader(this.loader);
            String var2 = System.getProperty("java.security.manager");
            if (var2 != null) {
                SecurityManager var3 = null;
                if (!"".equals(var2) && !"default".equals(var2)) {
                    try {
                        var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                    } catch (IllegalAccessException var5) {
                    } catch (InstantiationException var6) {
                    } catch (ClassNotFoundException var7) {
                    } catch (ClassCastException var8) {
                    }
                } else {
                    var3 = new SecurityManager();
                }
    
                if (var3 == null) {
                    throw new InternalError("Could not create SecurityManager: " + var2);
                }
    
                System.setSecurityManager(var3);
            }
    
        }

### 如果不打破双亲委派，所继承得到的MineClassloader的parent是AppClassLoader。 ###

package application.service.classloader;
    
    import lombok.SneakyThrows;
    
    import java.io.ByteArrayOutputStream;
    import java.io.InputStream;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2020, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2020-10-31 16:58
     * @Version: 1.0
     * @Description:
     */
    public class MineClassloader extends ClassLoader{
    
        public MineClassloader(){
            super(null);
        }
    
        @SneakyThrows
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            System.out.println(name);
    
            InputStream resourceAsStream = MineClassloader.class.getResourceAsStream("/" + name.replaceAll("\\.", "/") + ".class");
    
            int length = -1;
            byte [] buffer = new byte[10240];
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while ((length = resourceAsStream.read(buffer))!=-1){
                byteArrayOutputStream.write(buffer,0,length);
            }
    
            return defineClass(name,byteArrayOutputStream.toByteArray(),0,byteArrayOutputStream.toByteArray().length);
        }
    }

![20201031170730528.png][]

**打破双亲委派的时候，会将子类和父类都由MineClassloader加载！！！**

**热加载的原理：**

**不使用loadClass（），而是用findClass()：**

package application.service.classloader;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2020, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2020-10-31 16:59
     * @Version: 1.0
     * @Description:
     */
    public class Main {
        public static void main(String[] args) throws Exception {
            MineClassloader mineClassloader1 = new MineClassloader();
            MineClassloader mineClassloader2 = new MineClassloader();
    
            Class<?> aClass1 = mineClassloader1.findClass("application.service.classloader.SpiImpl");
            Class<?> aClass2 = mineClassloader2.findClass("application.service.classloader.SpiImpl");
    
            Class<?> aClass3 = mineClassloader1.loadClass("application.service.classloader.SpiImpl");
            Class<?> aClass4 = mineClassloader1.loadClass("application.service.classloader.SpiImpl");
    
            System.out.println(aClass1.hashCode());
            System.out.println(aClass2.hashCode());
    
            System.out.println(aClass3.hashCode());
            System.out.println(aClass4.hashCode());
        }
    }

![20201031171708301.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d0bDE5OTI_size_16_color_FFFFFF_t_70]: /images/20221122/9623619a00eb45dfb66e92f75e0d8350.png
[20201031170730528.png]: /images/20221122/c8f5571bc55b4094822a7cda44095203.png
[20201031171708301.png]: /images/20221122/3e30a63a96cc4d6088bfc5444aaf9894.png