深入理解Java类加载器(2)：线程上下文类加载器

绝地灬酷狼 2022-05-28 10:23 259阅读 0赞

# 1 线程上下文类加载器 #

线程上下文类加载器（context class loader）是从 JDK 1.2 开始引入的。类 java.lang.Thread中的方法 getContextClassLoader()和 setContextClassLoader(ClassLoader cl)用来获取和设置线程的上下文类加载器。如果没有通过 setContextClassLoader(ClassLoader cl)方法进行设置的话，线程将继承其父线程的上下文类加载器。Java 应用运行的初始线程的上下文类加载器是系统类加载器。在线程中运行的代码可以通过此类加载器来加载类和资源。

前面提到的类加载器的代理模式并不能解决 Java 应用开发中会遇到的类加载器的全部问题。Java 提供了很多服务提供者接口（Service Provider Interface，SPI），允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JCE、JNDI、JAXP 和 JBI 等。这些 SPI 的接口由 Java 核心库来提供，如 JAXP 的 SPI 接口定义包含在 javax.xml.parsers包中。这些 SPI 的实现代码很可能是作为 Java 应用所依赖的 jar 包被包含进来，可以通过类路径（CLASSPATH）来找到，如实现了 JAXP SPI 的 Apache Xerces所包含的 jar 包。SPI 接口中的代码经常需要加载具体的实现类。如 JAXP 中的 javax.xml.parsers.DocumentBuilderFactory类中的 newInstance()方法用来生成一个新的 DocumentBuilderFactory的实例。这里的实例的真正的类是继承自 javax.xml.parsers.DocumentBuilderFactory，由 SPI 的实现所提供的。如在 Apache Xerces 中，实现的类是 org.apache.xerces.jaxp.DocumentBuilderFactoryImpl。而问题在于，SPI 的接口是 Java 核心库的一部分，是由引导类加载器来加载的； SPI 实现的 Java 类一般是由系统类加载器来加载的。引导类加载器是无法找到 SPI 的实现类的，因为它只加载 Java 的核心库。它也不能代理给系统类加载器，因为它是系统类加载器的祖先类加载器。也就是说，类加载器的代理模式无法解决这个问题。

线程上下文类加载器正好解决了这个问题。如果不做任何的设置，Java 应用的线程的上下文类加载器默认就是系统上下文类加载器。在 SPI 接口的代码中使用线程上下文类加载器，就可以成功的加载到 SPI 实现的类。线程上下文类加载器在很多 SPI 的实现中都会用到。

Java默认的线程上下文类加载器是系统类加载器(AppClassLoader)。以下代码摘自sun.misc.Launch的无参构造函数Launch()。

**\[java\]** [view plain][] [copy][view plain]

1.  // Now create the class loader to use to launch the application
2.  try \{ 
3.   loader = AppClassLoader.getAppClassLoader(extcl); 
4.  \} catch (IOException e) \{ 
5.  thrownew InternalError( 
6.  "Could not create application class loader" ); 
7.  \} 
8.  
9.  // Also set the context class loader for the primordial thread.
10. Thread.currentThread().setContextClassLoader(loader);

使用线程上下文类加载器，可以在执行线程中抛弃双亲委派加载链模式，使用线程上下文里的类加载器加载类。典型的例子有：通过线程上下文来加载第三方库jndi实现，而不依赖于双亲委派。大部分java application服务器(jboss, tomcat..)也是采用contextClassLoader来处理web服务。还有一些采用hot swap特性的框架，也使用了线程上下文类加载器，比如 seasar (full stack framework in japenese)。  
　　线程上下文从根本解决了一般应用不能违背双亲委派模式的问题。使java类加载体系显得更灵活。随着多核时代的来临，相信多线程开发将会越来越多地进入程序员的实际编码过程中。因此，在编写基础设施时， 通过使用线程上下文来加载类，应该是一个很好的选择。  
　　当然，好东西都有利弊。使用线程上下文加载类，也要注意保证多个需要通信的线程间的类加载器应该是同一个，防止因为不同的类加载器导致类型转换异常(ClassCastException)。

defineClass(String name, byte\[\] b, int off, int len,ProtectionDomain protectionDomain)是java.lang.Classloader提供给开发人员，用来自定义加载class的接口。使用该接口，可以动态的加载class文件。例如在jdk中，URLClassLoader是配合findClass方法来使用defineClass，可以从网络或硬盘上加载class。而使用类加载接口，并加上自己的实现逻辑，还可以定制出更多的高级特性。

下面是一个简单的hot swap类加载器实现。hot swap即热插拔的意思，这里表示一个类已经被一个加载器加载了以后，在不卸载它的情况下重新再加载它一次。我们知道Java缺省的加载器对相同全名的类只会加载一次，以后直接从缓存中取这个Class object。因此要实现hot swap，必须在加载的那一刻进行拦截，先判断是否已经加载，若是则重新加载一次，否则直接首次加载它。我们从URLClassLoader继承，加载类的过程都代理给系统类加载器URLClassLoader中的相应方法来完成。

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader; 
2.  
3.  import java.net.URL; 
4.  import java.net.URLClassLoader; 
5.  
6.  /\*\*
7.   \* 可以重新载入同名类的类加载器实现
8.   \* 放弃了双亲委派的加载链模式，需要外部维护重载后的类的成员变量状态
9.   \*/
10. publicclass HotSwapClassLoader extends URLClassLoader \{ 
11. 
12. public HotSwapClassLoader(URL\[\] urls) \{ 
13. super(urls); 
14.  \} 
15. 
16. public HotSwapClassLoader(URL\[\] urls, ClassLoader parent) \{ 
17. super(urls, parent); 
18.  \} 
19. 
20. // 下面的两个重载load方法实现类的加载，仿照ClassLoader中的两个loadClass()
21. // 具体的加载过程代理给父类中的相应方法来完成
22. public Class<?> load(String name) throws ClassNotFoundException \{ 
23. return load(name, false); 
24.  \} 
25. 
26. public Class<?> load(String name, boolean resolve) throws ClassNotFoundException \{ 
27. // 若类已经被加载，则重新再加载一次
28. if (null != super.findLoadedClass(name)) \{ 
29. return reload(name, resolve); 
30.  \} 
31. // 否则用findClass()首次加载它
32.  Class<?> clazz = super.findClass(name); 
33. if (resolve) \{ 
34. super.resolveClass(clazz); 
35.  \} 
36. return clazz; 
37.  \} 
38. 
39. public Class<?> reload(String name, boolean resolve) throws ClassNotFoundException \{ 
40. returnnew HotSwapClassLoader(super.getURLs(), super.getParent()).load( 
41.  name, resolve); 
42.  \} 
43. \}

两个重载的load方法参数与ClassLoader类中的两个loadClass()相似。在load的实现中，用findLoadedClass()查找指定的类是否已经被祖先加载器加载了，若已加载则重新再加载一次，从而放弃了双亲委派的方式（这种方式只会加载一次）。若没有加载则用自身的findClass()来首次加载它。

下面是使用示例：

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader; 
2.  
3.  publicclass A \{ 
4.  
5.  private B b; 
6.  
7.  publicvoid setB(B b) \{ 
8.  this.b = b; 
9.   \} 
10. 
11. public B getB() \{ 
12. return b; 
13.  \} 
14. \}

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader; 
2.  
3.  publicclass B \{ 
4.  
5.  \}

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader; 
2.  
3.  import java.lang.reflect.InvocationTargetException; 
4.  import java.lang.reflect.Method; 
5.  import java.net.MalformedURLException; 
6.  import java.net.URL; 
7.  
8.  publicclass TestHotSwap \{ 
9.  
10. publicstaticvoid main(String args\[\]) throws MalformedURLException \{ 
11.  A a = new A(); // 加载类A
12.  B b = new B(); // 加载类B
13.  a.setB(b); // A引用了B，把b对象拷贝到A.b
14.  System.out.printf("A classLoader is %s\\n", a.getClass().getClassLoader()); 
15.  System.out.printf("B classLoader is %s\\n", b.getClass().getClassLoader()); 
16.  System.out.printf("A.b classLoader is %s\\n", a.getB().getClass().getClassLoader()); 
17. 
18. try \{ 
19.  URL\[\] urls = new URL\[\]\{ new URL("file:///C:/Users/JackZhou/Documents/NetBeansProjects/classloader/build/classes/") \}; 
20.  HotSwapClassLoader c1 = new HotSwapClassLoader(urls, a.getClass().getClassLoader()); 
21.  Class clazz = c1.load("classloader.A"); // 用hot swap重新加载类A
22.  Object aInstance = clazz.newInstance(); // 创建A类对象
23.  Method method1 = clazz.getMethod("setB", B.class); // 获取setB(B b)方法
24.  method1.invoke(aInstance, b); // 调用setB(b)方法，重新把b对象拷贝到A.b
25.  Method method2 = clazz.getMethod("getB"); // 获取getB()方法
26.  Object bInstance = method2.invoke(aInstance); // 调用getB()方法
27.  System.out.printf("Reloaded A.b classLoader is %s\\n", bInstance.getClass().getClassLoader()); 
28.  \} catch (MalformedURLException | ClassNotFoundException | 
29.  InstantiationException | IllegalAccessException | 
30.  NoSuchMethodException | SecurityException | 
31.  IllegalArgumentException | InvocationTargetException e) \{ 
32.  e.printStackTrace(); 
33.  \} 
34.  \} 
35. \}

运行输出：

**\[java\]** [view plain][] [copy][view plain]

1.  A classLoader is sun.misc.Launcher$AppClassLoader@73d16e93
2.  B classLoader is sun.misc.Launcher$AppClassLoader@73d16e93
3.  A.b classLoader is sun.misc.Launcher$AppClassLoader@73d16e93
4.  Reloaded A.b classLoader is sun.misc.Launcher$AppClassLoader@73d16e93

HotSwapClassLoader加载器的作用是重新加载同名的类。为了实现hot swap，一个类在加载过后，若重新再加载一次，则新的Class object的状态会改变，老的状态数据需要通过其他方式拷贝到重新加载过的类生成的全新Class object实例中来。上面A类引用了B类，加载A时也会加载B（如果B已经加载，则直接从缓存中取出）。在重新加载A后，其Class object中的成员b会重置，因此要重新调用setB(b)拷贝一次。你可以注释掉这行代码，再运行会抛出java.lang.NullPointerException，指示A.b为null。  
　　注意新的A Class object实例所依赖的B类Class object，如果它与老的B Class object实例不是同一个类加载器加载的， 将会抛出类型转换异常(ClassCastException)，表示两种不同的类。因此在重新加载A后，要特别注意给它的B类成员b传入外部值时，它们是否由同一个类加载器加载。为了解决这种问题， HotSwapClassLoader自定义的l/oad方法中，当前类（类A）是由自身classLoader加载的， 而内部依赖的类（类B）还是老对象的classLoader加载的。

# 2 何时使用Thread.getContextClassLoader()?    #

这是一个很常见的问题，但答案却很难回答。这个问题通常在需要动态加载类和资源的系统编程时会遇到。总的说来动态加载资源时，往往需要从三种类加载器里选择：系统或程序的类加载器、当前类加载器、以及当前线程的上下文类加载器。在程序中应该使用何种类加载器呢？  
　　系统类加载器通常不会使用。此类加载器处理启动应用程序时classpath指定的类，可以通过ClassLoader.getSystemClassLoader()来获得。所有的ClassLoader.getSystemXXX()接口也是通过这个类加载器加载的。一般不要显式调用这些方法，应该让其他类加载器代理到系统类加载器上。由于系统类加载器是JVM最后创建的类加载器，这样代码只会适应于简单命令行启动的程序。一旦代码移植到EJB、Web应用或者Java Web Start应用程序中，程序肯定不能正确执行。  
　　因此一般只有两种选择，当前类加载器和线程上下文类加载器。当前类加载器是指当前方法所在类的加载器。这个类加载器是运行时类解析使用的加载器，Class.forName(String)和Class.getResource(String)也使用该类加载器。代码中X.class的写法使用的类加载器也是这个类加载器。  
　　线程上下文类加载器在Java 2(J2SE)时引入。每个线程都有一个关联的上下文类加载器。如果你使用new Thread()方式生成新的线程，新线程将继承其父线程的上下文类加载器。如果程序对线程上下文类加载器没有任何改动的话，程序中所有的线程将都使用系统类加载器作为上下文类加载器。Web应用和Java企业级应用中，应用服务器经常要使用复杂的类加载器结构来实现JNDI（Java命名和目录接口)、线程池、组件热部署等功能，因此理解这一点尤其重要。  
　　为什么要引入线程的上下文类加载器？将它引入J2SE并不是纯粹的噱头，由于Sun没有提供充分的文档解释说明这一点，这使许多开发者很糊涂。实际上，上下文类加载器为同样在J2SE中引入的类加载代理机制提供了后门。通常JVM中的类加载器是按照层次结构组织的，目的是每个类加载器（除了启动整个JVM的原初类加载器）都有一个父类加载器。当类加载请求到来时，类加载器通常首先将请求代理给父类加载器。只有当父类加载器失败后，它才试图按照自己的算法查找并定义当前类。  
　　有时这种模式并不能总是奏效。这通常发生在JVM核心代码必须动态加载由应用程序动态提供的资源时。拿JNDI为例，它的核心是由JRE核心类(rt.jar)实现的。但这些核心JNDI类必须能加载由第三方厂商提供的JNDI实现。这种情况下调用父类加载器（原初类加载器）来加载只有其子类加载器可见的类，这种代理机制就会失效。解决办法就是让核心JNDI类使用线程上下文类加载器，从而有效的打通类加载器层次结构，逆着代理机制的方向使用类加载器。  
　　顺便提一下，XML解析API(JAXP)也是使用此种机制。当JAXP还是J2SE扩展时，XML解析器使用当前类加载器方法来加载解析器实现。但当JAXP成为J2SE核心代码后，类加载机制就换成了使用线程上下文加载器，这和JNDI的原因相似。  
　　好了，现在我们明白了问题的关键：这两种选择不可能适应所有情况。一些人认为线程上下文类加载器应成为新的标准。但这在不同JVM线程共享数据来沟通时，就会使类加载器的结构乱七八糟。除非所有线程都使用同一个上下文类加载器。而且，使用当前类加载器已成为缺省规则，它们广泛应用在类声明、Class.forName等情景中。即使你想尽可能只使用上下文类加载器，总是有这样那样的代码不是你所能控制的。这些代码都使用代理到当前类加载器的模式。混杂使用代理模式是很危险的。  
　　更为糟糕的是，某些应用服务器将当前类加载器和上下文类加器分别设置成不同的ClassLoader实例。虽然它们拥有相同的类路径，但是它们之间并不存在父子代理关系。想想这为什么可怕：记住加载并定义某个类的类加载器是虚拟机内部标识该类的组成部分，如果当前类加载器加载类X并接着执行它，如JNDI查找类型为Y的数据，上下文类加载器能够加载并定义Y，这个Y的定义和当前类加载器加载的相同名称的类就不是同一个，使用隐式类型转换就会造成异常。  
　　这种混乱的状况还将在Java中存在很长时间。在J2SE中还包括以下的功能使用不同的类加载器：  
　　（1）JNDI使用线程上下文类加载器。  
　　（2）Class.getResource()和Class.forName()使用当前类加载器。  
　　（3）JAXP使用上下文类加载器。  
　　（4）java.util.ResourceBundle使用调用者的当前类加载器。  
　　（5）URL协议处理器使用java.protocol.handler.pkgs系统属性并只使用系统类加载器。  
　　（6）Java序列化API缺省使用调用者当前的类加载器。  
　　这些类加载器非常混乱，没有在J2SE文档中给以清晰明确的说明。  
　　该如何选择类加载器？  
　　如若代码是限于某些特定框架，这些框架有着特定加载规则，则不要做任何改动，让框架开发者来保证其工作（比如应用服务器提供商，尽管他们并不能总是做对）。如在Web应用和EJB中，要使用Class.gerResource来加载资源。

在其他情况下，我们可以自己来选择最合适的类加载器。可以使用策略模式来设计选择机制。其思想是将“总是使用上下文类加载器”或者“总是使用当前类加载器”的决策同具体实现逻辑分离开。往往设计之初是很难预测何种类加载策略是合适的，该设计能够让你可以后来修改类加载策略。

考虑使用下面的代码，这是作者本人在工作中发现的经验。这儿有一个缺省实现，应该可以适应大部分工作场景：

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader.context; 
2.  
3.  /\*\*
4.   \* 类加载上下文，持有要加载的类
5.   \*/
6.  publicclass ClassLoadContext \{ 
7.  
8.  privatefinal Class m\_caller; 
9.  
10. publicfinal Class getCallerClass() \{ 
11. return m\_caller; 
12.  \} 
13. 
14.  ClassLoadContext(final Class caller) \{ 
15.  m\_caller = caller; 
16.  \} 
17. \}

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader.context; 
2.  
3.  /\*\*
4.   \* 类加载策略接口
5.   \*/
6.  publicinterface IClassLoadStrategy \{ 
7.  
8.   ClassLoader getClassLoader(ClassLoadContext ctx); 
9.  \}

**\[java\]** [view plain][] [copy][view plain]

1.  /\*\*
2.   \* 缺省的类加载策略，可以适应大部分工作场景
3.   \*/
4.  publicclass DefaultClassLoadStrategy implements IClassLoadStrategy \{ 
5.  
6.  /\*\*
7.   \* 为ctx返回最合适的类加载器，从系统类加载器、当前类加载器
8.   \* 和当前线程上下文类加载中选择一个最底层的加载器
9.   \* @param ctx
10.  \* @return 
11.  \*/
12. @Override
13. public ClassLoader getClassLoader(final ClassLoadContext ctx) \{ 
14. final ClassLoader callerLoader = ctx.getCallerClass().getClassLoader(); 
15. final ClassLoader contextLoader = Thread.currentThread().getContextClassLoader(); 
16.  ClassLoader result; 
17. 
18. // If 'callerLoader' and 'contextLoader' are in a parent-child
19. // relationship, always choose the child:
20. if (isChild(contextLoader, callerLoader)) \{ 
21.  result = callerLoader; 
22.  \} elseif (isChild(callerLoader, contextLoader)) \{ 
23.  result = contextLoader; 
24.  \} else \{ 
25. // This else branch could be merged into the previous one,
26. // but I show it here to emphasize the ambiguous case:
27.  result = contextLoader; 
28.  \} 
29. final ClassLoader systemLoader = ClassLoader.getSystemClassLoader(); 
30. // Precaution for when deployed as a bootstrap or extension class:
31. if (isChild(result, systemLoader)) \{ 
32.  result = systemLoader; 
33.  \} 
34. 
35. return result; 
36.  \} 
37. 
38. // 判断anotherLoader是否是oneLoader的child
39. privateboolean isChild(ClassLoader oneLoader, ClassLoader anotherLoader)\{ 
40. //...
41.  \} 
42. 
43. // ... more methods 
44. \}

决定应该使用何种类加载器的接口是IClassLoaderStrategy，为了帮助IClassLoadStrategy做决定，给它传递了个ClassLoadContext对象作为参数。ClassLoadContext持有要加载的类。

上面代码的逻辑很简单：如调用类的当前类加载器和上下文类加载器是父子关系，则总是选择子类加载器。对子类加载器可见的资源通常是对父类可见资源的超集，因此如果每个开发者都遵循J2SE的代理规则，这样做大多数情况下是合适的。  
　　当前类加载器和上下文类加载器是兄弟关系时，决定使用哪一个是比较困难的。理想情况下，Java运行时不应产生这种模糊。但一旦发生，上面代码选择上下文类加载器。这是作者本人的实际经验，绝大多数情况下应该能正常工作。你可以修改这部分代码来适应具体需要。一般来说，上下文类加载器要比当前类加载器更适合于框架编程，而当前类加载器则更适合于业务逻辑编程。  
　　最后需要检查一下，以便保证所选类加载器不是系统类加载器的父亲，在开发标准扩展类库时这通常是个好习惯。  
　　注意作者故意没有检查要加载资源或类的名称。Java XML API成为J2SE核心的历程应该能让我们清楚过滤类名并不是好想法。作者也没有试图检查哪个类加载器加载首先成功，而是检查类加载器的父子关系，这是更好更有保证的方法。  
　　下面是类加载器的选择器：

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader.context; 
2.  
3.  /\*\*
4.   \* 类加载解析器，获取最合适的类加载器
5.   \*/
6.  publicabstractclass ClassLoaderResolver \{ 
7.  
8.  privatestatic IClassLoadStrategy s\_strategy; // initialized in <clinit>
9.  privatestaticfinalint CALL\_CONTEXT\_OFFSET = 3; // may need to change if this class is redesigned
10. privatestaticfinal CallerResolver CALLER\_RESOLVER; // set in <clinit>
11. 
12. static \{ 
13. try \{ 
14. // This can fail if the current SecurityManager does not allow
15. // RuntimePermission ("createSecurityManager"):
16.  CALLER\_RESOLVER = new CallerResolver(); 
17.  \} catch (SecurityException se) \{ 
18. thrownew RuntimeException("ClassLoaderResolver: could not create CallerResolver: " \+ se); 
19.  \} 
20.  s\_strategy = new DefaultClassLoadStrategy(); //默认使用缺省加载策略
21.  \} 
22. 
23. /\*\*
24.  \* This method selects the best classloader instance to be used for
25.  \* class/resource loading by whoever calls this method. The decision
26.  \* typically involves choosing between the caller's current, thread context,
27.  \* system, and other classloaders in the JVM and is made by the \{@link IClassLoadStrategy\}
28.  \* instance established by the last call to \{@link \#setStrategy\}.
29.  \* 
30.  \* @return classloader to be used by the caller \['null' indicates the
31.  \* primordial loader\]
32.  \*/
33. publicstaticsynchronized ClassLoader getClassLoader() \{ 
34. final Class caller = getCallerClass(0); // 获取执行当前方法的类
35. final ClassLoadContext ctx = new ClassLoadContext(caller); // 创建类加载上下文
36. return s\_strategy.getClassLoader(ctx); // 获取最合适的类加载器
37.  \} 
38. 
39. publicstaticsynchronized IClassLoadStrategy getStrategy() \{ 
40. return s\_strategy; 
41.  \} 
42. 
43. publicstaticsynchronized IClassLoadStrategy setStrategy(final IClassLoadStrategy strategy) \{ 
44. final IClassLoadStrategy old = s\_strategy; // 设置类加载策略
45.  s\_strategy = strategy; 
46. return old; 
47.  \} 
48. 
49. /\*\*
50.  \* A helper class to get the call context. It subclasses SecurityManager
51.  \* to make getClassContext() accessible. An instance of CallerResolver
52.  \* only needs to be created, not installed as an actual security manager.
53.  \*/
54. privatestaticfinalclass CallerResolver extends SecurityManager \{ 
55. @Override
56. protected Class\[\] getClassContext() \{ 
57. returnsuper.getClassContext(); // 获取当执行栈的所有类，native方法
58.  \} 
59. 
60.  \} 
61. 
62. /\*
63.  \* Indexes into the current method call context with a given
64.  \* offset.
65.  \*/
66. privatestatic Class getCallerClass(finalint callerOffset) \{ 
67. return CALLER\_RESOLVER.getClassContext()\[CALL\_CONTEXT\_OFFSET 
68.  \+ callerOffset\]; // 获取执行栈上某个方法所属的类
69.  \} 
70. \}

可通过调用 ClassLoaderResolver.getClassLoader() 方法来获取类加载器对象，并使用其 ClassLoader 的接口如loadClass()等来加载类和资源。此外还可使用下面的 ResourceLoader 接口来取代 ClassLoader 接口：

**\[java\]** [view plain][] [copy][view plain]

1.  package classloader.context; 
2.  
3.  import java.net.URL; 
4.  
5.  publicclass ResourceLoader \{ 
6.  
7.  /\*\*
8.   \* 加载一个类
9.   \* 
10.  \* @param name
11.  \* @return 
12.  \* @throws java.lang.ClassNotFoundException 
13.  \* @see java.lang.ClassLoader\#loadClass(java.lang.String)
14.  \*/
15. publicstatic Class<?> loadClass(final String name) throws ClassNotFoundException \{ 
16. //获取最合适的类加载器
17. final ClassLoader loader = ClassLoaderResolver.getClassLoader(); 
18. //用指定加载器加载类
19. return Class.forName(name, false, loader); 
20.  \} 
21. 
22. /\*\*
23.  \* 加载一个资源
24.  \* 
25.  \* @param name
26.  \* @return 
27.  \* @see java.lang.ClassLoader\#getResource(java.lang.String)
28.  \*/
29. publicstatic URL getResource(final String name) \{ 
30. //获取最合适的类加载器
31. final ClassLoader loader = ClassLoaderResolver.getClassLoader(); 
32. //查找指定的资源
33. if (loader != null) \{ 
34. return loader.getResource(name); 
35.  \} else \{ 
36. return ClassLoader.getSystemResource(name); 
37.  \} 
38.  \} 
39. 
40. // ... more methods ...
41. \}

ClassLoadContext.getCallerClass()返回的类在ClassLoaderResolver或ResourceLoader使用，这样做的目的是让其能找到调用类的类加载器（上下文加载器总是能通过Thread.currentThread().getContextClassLoader()来获得）。注意调用类是静态获得的，因此这个接口不需现有业务方法增加额外的Class参数，而且也适合于静态方法和类初始化代码。具体使用时，可以往这个上下文对象中添加具体部署环境中所需的其他属性。

# 3 类加载器与Web容器    #

对于运行在 Java EE容器中的 Web 应用来说，类加载器的实现方式与一般的 Java 应用有所不同。不同的 Web 容器的实现方式也会有所不同。以 Apache Tomcat 来说，每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。这是 Java Servlet 规范中的推荐做法，其目的是使得 Web 应用自己的类的优先级高于 Web 容器提供的类。这种代理模式的一个例外是：Java 核心库的类是不在查找范围之内的。这也是为了保证 Java 核心库的类型安全。  
　　绝大多数情况下，Web 应用的开发人员不需要考虑与类加载器相关的细节。下面给出几条简单的原则：  
　　（1）每个 Web 应用自己的 Java 类文件和使用的库的 jar 包，分别放在 WEB-INF/classes和 WEB-INF/lib目录下面。  
　　（2）多个应用共享的 Java 类文件和 jar 包，分别放在 Web 容器指定的由所有 Web 应用共享的目录下面。  
　　（3）当出现找不到类的错误时，检查当前类的类加载器和当前线程的上下文类加载器是否正确。

# 4 类加载器与OSGi    #

OSGi是 Java 上的动态模块系统。它为开发人员提供了面向服务和基于组件的运行环境，并提供标准的方式用来管理软件的生命周期。OSGi 已经被实现和部署在很多产品上，在开源社区也得到了广泛的支持。Eclipse就是基于OSGi 技术来构建的。  
　　OSGi 中的每个模块（bundle）都包含 Java 包和类。模块可以声明它所依赖的需要导入（import）的其它模块的 Java 包和类（通过 Import-Package），也可以声明导出（export）自己的包和类，供其它模块使用（通过 Export-Package）。也就是说需要能够隐藏和共享一个模块中的某些 Java 包和类。这是通过 OSGi 特有的类加载器机制来实现的。OSGi 中的每个模块都有对应的一个类加载器。它负责加载模块自己包含的 Java 包和类。当它需要加载 Java 核心库的类时（以 java开头的包和类），它会代理给父类加载器（通常是启动类加载器）来完成。当它需要加载所导入的 Java 类时，它会代理给导出此 Java 类的模块来完成加载。模块也可以显式的声明某些 Java 包和类，必须由父类加载器来加载。只需要设置系统属性 org.osgi.framework.bootdelegation的值即可。  
　　假设有两个模块 bundleA 和 bundleB，它们都有自己对应的类加载器 classLoaderA 和 classLoaderB。在 bundleA 中包含类 com.bundleA.Sample，并且该类被声明为导出的，也就是说可以被其它模块所使用的。bundleB 声明了导入 bundleA 提供的类 com.bundleA.Sample，并包含一个类 com.bundleB.NewSample继承自 com.bundleA.Sample。在 bundleB 启动的时候，其类加载器 classLoaderB 需要加载类 com.bundleB.NewSample，进而需要加载类 com.bundleA.Sample。由于 bundleB 声明了类 com.bundleA.Sample是导入的，classLoaderB 把加载类 com.bundleA.Sample的工作代理给导出该类的 bundleA 的类加载器 classLoaderA。classLoaderA 在其模块内部查找类 com.bundleA.Sample并定义它，所得到的类 com.bundleA.Sample实例就可以被所有声明导入了此类的模块使用。对于以 java开头的类，都是由父类加载器来加载的。如果声明了系统属性 org.osgi.framework.bootdelegation=com.example.core.\*，那么对于包 com.example.core中的类，都是由父类加载器来完成的。  
　　OSGi 模块的这种类加载器结构，使得一个类的不同版本可以共存在 Java 虚拟机中，带来了很大的灵活性。不过它的这种不同，也会给开发人员带来一些麻烦，尤其当模块需要使用第三方提供的库的时候。下面提供几条比较好的建议：  
　　（1）如果一个类库只有一个模块使用，把该类库的 jar 包放在模块中，在 Bundle-ClassPath中指明即可。  
　　（2）如果一个类库被多个模块共用，可以为这个类库单独的创建一个模块，把其它模块需要用到的 Java 包声明为导出的。其它模块声明导入这些类。  
　　（3）如果类库提供了 SPI 接口，并且利用线程上下文类加载器来加载 SPI 实现的 Java 类，有可能会找不到 Java 类。如果出现了 NoClassDefFoundError异常，首先检查当前线程的上下文类加载器是否正确。通过 Thread.currentThread().getContextClassLoader()就可以得到该类加载器。该类加载器应该是该模块对应的类加载器。如果不是的话，可以首先通过 class.getClassLoader()来得到模块对应的类加载器，再通过 Thread.currentThread().setContextClassLoader()来设置当前线程的上下文类加载器。

# 总结    #

类加载器是 Java 语言的一个创新。它使得动态安装和更新软件组件成为可能。本文详细介绍了类加载器的相关话题，包括基本概念、代理模式、线程上下文类加载器、与 Web 容器和 OSGi 的关系等。开发人员在遇到 ClassNotFoundException和 NoClassDefFoundError等异常的时候，应该检查抛出异常的类的类加载器和当前线程的上下文类加载器，从中可以发现问题的所在。在开发自己的类加载器的时候，需要注意与已有的类加载器组织结构的协调。

参考文献：

[https://www.ibm.com/developerworks/cn/java/j-lo-classloader/][https_www.ibm.com_developerworks_cn_java_j-lo-classloader]

[http://www.blogjava.net/lihao336/archive/2009/09/17/295489.html][http_www.blogjava.net_lihao336_archive_2009_09_17_295489.html]

[http://kenwublog.com/structure-of-java-class-loader][http_kenwublog.com_structure-of-java-class-loader]

[view plain]: https://blog.csdn.net/zhoudaxia/article/details/35897057#
[https_www.ibm.com_developerworks_cn_java_j-lo-classloader]: https://www.ibm.com/developerworks/cn/java/j-lo-classloader/
[http_www.blogjava.net_lihao336_archive_2009_09_17_295489.html]: http://www.blogjava.net/lihao336/archive/2009/09/17/295489.html
[http_kenwublog.com_structure-of-java-class-loader]: http://kenwublog.com/structure-of-java-class-loader