从源码级别了解java双亲委派

双亲委派

双亲委派的机制是在Java1.2后引入的，其工作原理就是java在加载某个类（.class）文件时会先去委托父加载器去寻找并加载目标类，递归这个操作，如果所有的父加载器在自己的加载类路径下都找不到目标类，自己才会去加载这个类。

类加载器的类别

引导类加载器（Bootstrap ClassLoader）

引导类加载器（启动类加载器）：c++编写，负责将JAVA_HOME/lib下面的核心类库或-Xbootclasspath选项指定的jar包等虚拟机识别的类库加载到内存中,构造ExtClassLoader和AppClassLoader。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用。具体的启动类加载器加载到的路径可通过URL[] urls = Launcher.getBootstrapClassPath().getURLs();查看。

扩展类加载器（ExtClass Loader）

扩展类加载器：java编写，是由Sun的ExtClassLoader（sun.misc.launcher$ExtClassLoader）实现的，主要负责加载E:\Program Files\Java\jre1.8.0_261\lib\ext或者由系统变量-Djava.ext.dir指定位置中的类库加载到内存中。具体的扩展类加载器加载到的路径可通过System.getProperty("java.ext.dirs")查看。

应用程序类加载器（Application ClassLoader）

应用程序类加载器（系统类加载器）：java编写，是由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的，它负责将用户类路径下的类库加载到内存中（如classes）。具体的系统类加载器加载到的路径可通过System.getProperty("java.class.path")查看。

自定义类加载器（Customer ClassLoader）

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

源码分析

//ClassLoader的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();
            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方法在加载器的类路径里查找并加载该类
                //如果bootstrapClassLoader 仍然没有加载过，则递归回来，尝试自己去加载class
                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;
    }
}

双亲委派机制流程图

双亲委派的优势

• 沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心 API库被随意篡改
• 避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一 次，保证被加载类的唯一性

打破双亲委派

• 原理：我们直接让自定义加载器去直接加载class文件 而不让它取委托父加载器去加载，就是说不要去走双亲委派那一套。
• 分析：ClassLoader的loadClass方法，里面实现了双亲委派机制，如果我们要打破双亲委派机制，那只需要重写loadCLass方法就可以了。
  首先，我们需要实现一个自定义类加载器，自定义类加载器只需要继承 java.lang.ClassLoader 类，该类有两个核心方法，一个是loadClass(String, boolean)，实现了双亲委派机制，还有一个方法是findClass，默认实现是空方法，所以我们自定义类加载器主要是重写findClass方法。
  下面我们是一个自定义类加载器的实例：

package com.java.clazz.loader;

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

public class MyClassLoaderTest {
	  static class MyClassLoader extends ClassLoader {
	        private String classPath;

	        public MyClassLoader(String classPath) {
	            this.classPath = classPath;
	        }

	        private byte[] loadByte(String name) throws IOException {
	            name = name.replaceAll("\\.","/");
	            FileInputStream fileInputStream = new FileInputStream(classPath + "/" + name + ".class");
	            int len = fileInputStream.available();
	            byte[] data = new byte[len];
	            fileInputStream.read(data);
	            fileInputStream.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();
	            }
	        }

	        public static void main(String[] args) {
	            MyClassLoader classLoader = new MyClassLoader("D:/test");

	            try {
	                Class clazz = null;
	                clazz = classLoader.loadClass("com.java.clazz.loader.User");
	                Object object = clazz.newInstance();
	                Method method = clazz.getDeclaredMethod("eat",null);
	                method.invoke(object, null);
	                System.out.println(clazz.getClassLoader().getClass().getName());
	            } catch (Exception e) {
	                e.printStackTrace();
	            }
	        }
	    }
}

从执行结果，当前的类加载器还是应用程序类加载器，虽然我们自定义了类加载器，但是并未打破双亲委派机制。如果我们想要打破双亲委派机制，只需要重写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();



                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    //
                    if(!name.startsWith("com.tuling.jvm")){
                        c = this.getParent().loadClass(name);
                    }else{
                        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;
            }
        }

ok~，本篇到此告一段落，如有误处，欢迎留言，谢谢