双亲委派模型


by: dick 林敏悦

保护私人版权，尊重他人版权。转载请注明出处并附带页面链接

概念

双亲委派模型是指当类加载器收到类加载任务时，会先交由自己的父类加载器去尝试加载，最终会传递到BootstrapClassLoader，只有当父类加载器无法加载任务时才会尝试自己加载。

常见类加载器

BootstrapClassLoader（启动类加载器）：负责核心类库的加载，rt.jar，java.lang.*，JVM_HOME/lib目录下的，构造ExtClassLoader和AppClassLoader。

ExtClassLoader（拓展类加载器）：负责加载jre/lib/ext的jar。

AppClassLoader（系统类加载器）：加载应用程序的主函数类。

双亲委派模型的打破

Java SPI机制：SPI全称Service Provider Interface，用于接入产商自定义组件，例如JDBC。SPI的思想是系统抽象的各个模块有多种实现方案，例如JDBC，日志模块等。面向对象中，我们倾向于基于接口编程，模块直接不对实现类进行硬编码，否则会破坏开闭原则。为了能在模块装配的时候不需要在程序中显示声明，需要服务发现机制，SPI就是提供这样一个服务。

SPI的约定：当服务提供者提供服务接口后，在jar包下的META-INF/services/目录同时创建一个以服务接口命名的具体实现类文件。当外部程序装配模块的时候，能够以META-INF/services/里的配置文件找到具体的实现类并实例化。jdk中提供了java.util.ServiceLoader进行实现。

以JDBC为例，我们通常用以下方式获取数据库连接

1
2
String url = "jdbc:mysql://localhost:3306/testdb";    
Connection conn = java.sql.DriverManager.getConnection(url, "name", "password");

getConnection()继续调用了重载的getConnection方法

1
2
3
4
5
public static Connection getConnection(String url,
    java.util.Properties info) throws SQLException {

    return (getConnection(url, info, Reflection.getCallerClass()));
}

重载的方法，省略若干代码，看注释可以知道此时得到的callerCL为null，那么就会执行Thread.currentThread().getContextClassLoader()并赋值给callerCL，而且后面调用isDriverAllowed(aDriver.driver, callerCL)就是使用此时获取的类加载器进行类的加载。于是重点就是停留在Thread.currentThread().getContextClassLoader()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
private static Connection getConnection(
    String url, java.util.Properties info, Class<?> caller) throws SQLException {
    /*
     * When callerCl is null, we should check the application's
     * (which is invoking this class indirectly)
     * classloader, so that the JDBC driver class outside rt.jar
     * can be loaded from here.
     */
    ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
    synchronized(DriverManager.class) {
        // synchronize loading of the correct classloader.
        if (callerCL == null) {
            callerCL = Thread.currentThread().getContextClassLoader();
        }
    }

    ...
    ...
    ...

    for(DriverInfo aDriver : registeredDrivers) {
        // If the caller does not have permission to load the driver then
        // skip it.
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            ...
            ...
            ...
        } else {
            ...
            ...
            ...
        }
    }
    ...
    ...
    ...
}

private static boolean isDriverAllowed(Driver driver, ClassLoader classLoader) {
    boolean result = false;
    if(driver != null) {
        Class<?> aClass = null;
        try {
            aClass =  Class.forName(driver.getClass().getName(), true, classLoader);
        } catch (Exception ex) {
            result = false;
        }

         result = ( aClass == driver.getClass() ) ? true : false;
    }

    return result;
}

public ClassLoader getContextClassLoader() {
    if (contextClassLoader == null)
        return null;
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                               Reflection.getCallerClass());
    }
    return contextClassLoader;
}

看一下getContextClassLoader方法，发现仅仅只是简单的校验就获取了。我们回到一开始的java.sql.DriverManager.getConnection(url, “name”, “password”)，这里的DriverManager，我们看一下它的初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private DriverManager(){}

static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}

private static void loadInitialDrivers() {

    ...
    ...
    ...
    
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}

public static ClassLoader getSystemClassLoader() {
    initSystemClassLoader();
    if (scl == null) {
        return null;
    }
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkClassLoaderPermission(scl, Reflection.getCallerClass());
    }
    return scl;
}

构造方法被private修饰阻止了实例化，那么看一下静态代码块的loadInitialDrivers方法，省略若干代码，我们看一下ClassLoader.getSystemClassLoader()，发现了initSystemClassLoader()，继续往下看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
private static synchronized void initSystemClassLoader() {
    if (!sclSet) {
        if (scl != null)
            throw new IllegalStateException("recursive invocation");
        sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
        if (l != null) {
            Throwable oops = null;
            scl = l.getClassLoader();
            try {
                scl = AccessController.doPrivileged(
                    new SystemClassLoaderAction(scl));
            } catch (PrivilegedActionException pae) {
                oops = pae.getCause();
                if (oops instanceof InvocationTargetException) {
                    oops = oops.getCause();
                }
            }
            if (oops != null) {
                if (oops instanceof Error) {
                    throw (Error) oops;
                } else {
                    // wrap the exception
                    throw new Error(oops);
                }
            }
        }
        sclSet = true;
    }
}

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

这里就是实现的关键，注意initSystemClassLoader的以下代码段

1
2
3
4
5
6
7
8
9
10
11
12
sun.misc.Launcher l = sun.misc.Launcher.getLauncher();

scl = l.getClassLoader();
try {
    scl = AccessController.doPrivileged(
        new SystemClassLoaderAction(scl));
} catch (PrivilegedActionException pae) {
    oops = pae.getCause();
    if (oops instanceof InvocationTargetException) {
        oops = oops.getCause();
    }
}

看一下getLauncher()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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);
    
    ...
    ...
    ...

}

发现这里先获取了当前的系统加载器，然后将系统加载器，然后将系统加载器作为线程上下文加载器的父类，相当于构造链表一样。我们再看一下new SystemClassLoaderAction(scl)，发现这个类居然有个run方法，而且是使用java.system.class.loader作为实现的线程上下文加载器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SystemClassLoaderAction(ClassLoader parent) {
    this.parent = parent;
}

public ClassLoader run() throws Exception {
    String cls = System.getProperty("java.system.class.loader");
    if (cls == null) {
        return parent;
    }

    Constructor<?> ctor = Class.forName(cls, true, parent)
        .getDeclaredConstructor(new Class<?>[] { ClassLoader.class });
    ClassLoader sys = (ClassLoader) ctor.newInstance(
        new Object[] { parent });
    Thread.currentThread().setContextClassLoader(sys);
    return sys;
}

到这里我们可以得出结论：对于SPI，通过配置文件java.system.class.loader的方式实现了额外的线程上下文加载器并用于加载SPI组件，于是就打破了双亲委派模型。其实我们平时实现自定义类加载器的方式也是打破双亲委派模型，我们通过重写findClass（1.2之前是通过重写loadClass）阻止使用双亲委派模型。

ps：为什么要使用自定义类加载器？因为系统类加载器只会加载指定目录下的class文件，想加载自己的文件就可以通过自定义ClassLoader，可以用于文件改动后不想重启Java程序的热加载。

Sub

扫码关注微信公众号，随时随地，掌握最新技术资讯

微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我们是<br>深圳梅沙科技后端团队<br><br>这里是我们的知识集中营<br>欢迎各路大佬交流学习