类加载器以及双亲委派模式

一.Java中的类加载器

一般有四种：

引导类加载器（BootstrapClassLoader）：加载JRE的lib目录下的核心类库

扩展类加载器（ExtClassLoader）：加载JRE的lib目录下ext扩展目录下的JER包

应用程序加载器（AppClassLoader）：主要加载自己写的那些类

自定义加载器：负责加载用户自定义路径下的类包

二.什么是双亲委派机制

双亲委派顾名思义就是当一个类被加载时，首先会使用我们的应用程序加载器去加载，若应用程序加载器里面已经有这个类那就直接加载，若没有则应用类加载器会委派扩展加载器去加载，同理扩展加载器里面有就直接加载没有就委派引导类加载器去加载。

类加载过程：

双亲委派机制的源码：

 三.如何自定义加载器

我们只需要创建一个类加载器并继承ClassLoader即可

public class TestMyClassLoader {
    //自定义类加载器
    static class MyClassLoader extends ClassLoader{
        //文件存放路径
        private String classPath;

        public MyClassLoader (String classPath) {
            this.classPath = classPath;
        }
        public 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;
        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data=loadByte(name);
                return defineClass(name,data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
            }
            throw new ClassNotFoundException(name);
        }


    }
    public static void main(String[] args) throws Exception{
        //初始化自定义加载器，加载指定目录下的包
        MyClassLoader classLoader=new MyClassLoader("D:/test");
        //加载指定包下的类
        Class<?> loadClass = classLoader.loadClass("com.aldi.app.Person1");
        Object newInstance = loadClass.newInstance();
        Method method = loadClass.getDeclaredMethod("sout", null);
        method.invoke(newInstance, null);
        System.out.println(loadClass.getClassLoader().getClass().getName());
    }
}

 

 这时候我们发现我们的方法执行成功了，但是加载器使用的是AppClassLoader，这是为什么呢？

这也就是我们所说的双亲委派机制，因为我们的项目里也有这个Person1类，所以我们自定义的类不会去加载它，会委托父加载器也就是AppClassLoader去加载。

那么如何使用我们自定义的加载器去加载呢；只需要将我们项目里的类删除即可。

 

 

四.如何打破双亲委派机制呢

那么我们又想不删除项目里的类，又想使用我们自己的类加载器呢。

为什么设计双亲委派机制呢？

1.沙箱安全机制：防止核心类库被随意篡改

2.避免类的重复加载：当父类加载了这个类，那么没必要子类再去加载一次，保证了被加载类的唯一性。

那么如何去打破双亲委派呢

我们从源码里发现，实现双亲委派机制的主要是ClassLoader里的loadClass方法，所以我们只需要重写这个方法，那么就可以打破。

package com.aldi.app.service;

import lombok.SneakyThrows;

import java.io.FileInputStream;
import java.lang.reflect.Method;

public class TestMyClassLoader {
    //自定义类加载器
    static class MyClassLoader extends ClassLoader{
        //文件存放路径
        private String classPath;

        public MyClassLoader (String classPath) {
            this.classPath = classPath;
        }
        public 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;
        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data=loadByte(name);
                return defineClass(name,data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
            }
            throw new ClassNotFoundException(name);
        }

        /**
         * 重写 loadClass方法，打破双亲委派机制
         * @param name
         * @param resolve
         * @return
         * @throws ClassNotFoundException
         */
        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;
            }
        }


    }
    public static void main(String[] args) throws Exception{
        //初始化自定义加载器，加载指定目录下的包
        MyClassLoader classLoader=new MyClassLoader("D:/test");
        //加载指定包下的类
        Class<?> loadClass = classLoader.loadClass("com.aldi.app.Person1");
        Object newInstance = loadClass.newInstance();
        Method method = loadClass.getDeclaredMethod("sout", null);
        method.invoke(newInstance, null);
        System.out.println(loadClass.getClassLoader().getClass().getName());
    }
}

 但是我们执行的时候发现找不到指定路径下的Object类，这是为什么呢？

因为我们所有的类都继承于Object类，用自定义加载器加载指定的类势必也会加载Object类

这个怎么解决呢。

这时候嗯可能会直接复制一个Object类放在指定目录下不就可以了吗，但这里我们还需要知道JDK的另外一个机制：沙箱安全机制，这是为了防止核心代码库被随意篡改。那么我们只能去修改我们的代码去实现。只需要加一个判断是不是来自我们指定包路径下的类即可

package com.aldi.app.service;

import lombok.SneakyThrows;

import java.io.FileInputStream;
import java.lang.reflect.Method;

public class TestMyClassLoader {
    //自定义类加载器
    static class MyClassLoader extends ClassLoader{
        //文件存放路径
        private String classPath;

        public MyClassLoader (String classPath) {
            this.classPath = classPath;
        }
        public 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;
        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data=loadByte(name);
                return defineClass(name,data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
            }
            throw new ClassNotFoundException(name);
        }

        /**
         * 重写 loadClass方法，打破双亲委派机制
         * @param name
         * @param resolve
         * @return
         * @throws ClassNotFoundException
         */
        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();
                    if(!name.startsWith("com.aldi.app")){
                       c= this.getParent().loadClass(name);

                    //实现双亲委派的代码
                    /*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
                    }*/}else {

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


    }
    public static void main(String[] args) throws Exception{
        //初始化自定义加载器，加载指定目录下的包
        MyClassLoader classLoader=new MyClassLoader("D:/test");
        //加载指定包下的类
        Class<?> loadClass = classLoader.loadClass("com.aldi.app.Person1");
        Object newInstance = loadClass.newInstance();
        Method method = loadClass.getDeclaredMethod("sout", null);
        method.invoke(newInstance, null);
        System.out.println(loadClass.getClassLoader().getClass().getName());
    }
}

 

 到这里我们就已经实现了自定义记载类去加载我们指定目录下的类，并打破了双亲委派机制去加载。