笔记]类加载器

topinking

浏览: 835233 次
性别:
来自: 北京

最近访客更多访客>>

itskyblue

sos303sos

hxgdragon

1310002415

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

应用服务器 Java EXT JVM 多线程

http://www.iteye.com/topic/68170

看了王森的《JAVA深度历险》，做了一个简单的学习笔记。
1. JAVA类装载器在装载类的时候是按需加载的，只有当一个类要使用(使用new 关键字来实例化一个类)的时候，类加载器才会加载这    个类并初始化。
    类Main:

java 代码

public class Main {
public static void main(String[] args) {
A a = new A();
a.print();
B b = new B();
b.print();
}
}

类A：

java 代码

public class A {
public void print() {
System.out.println("Using Class A");
}
}

类B：

java 代码

public class B {
public void print() {
System.out.println("Using Class B");
}
}

执行：java -varbose:class Main
执行结果：
    E:\DEV>java -verbose:class Main
    [Opened C:\Program Files\Java\jre1.5.0_11\lib\rt.jar] (类装载器会首先加载rt.jar加载基础类)
    .
    .
    [Loaded Main from file:/E:/DEV/] (类装载器载入相应类并初始化)
    [Loaded A from file:/E:/DEV/]
    Using Class A
    [Loaded B from file:/E:/DEV/]
    Using Class B
2. 让JAVA程序具有动态性
   使用显式方式来实现动态性，我们需要自己动手处理类载入时的细节部分。

     两种方法：
    ｜
    ＋－－隐式的：使用new关键字让类加载器按需求载入所需的类
    ｜
    ＋－－显式的：
               ｜
                     ＋－－由 java.lang.Class的forName()方法加载
                     ｜
               ＋－－由 java.lang.ClassLoader的loadClass()方法加载

    (1) 使用Class.forName()
    Class.forName()方法具有两个重载的方法：
            ＋－ public static Class forName(String className)
            ｜
            ＋－ public static Class forName(String className, boolean initialize,ClassLoader loader)
    参数说明：
        className - 所需类的完全限定名
        initialize - 是否必须初始化类(静态代码块的初始化)
        loader - 用于加载类的类加载器
调用只有一个参数的forName()方法等效于 Class.forName(className, true, loader)。
这两个方法，最后都要连接到原生方法forName0()，其定义如下：
private static native Class forName0(String name, boolean initialize,ClassLoader loader) throws ClassNotFoundException;
只有一个参数的forName()方法，最后调用的是:
forName0(className, true, ClassLoader.getCallerClassLoader());
而三个参数的forName()，最后调用的是:
forName0(name, initialize, loader);
所以，不管使用的是new 來实例化某个类、或是使用只有一个参数的Class.forName()方法，内部都隐含了“载入类＋运行静态代码块”的步骤。而使用具有三个参数的Class.forName()方法时，如果第二个参数为false，那么类加载器只会加载类，而不会初始化静态代码块，只有当实例化这个类的时候，静态代码块才会被初始化，静态代码块是在类第一次实例化的时候才初始化的。

    (2) 直接使用类加载器
       ＋— 获得对象所属的类 : getClass()方法
           ｜
           ＋— 获得该类的类加载器 : getClassLoader()方法

java 代码

public class Main3 {
public static void main(String[] args) throws Exception {
Main3 main3 = new Main3();
System.out.println("准备载入类");
ClassLoader loader = main3.getClass().getClassLoader();
Class clazzA = loader.loadClass(args[0]);
System.out.println("实例化类A");
A o1 = (A) clazzA.newInstance();
}
}

3 类加载器的层次

我们可以通过java.net.URLClassLoader这个类构建一个自己的类加载器，来载入自己所需要的类。
下面是JDK中的说明：

public class URLClassLoader
extends SecureClassLoader
该类加载器用于从指向 JAR 文件和目录的 URL 的搜索路径加载类和资源。这里假定任何以 '/' 结束的 URL 都是指向目录的。如果不是以该字符结束，则认为该 URL 指向一个将根据需要打开的 JAR 文件。

当启动JVM的时候，可以使用三个类加载器：引导（bootstrap）类加载器、扩展（extensions）类加载器、应用程序（application）类加载器。

1.引导类加载器仅仅负责加载核心的Java库，比如位于<JAVA_HOME>/jre/lib 目录下的vm.jar，core.jar。这个类加载器，是JVM核心部分，是用native代码写成的。

2. 扩展类加载器负责加载扩展路径下的代码，一般位于<JAVA_HOME>/jre/lib/ext 或者通过java.ext.dirs 这个系统属性指定的路径下的代码。这个类加载器是由sun.misc.Launcher$ExtClassLoader 实现的。

3.应用程序类加载器负责加载java.class.path（映射系统参数 CLASSPATH的值）路径下面的代码，这个类加载器是由 sun.misc.Launcher$AppClassLoader 实现的。

String bootClassPath = System.getProperty("sun.boot.class.path");

String extClassPath = System.getProperty("java.ext.dirs");

String appClassPath = System.getProperty("java.class.path");
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lihe2008125/archive/2009/02/05/3864983.aspx

开发者通常会使用如下语法通过类加载器机制加载属性文件：

Properties p = new Properties();

p.load(MyClass.class.getClassLoader().getResourceAsStream("myApp.properties"

));

这个意思是：如果MyClass 由扩展类加载器加载，而 myApp.properties 文件只能应用程序类加载器看到，则装入属性文件就会失败。

=========================

jvm classLoader architecture :

a, Bootstrap ClassLoader/启动类加载器
       主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作.

b, Extension ClassLoader/扩展类加载器
       主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作

c, System ClassLoader/系统类加载器
        主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作.

b, User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
        在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.

类加载器的特性：

1，每个ClassLoader都维护了一份自己的名称空间，同一个名称空间里不能出现两个同名的类。
2，为了实现java安全沙箱模型顶层的类加载器安全机制, java默认采用了 " 双亲委派的加载链 " 结构.
如下图:

Class Diagram：

类图中， BootstrapClassLoader是一个单独的java类，其实在这里，不应该叫他是一个java类。
因为，它已经完全不用java实现了。

它是在jvm启动时，就被构造起来的，负责java平台核心库。（具体上面已经有介绍）

启动类加载实现 (其实我们不用关心这块，但是有兴趣的，可以研究一下 ):

bootstrap classLoader 类加载原理探索
 www.iteye.com/topic/136885

自定义类加载器加载一个类的步骤 :

ClassLoader 类加载逻辑分析，以下逻辑是除 BootstrapClassLoader 外的类加载器加载流程:

java 代码

// 检查类是否已被装载过
Class c = findLoadedClass(name);
if (c == null ) {
// 指定类未被装载过
try {
if (parent != null ) {
// 如果父类加载器不为空，则委派给父类加载
c = parent.loadClass(name, false );
} else {
// 如果父类加载器为空，则委派给启动类加载加载
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
// 启动类加载器或父类加载器抛出异常后，当前类加载器将其
// 捕获，并通过findClass方法，由自身加载
c = findClass(name);
}
}

用Class.forName加载类
Class.forName使用的是被调用者的类加载器来加载类的.
这种特性, 证明了java类加载器中的名称空间是唯一的, 不会相互干扰.
即在一般情况下, 保证同一个类中所关联的其他类都是由当前类的类加载器所加载的.

java 代码

public static Class forName(String className)
throws ClassNotFoundException {
return forName0(className, true , ClassLoader.getCallerClassLoader());
}
/** Called after security checks have been made. */
private static native Class forName0(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException;

上图中 ClassLoader.getCallerClassLoader 就是得到调用当前forName方法的类的类加载器

线程上下文类加载器
java默认的线程上下文类加载器是系统类加载器(AppClassLoader).

java 代码

// Now create the class loader to use to launch the application
try {
loader = AppClassLoader.getAppClassLoader(extcl);
} catch (IOException e) {
throw new InternalError(
"Could not create application class loader" );
}
// Also set the context class loader for the primordial thread.
Thread.currentThread().setContextClassLoader(loader);

以上代码摘自sun.misc.Launch的无参构造函数Launch()。

使用线程上下文类加载器, 可以在执行线程中, 抛弃双亲委派加载链模式, 使用线程上下文里的类加载器加载类.
典型的例子有, 通过线程上下文来加载第三方库jndi实现, 而不依赖于双亲委派.
大部分java app服务器(jboss, tomcat..)也是采用contextClassLoader来处理web服务。
还有一些采用 hotswap 特性的框架, 也使用了线程上下文类加载器, 比如 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 类加载器实现:

java 代码

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
/**
* 可以重新载入同名类的类加载器实现
*
* 放弃了双亲委派的加载链模式.
* 需要外部维护重载后的类的成员变量状态.
*
* @author ken.wu
* @mail ken.wug@gmail.com
* 2007-9-28 下午01:37:43
*/
public class HotSwapClassLoader extends URLClassLoader {
public HotSwapClassLoader(URL[] urls) {
super (urls);
}
public HotSwapClassLoader(URL[] urls, ClassLoader parent) {
super (urls, parent);
}
public Class load(String name)
throws ClassNotFoundException {
return load(name, false );
}
public Class load(String name, boolean resolve)
throws ClassNotFoundException {
if ( null != super .findLoadedClass(name))
return reload(name, resolve);
Class clazz = super .findClass(name);
if (resolve)
super .resolveClass(clazz);
return clazz;
}
public Class reload(String name, boolean resolve)
throws ClassNotFoundException {
return new HotSwapClassLoader( super .getURLs(), super .getParent()).load(
name, resolve);
}
}

java 代码

public class A {
private B b;
public void setB(B b) {
this .b = b;
}
public B getB() {
return b;
}
}

java 代码

public class B {}

这个类的作用是可以重新载入同名的类，但是，为了实现hotswap, 老的对象状态
需要通过其他方式拷贝到重载过的类生成的全新实例中来。(A类中的b实例)

而新实例所依赖的B类如果与老对象不是同一个类加载器加载的，将会抛出类型转换异常(ClassCastException).

为了解决这种问题， HotSwapClassLoader自定义了load方法. 即当前类是由自身classLoader加载的，而内部依赖的类还是老对象的classLoader加载的.

java 代码

public class TestHotSwap {
public static void main(String args[]) {
A a = new A();
B b = new B();
a.setB(b);
System.out.printf("A classLoader is %s \n" , a.getClass().getClassLoader());
System.out.printf("B classLoader is %s \n" , b.getClass().getClassLoader());
System.out.printf("A.b classLoader is %s \n" , a.getB().getClass().getClassLoader());
HotSwapClassLoader c1 = new HotSwapClassLoader( new URL[]{ new URL( "file:\\e:\\test\\")} , a.getClass().getClassLoader());
Class clazz = c1.load(" test.hotswap.A ");
Object aInstance = clazz.newInstance();
Method method1 = clazz.getMethod(" setB ", B.class);
method1.invoke(aInstance, b);
Method method2 = clazz.getMethod(" getB ", null);
Object bInstance = method2.invoke(aInstance, null);
System.out.printf(" reloaded A.b classLoader is %s \n", bInstance.getClass().getClassLoader());
}
}

输出

A classLoader is sun.misc.Launcher$AppClassLoader@19821f
B classLoader is sun.misc.Launcher$AppClassLoader@19821f
A.b classLoader is sun.misc.Launcher$AppClassLoader@19821f
reloaded A.b classLoader is sun.misc.Launcher$AppClassLoader@19821f

JVM

java -verbose:class Main 显示调用的详细信息

classloader

java动态载入class的两种方式:

ClassLoader

static块在什么时候执行?

ClassLoader

Class类的实例.

classLoader

ClassLoader

自定义ClassLoader:

各个java类由哪些classLoader加载?

ClassLoader

ClassLoader hierachy:

ClassLoader

classloader

ClassLoader

NoClassDefFoundError和ClassNotFoundException

ClassLoader

分享到：

Java栈与堆 | Connection timeouts with the Apache comm ...

2009-08-27 19:29
浏览 1446
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论