类加载器的双亲委托模式

public class HelloLoader {
    public void print() {
        System.out.println("I am in Boot ClassLoader");
    }
}

public class FindClassOrder {
    public static void main(String[] args) {
        HelloLoader loader = new HelloLoader();
        loader.print();
    }
}

public class HelloLoader {
    public void print() {
        System.out.println("I am in App ClassLoader");
    }
}

public class FindClassOrder {
    public static void main(String[] args) {
        HelloLoader loader = new HelloLoader();
        loader.print();
        System.out.println(System.getProperty("sun.boot.class.path"));
    }
}

public class FindClassOrder1 {
    public static void main(String[] args) throws Exception {
        //获取FindClassOrder1的类加载器，此处为一个应用类加载器
        ClassLoader cl = FindClassOrder1.class.getClassLoader();
        //将HelloLoader.class字节码转换成字节数组
        byte[] bHelloLoader = loadClassBytes("com.guanjian.calculate.test.HelloLoader");
        //ClassLoader的defineClass()方法可以将字节数组转换成Class
        Method md_defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        md_defineClass.setAccessible(true);
        //获取Class HelloLoader
        md_defineClass.invoke(cl, bHelloLoader, 0, bHelloLoader.length);
        md_defineClass.setAccessible(false);

        HelloLoader loader = new HelloLoader();
        //打印loader对象的类加载器
        System.out.println(loader.getClass().getClassLoader());
        loader.print();
    }

    private static byte[] loadClassBytes(String className) throws ClassNotFoundException {
        try {
            //获取class文件的完整路径
            String classFile = getClassFile(className);
            FileInputStream fis = new FileInputStream(classFile);
            FileChannel fileC = fis.getChannel();
            ByteArrayOutputStream baos = new
                    ByteArrayOutputStream();
            WritableByteChannel outC = Channels.newChannel(baos);
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            while (true) {
                int i = fileC.read(buffer);
                if (i == 0 || i == -1) {
                    break;
                }
                buffer.flip();
                outC.write(buffer);
                buffer.clear();
            }
            fis.close();
            return baos.toByteArray();
        } catch (IOException fnfe) {
            throw new ClassNotFoundException(className);
        }
    }

    private static String getClassFile(String name) {
        StringBuilder sb = new StringBuilder("/Users/admin/Downloads/calculate/target/classes");
        name = name.replace('.', File.separatorChar) + ".class";
        sb.append(File.separator + name);
        return sb.toString();
    }
}

public class FindClassOrder2 {
    public static void main(String[] args) throws Exception {
        //获取FindClassOrder1的类加载器，此处为一个应用类加载器
        ClassLoader cl = FindClassOrder1.class.getClassLoader();
        //将HelloLoader.class字节码转换成字节数组
        byte[] bHelloLoader = loadClassBytes("com.guanjian.calculate.test.HelloLoader");
        //ClassLoader的defineClass()方法可以将字节数组转换成Class
        Method md_defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        md_defineClass.setAccessible(true);
        //获取Class HelloLoader
        md_defineClass.invoke(cl, bHelloLoader, 0, bHelloLoader.length);
        md_defineClass.setAccessible(false);
        //通过应用类加载器的双亲扩展类加载器进行加载
        //如果扩展类加载器加载不了，则会请求扩展类加载器的双亲启动类加载器进行加载
        Object loader = cl.getParent().loadClass("com.guanjian.calculate.test.HelloLoader").newInstance();
        //打印loader对象的类加载器
        System.out.println(loader.getClass().getClassLoader());
        //获取loader对象的print()方法
        Method m = loader.getClass().getMethod("print", null);
        //执行print()方法
        m.invoke(loader,null);
    }

    private static byte[] loadClassBytes(String className) throws ClassNotFoundException {
        try {
            String classFile = getClassFile(className);
            FileInputStream fis = new FileInputStream(classFile);
            FileChannel fileC = fis.getChannel();
            ByteArrayOutputStream baos = new
                    ByteArrayOutputStream();
            WritableByteChannel outC = Channels.newChannel(baos);
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            while (true) {
                int i = fileC.read(buffer);
                if (i == 0 || i == -1) {
                    break;
                }
                buffer.flip();
                outC.write(buffer);
                buffer.clear();
            }
            fis.close();
            return baos.toByteArray();
        } catch (IOException fnfe) {
            throw new ClassNotFoundException(className);
        }
    }

    private static String getClassFile(String name) {
        StringBuilder sb = new StringBuilder("/Users/admin/Downloads/calculate/target/classes");
        name = name.replace('.', File.separatorChar) + ".class";
        sb.append(File.separator + name);
        return sb.toString();
    }
}

public static DocumentBuilderFactory newInstance() {
    //根据抽象父类来获取一个子类的对象，抽象父类是通过启动类加载器加载，而子类是通过应用类加载器加载
    return FactoryFinder.find(
            /* The default property name according to the JAXP spec */
            DocumentBuilderFactory.class, // "javax.xml.parsers.DocumentBuilderFactory"
            /* The fallback implementation class name */
            "com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl");
}

private static final SecuritySupport ss = new SecuritySupport(); //在获取系统资源的时候用于检查访问控制的安全支持类

static <T> T find(Class<T> type, String fallbackClassName)
    throws FactoryConfigurationError
{
    //获取类的名称
    final String factoryId = type.getName();
    dPrint("find factoryId =" + factoryId);

    // Use the system property first
    try {
        //从系统属性中获取资源名称
        String systemProp = ss.getSystemProperty(factoryId);
        //如果该资源名称不为空，则返回type类的实例化对象
        if (systemProp != null) {
            dPrint("found system property, value=" + systemProp);
            return newInstance(type, systemProp, null, true);
        }
    }
    catch (SecurityException se) {
        if (debug) se.printStackTrace();
    }

    //尝试从$java.home/lib/jaxp.properties文件读取资源
    try {
        if (firstTime) {
            synchronized (cacheProps) {
                if (firstTime) {
                    String configFile = ss.getSystemProperty("java.home") + File.separator +
                        "lib" + File.separator + "jaxp.properties";
                    File f = new File(configFile);
                    firstTime = false;
                    if (ss.doesFileExist(f)) {
                        dPrint("Read properties file "+f);
                        cacheProps.load(ss.getFileInputStream(f));
                    }
                }
            }
        }
        final String factoryClassName = cacheProps.getProperty(factoryId);
        //如果可以读取，则返回实例化type类的对象
        if (factoryClassName != null) {
            dPrint("found in $java.home/jaxp.properties, value=" + factoryClassName);
            return newInstance(type, factoryClassName, null, true);
        }
    }
    catch (Exception ex) {
        if (debug) ex.printStackTrace();
    }

    //尝试用SPI方式
    T provider = findServiceProvider(type);
    if (provider != null) {
        return provider;
    }
    if (fallbackClassName == null) {
        throw new FactoryConfigurationError(
            "Provider for " + factoryId + " cannot be found");
    }

    dPrint("loaded from fallback value: " + fallbackClassName);
    return newInstance(type, fallbackClassName, null, true);
}

private static <T> T findServiceProvider(final Class<T> type) {
    try {
        return AccessController.doPrivileged(new PrivilegedAction<T>() {
            public T run() {
                //通过把type类实例，这里是DocumentBuilderFactory.class以及通过Thread.currentThread().getContextClassLoader()获取的应用类加载器
                //放入serviceLoader对象的惰性迭代器lookupIterator属性中
                final ServiceLoader<T> serviceLoader = ServiceLoader.load(type);
                
                final Iterator<T> iterator = serviceLoader.iterator();
                if (iterator.hasNext()) {
                    return iterator.next();
                } else {
                    return null;
                }
             }
        });
    } catch(ServiceConfigurationError e) {
        // It is not possible to wrap an error directly in
        // FactoryConfigurationError - so we need to wrap the
        // ServiceConfigurationError in a RuntimeException.
        // The alternative would be to modify the logic in
        // FactoryConfigurationError to allow setting a
        // Throwable as the cause, but that could cause
        // compatibility issues down the road.
        final RuntimeException x = new RuntimeException(
                "Provider for " + type + " cannot be created", e);
        final FactoryConfigurationError error =
                new FactoryConfigurationError(x, x.getMessage());
        throw error;
    }
}

public static <S> ServiceLoader<S> load(Class<S> service) {
    //获取一个当前线程的上下文加载器，该上下文加载器就是应用类加载器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}

public static <S> ServiceLoader<S> load(Class<S> service,
                                        ClassLoader loader)
{
    return new ServiceLoader<>(service, loader);
}

private final Class<S> service; //已经被启动类加载器加载过的类，这里指的是DocumentBuilderFactory.class

private final ClassLoader loader; //类加载器，用于判定获取的是哪一种类加载器，如启动类加载器或应用类加载器

private final AccessControlContext acc; //访问控制权限

private ServiceLoader(Class<S> svc, ClassLoader cl) {
    //如果svc类已经被加载了，返回该类实例，否则抛出异常
    service = Objects.requireNonNull(svc, "Service interface cannot be null");
    //传入的类加载器为应用类加载器，如果该应用类加载器不为空，则为应用类加载器，否则为启动类加载器
    loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
    acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
    reload();
}

private LinkedHashMap<String,S> providers = new LinkedHashMap<>(); //按照实例化顺序的缓存

private LazyIterator lookupIterator; //当前的惰性查找迭代器，ServiceLoader的内部类

public void reload() {
    //清空加载缓存
    providers.clear();
    //将DocumentBuilderFactory.class以及应用类加载器传入惰性查找迭代器中生成对象
    lookupIterator = new LazyIterator(service, loader);
}

private static final String PREFIX = "META-INF/services/";

private class LazyIterator
    implements Iterator<S>
{

    Class<S> service;
    ClassLoader loader;
    Enumeration<URL> configs = null;
    Iterator<String> pending = null;
    String nextName = null;

    private LazyIterator(Class<S> service, ClassLoader loader) {
        this.service = service;
        this.loader = loader;
    }

    private boolean hasNextService() {
        //如果nextName不为空，表示有下一个类实例
        if (nextName != null) {
            return true;
        }
        if (configs == null) {
            try {
                //获取META-INF/services/加类全名组成的路径
                String fullName = PREFIX + service.getName();
                //如果应用类加载器为空，从加载类的搜索路径查找指定名称的资源
                if (loader == null)
                    configs = ClassLoader.getSystemResources(fullName);
                //如果应用类加载器不为空，启用双亲加载器查找资源
                else
                    configs = loader.getResources(fullName);
            } catch (IOException x) {
                fail(service, "Error locating configuration files", x);
            }
        }
        while ((pending == null) || !pending.hasNext()) {
            if (!configs.hasMoreElements()) {
                return false;
            }
            pending = parse(service, configs.nextElement());
        }
        nextName = pending.next();
        return true;
    }

    /**
     * 从资源文件加载子类
     */
    private S nextService() {
        if (!hasNextService())
            throw new NoSuchElementException();
        String cn = nextName;
        nextName = null;
        Class<?> c = null;
        try {
            //使用应用类加载器loader加载子类c
            c = Class.forName(cn, false, loader);
        } catch (ClassNotFoundException x) {
            fail(service,
                 "Provider " + cn + " not found");
        }
        //如果c不是DocumentBuilderFactory.class的子类，抛出异常
        if (!service.isAssignableFrom(c)) {
            fail(service,
                 "Provider " + cn  + " not a subtype");
        }
        try {
            //将c的对象实例强转成DocumentBuilderFactory类型的对象
            S p = service.cast(c.newInstance());
            //添加进缓存
            providers.put(cn, p);
            return p;
        } catch (Throwable x) {
            fail(service,
                 "Provider " + cn + " could not be instantiated",
                 x);
        }
        throw new Error();          // This cannot happen
    }

    public boolean hasNext() {
        if (acc == null) {
            return hasNextService();
        } else {
            PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                public Boolean run() { return hasNextService(); }
            };
            return AccessController.doPrivileged(action, acc);
        }
    }

    public S next() {
        if (acc == null) {
            return nextService();
        } else {
            PrivilegedAction<S> action = new PrivilegedAction<S>() {
                public S run() { return nextService(); }
            };
            return AccessController.doPrivileged(action, acc);
        }
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }

}

public Iterator<S> iterator() {
    return new Iterator<S>() {
        //通过缓存获取已加载的迭代器集合
        Iterator<Map.Entry<String,S>> knownProviders
            = providers.entrySet().iterator();
        /**
         * 是否有加载的下一个类实例
         */
        public boolean hasNext() {
            //如果缓存中有下一个加载的类实例，返回true
            if (knownProviders.hasNext())
                return true;
            //如果缓存中没有，返回惰性查找迭代器中查找结果
            return lookupIterator.hasNext();
        }

        public S next() {
            //如果缓存中有下一个加载的类实例，直接从缓存中获取
            if (knownProviders.hasNext())
                return knownProviders.next().getValue();
            //如果缓存中没有，返回惰性查找迭代器的下一个类实例
            return lookupIterator.next();
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    };
}

@AllArgsConstructor
public class OrderClassLoader extends ClassLoader {
    private String fileName;

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        Class<?> re = findClass(name);
        if (re == null) {
            System.out.println("I can't load the class:" + name + " need help from parent");
            return super.loadClass(name, resolve);
        }
        return re;
    }

    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        Class<?> clazz = this.findLoadedClass(className);
        if (clazz == null) {
            try {
                byte[] bytes = loadClassBytes(className);
                clazz = defineClass(className,bytes,0,bytes.length);
            } catch (Exception e) {
//                e.printStackTrace();
                return null;
            }
        }
        return clazz;
    }

    private byte[] loadClassBytes(String className) throws ClassNotFoundException {
        try {
            //获取class文件的完整路径
            String classFile = getClassFile(className);
            FileInputStream fis = new FileInputStream(classFile);
            FileChannel fileC = fis.getChannel();
            ByteArrayOutputStream baos = new
                    ByteArrayOutputStream();
            WritableByteChannel outC = Channels.newChannel(baos);
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            while (true) {
                int i = fileC.read(buffer);
                if (i == 0 || i == -1) {
                    break;
                }
                buffer.flip();
                outC.write(buffer);
                buffer.clear();
            }
            fis.close();
            return baos.toByteArray();
        } catch (IOException fnfe) {
//            throw new ClassNotFoundException(className);
            return null;
        }
    }

    private String getClassFile(String name) {
        StringBuilder sb = new StringBuilder(fileName);
        name = name.replace('.', File.separatorChar) + ".class";
        sb.append(File.separator + name);
        return sb.toString();
    }
}

public class OrderClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException {
        OrderClassLoader myLoader = new OrderClassLoader("/Users/admin/Downloads/");
        Class<?> clz = myLoader.loadClass("com.guanjian.calculate.test.HelloLoader");
        System.out.println(clz.getClassLoader());

        System.out.println("==== Class Loader Tree ====");
        ClassLoader cl = clz.getClassLoader();
        while (cl != null) {
            System.out.println(cl);
            cl = cl.getParent();
        }
    }
}

public class OrderClassLoaderTest1 {
    public static void main(String[] args) {
        while (true) {
            try {
                OrderClassLoader myLoader = new OrderClassLoader("/Users/admin/Downloads/");
                Class<?> clz = myLoader.loadClass("com.guanjian.calculate.test.HelloLoader");
                Object demo = clz.newInstance();
                Method print = demo.getClass().getMethod("print", new Class[]{});
                print.invoke(demo,new Object[]{});
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class OrderClassLoaderTest1 {
    public static void main(String[] args) {
        while (true) {
            try {
                OrderClassLoader myLoader = new OrderClassLoader("/Users/admin/Downloads/");
                Class<?> clz = myLoader.loadClass("com.guanjian.calculate.test.HelloLoader");
                HelloLoader demo = (HelloLoader)clz.newInstance();
                Method print = demo.getClass().getMethod("print", new Class[]{});
                print.invoke(demo,new Object[]{});
                Thread.sleep(10000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

 at com.guanjian.calculate.test.OrderClassLoaderTest1.main(OrderClassLoaderTest1.java:11)