JavaChen on JavaJava Core

Java Concurrency Annotations

JavaChen — Tue, 07 Jun 2011 15:34:01 +0000

在JGroups源码中发现了GuardedBy这个注解：

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.SOURCE)
public @interface GuardedBy {
    String value();
}

该注解的Retention的value为RetentionPolicy.SOURCE，这个很少见。一般该值都是设为RetentionPolicy.RUNTIME（这个见得更多）或RetentionPolicy.CLASS。

该注解有什么用呢？看看该注解的注释：

/**
 * Copyright (c) 2005 Brian Goetz and Tim Peierls
 * Released under the Creative Commons Attribution License
 * (http://creativecommons.org/licenses/by/2.5)
 * Official home: http://www.jcip.net
 * Adopted from Java Concurrency in Practice. This annotation defines the
 * monitor that protects the variable annotated by @GuardedBy, e.g.
 * @GuardedBy("lock") or @GuardedBy("this")
 * @author Bela Ban
 */

从上可以看出该注解是从Java Concurrency in Practice引入过来的，目的是为了定义一个监视器保卫类的变量，其实也就是为了控制线程的并发。这样，也就涉及到Java的并发编程了。

Java并发编程中，用到了一些专门为并发编程准备的 Annotation。在《Java Concurrency in Practice》的附录A中有讲到下面的并发注解，下面的一段在网上很容易搜到，就直接拷贝过来了。

Java并发注解主要包括三类：
1、类 Annotation（注解）
就像名字一样，这些注解是针对类的。主有要以下三个：
@Immutable
@ThreadSafe
@NotThreadSafe

@ThreadSafe 是表示这个类是线程安全的。具体是否真安全，那要看实现者怎么实现的了，反正打上这个标签只是表示一下。不线程安全的类打上这个注解也没事儿。
@Immutable 表示，类是不可变的，包含了　@ThreadSafe　的意思。
@NotThreadSafe 表示这个类不是线程安全的。如果是线程安全的非要打上这个注解，那也不会报错。

这三个注解，对用户和维护者是有益的，用户可以立即看出来这个类是否是线程安全的，维护者则是可以根据这个注解，重点检查线程安全方面。另外，代码分析工具(如findbugs)可能会利用这个注解。

2、域 Annotation（注解）
域注解是对类里面成员变量加的注解。

3、方法 Annotation（注解）
方法注解是对类里面方法加的注解。
域注解和方法注解都是用@GuardedBy( lock )来标识。里面的Lock是告诉维护者：这个状态变量，这个方法被哪个锁保护着。这样可以强烈的提示类的维护者注意这里。
@GuardedBy( lock )有以下几种使用形式：

@GuardedBy( “this” ) 受对象内部锁保护
@GuardedBy( “fieldName” ) 受与fieldName引用相关联的锁保护。
@GuardedBy( “ClassName.fieldName” ) 受一个类的静态field的锁保存。
@GuardedBy( “methodName()” ) 锁对象是 methodName() 方法的返值，受这个锁保护。
@GuardedBy( “ClassName.class” ) 受 ClassName类的直接锁对象保护。而不是这个类的某个实例的锁对象。

Java Concurrency in Practice中对并发注解的相关介绍：
设计线程安全的类有如下准则：

识别出哪些变量将改变类的状态
识别出约束状态变量的不变条件
建立起规则，用于管理并发访问状态的状态

如果一个对象的field都是由基本数据类型(int long等)组成的，则所有这些field就构成了对象的全部状态。如果对象的field中还包含引用，则对象状态还要包括这些引用变量中的隐含数据。例如LinkedList中的Node。为了方便后人阅读代码，应该在代码处对同步机制作出注释，特别是哪个类由哪个锁所保护，如下所示：

^?View Code JAVA

@ThreadSafe
public final class Counter {
    @GuardedBy("this")  private long value = 0;
 
    public synchronized  long getValue() {
        return value;
    }
 
    public  synchronized  long increment() {
        if (value == Long.MAX_VALUE)
            throw new IllegalStateException("counter overflow");
        return ++value;
    }
}

上面的例子中，Counter类是不可修改的，内部所有方法都是synchronized的，所以该类是线程安全的，用@ThreadSafe注解标注该类就是为了告诉使用者和维护站该类是线程安全的，不需要再对该类进行同步操作。

上面的例子是用synchronized关键字对方法进行同步，在java 5中还支持使用同步锁进行同步，例子如下：

^?View Code JAVA

public class PrivateLock {
    private final Object myLock = new Object();
    @GuardedBy("myLock") Widget widget;
 
    void someMethod() {
        synchronized(myLock) {
            // Access or modify the state of widget
        }
    }
}

这里用到了Java监视器，Java监视器是另一种线程安全的设计模式。

它自己创建了一个Object作为锁。Vector、Hashtable等都使用了类似的设计模式。使用这种私有锁而不是将对象作为锁（synchronized方法）的好处是：使得外界无法直接参与作用同步机制，防止了意外的发生。

来看一个例子：

^?View Code JAVA

@ThreadSafe
public class MonitorVehicleTracker {
@GuardedBy(“this”)
private final Map&lt;String, MutablePoint&gt; locations;
 
public MonitorVehicleTracker(Map&lt;String, MutablePoint&gt; locations) {
     this.locations = deepCopy(locations);
}
 
public synchronized Map&lt;String, MutablePoint&gt; getLocations() {
     return deepCopy(locations);
}
 
public synchronized  MutablePoint getLocation(String id) {
     MutablePoint loc = locations.get(id);
     return loc == null ? null : new MutablePoint(loc);
}
 
public synchronized  void setLocation(String id, int x, int y) {
     MutablePoint loc = locations.get(id);
     if (loc == null)
          throw new IllegalArgumentException(“No such ID: ” + id);
     loc.x = x;
     loc.y = y;
}
 
private static Map&lt;String, MutablePoint&gt; deepCopy(
        Map&lt;String, MutablePoint&gt; m) {
     Map&lt;String, MutablePoint&gt; result =new HashMap&lt;String, MutablePoint&gt;();
     for (String id : m.keySet())
         result.put(id, new MutablePoint(m.get(id)));
     return Collections.unmodifiableMap(result);
   }
}
 
@NotThreadSafe
public class MutablePoint {
    public int x, y;
 
    public MutablePoint() { x = 0; y = 0; }
    public MutablePoint(MutablePoint p) {
        this.x = p.x;
        this.y = p.y;
    }
}

可以注意到，MonitorVehicleTracker是一个线程安全的类。然而由于MutablePoint不是线程安全的，所以在从这个类返回的任何包含MutablePoint类都是经过拷贝的副本。这是常用的一个技巧，否则必须在程序所有地方对MutablePoint操作的时候加上同步控制。

Java监视器模式可以很好地解决由非线程安全field构成的对象的并发访问问题。但对于field都是线程安全的情况，有时并不必这么做。对于线程安全的类就可以用@Immutable标注该类是不可变的，是线程安全的。

改用线程安全的点类（因为不可变所以线程安全）：

^?View Code JAVA

@Immutable
public class Point {
    public final int x, y;
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

我们将该类用于下面代码中：

^?View Code JAVA

@ThreadSafe
public class DelegatingVehicleTracker {
    private final ConcurrentMap&lt;String, Point&gt; locations;
    private final Map&lt;String, Point&gt; unmodifiableMap;
 
    public DelegatingVehicleTracker(Map&lt;String, Point&gt; points) {
        locations = new ConcurrentHashMap&lt;String, Point&gt;(points);
        unmodifiableMap = Collections.unmodifiableMap(locations);
    }
 
    public Map&lt;String, Point&gt; getLocations() {
        return unmodifiableMap;
    }
 
    public Point getLocation(String id) {
        return locations.get(id);
    }
 
    public void setLocation(String id, int x, int y) {
        if (locations.replace(id, new Point(x, y)) == null)
            throw new IllegalArgumentException(
                "invalid vehicle name: " + id);
    }
}

因为ConcurrentMap保证了线程安全，所以DelegatingVehichleTracker可以不用再做同步控制了，这样该类也是线程安全的了，所以该类被@ThreadSafe注解。

通过以上几个例子，基本上知道了同步注解的用法。对各种同步措施，无论是synchronized、volatile还是其他线程安全的class进行注释是非常必要的。为了方便使用者和开发者，建议使用同步注解对线程安全和不安全的类进行注解。

参考文章：
1.Java同步注解（Annotation)解释 http://kongjian.baidu.com/plan4s/blog/item/28748a26bd373b128b82a1ca.html
2.Java Concurrency in Practice读书笔记第四章 http://www.coder4.com/archives/895
3.Java Concurrency in Practice http://www.jcip.net

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

commons-lang-1.0中的EqualsBuilder和HashCodeBuilder

JavaChen — Sat, 26 Feb 2011 11:49:10 +0000

CompareToBuilder是对jdk中compareTo的一个扩展，提供了一个很好的compareTo()方法，来比较两个对象是否相等。
同样EqualsBuilder和HashCodeBuilder分别是对equals和hashCode方法的扩展。其实，参照CompareToBuilder的实现方式应该很容易理解EqualsBuilder和HashCodeBuilder方式，他们三者都是一种Builder，差别的是具体的实现方式或功能不一样而已，抽象出不同点，他们三者在结构上就是大同小异了。

EqualsBuilder类的核心代码：

^?View Code JAVA

public class EqualsBuilder {
 
    private boolean isEquals;
 
    public EqualsBuilder() {
        super();
        isEquals = true;
    }
 
    public static boolean reflectionEquals(Object lhs, Object rhs) {
        return reflectionEquals(lhs, rhs, false);
    }
 
    public static boolean reflectionEquals(Object lhs, Object rhs, 
            boolean testTransients) {
        if (lhs == rhs) {
            return true;
        }
        if (lhs == null || rhs == null) {
            return false;
        }
        Class c1 = lhs.getClass();
        if (!c1.isInstance(rhs)) {
            return false;
        }
        Field[] fields = c1.getDeclaredFields();
        Field.setAccessible(fields, true);
        EqualsBuilder equalsBuilder = new EqualsBuilder();
        for (int i = 0; i < fields.length && equalsBuilder.isEquals; ++i) {
            Field f = fields[i];
            if (testTransients || !Modifier.isTransient(f.getModifiers())) {
                if (!Modifier.isStatic(f.getModifiers())) {
                    try {
                        equalsBuilder.append(f.get(lhs), f.get(rhs));
                    } catch (IllegalAccessException e) {
                        //this can't happen. Would get a Security exception instead
                        //throw a runtime exception in case the impossible happens.
                        throw new InternalError("Unexpected IllegalAccessException");
                    }
                }
            }
        }
        return equalsBuilder.isEquals();
    }
 
    public EqualsBuilder append(Object lhs, Object rhs) {
        if (isEquals == false) {
            return this;
        }
        if (lhs == rhs) {
            return this;
        }
        if (lhs == null || rhs == null) {
            isEquals = false;
            return this;
        }
        Class lhsClass = lhs.getClass();
        if (!lhsClass.isArray()) {
            //the simple case, not an array, just test the element 
            isEquals = lhs.equals(rhs);
        } else {
            //'Switch' on type of array, to dispatch to the correct handler
            // This handles multi dimensional arrays
            if (lhs instanceof long[]) {
                append((long[]) lhs, (long[]) rhs);
            } else if (lhs instanceof int[]) {
                append((int[]) lhs, (int[]) rhs);
            } else if (lhs instanceof short[]) {
                append((short[]) lhs, (short[]) rhs);
            } else if (lhs instanceof char[]) {
                append((char[]) lhs, (char[]) rhs);
            } else if (lhs instanceof byte[]) {
                append((byte[]) lhs, (byte[]) rhs);
            } else if (lhs instanceof double[]) {
                append((double[]) lhs, (double[]) rhs);
            } else if (lhs instanceof float[]) {
                append((float[]) lhs, (float[]) rhs);
            } else if (lhs instanceof boolean[]) {
                append((boolean[]) lhs, (boolean[]) rhs);
            } else {
                // Not an array of primitives
                append((Object[]) lhs, (Object[]) rhs);
            }
        }
        return this;
    }
 
}

将上段代码和CompareToBuilder的对应代码相比较，你会发现他们基本上是相同的，唯一不同的是在于具体的append方法，我们来看看他们两者的各自的append是怎么样的.

CompareToBuilder的append方法：

    public CompareToBuilder append(long lhs, long rhs) {
        if (comparison != 0) {
            return this;
        }
        comparison = ((lhs < rhs) ? -1 : ((lhs > rhs) ? 1 : 0));
        return this;
    }

EqualsBuilder 的append方法：

^?View Code JAVA

    public EqualsBuilder append(long lhs, long rhs) {
        if (isEquals == false) {
            return this;
        }
        isEquals = (lhs == rhs);
        return this;
    }

这样就能够发现他们的相同点和不同点了，同样，调用EqualsBuilder的方法和CompareToBuilder类似，你应该知道了。

总结：
1.三者都用到了反射、链式结构来实现各自的逻辑，整体的代码结构是一样的。反射的方法名都是reflectionXXX，望名知义，实现具体操作逻辑的方法都叫append，从方法名可以联想到StringBuffer类，很容易想到该方法使用了链式结构。
2.类名都叫XXXBuilder，为什么这样起名？是否与Builder模式相关？其实，这样取名只是说明这三个类都是构造类，体现命名的规范。

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

commons-lang-1.0中的CompareToBuilder

JavaChen — Sat, 26 Feb 2011 11:20:29 +0000

CompareToBuilder是对jdk中compareTo的一个扩展，提供了一个很好的compareTo()方法，来比较两个对象是否相等。
这个类通常与EqualsBuilder（对equals方法的扩展）和HashCodeBuilder（对hashcode的扩展）两个类配合使用。
用这个类比较两个对象是否相等的时候，static和transient成员变量会被忽略。
该类中有一个reflectionCompare方法，使用反射决定哪些属性需要被用于测试或是比较两个对象是否相等。对于对象的私有属性，需要用Field.setAccessible()方法修改属性的可见性。除非拥有合适的权限，否则在java的权限管理器下比较会失败。当然，使用反射会比直接比较两个对象是否相等要慢。

该类的核心代码：

^?View Code JAVA

public class CompareToBuilder {
 
    private int comparison;
 
    public CompareToBuilder() {
        super();
        comparison = 0;
    }
 
 
    public static int reflectionCompare(Object lhs, Object rhs) {
        return reflectionCompare(lhs, rhs, false);
    }
 
    public static int reflectionCompare(Object lhs, Object rhs, 
            boolean testTransients) {
        //判断是否相等
        if (lhs == rhs) {
            return 0;
        }
        //是否有空指针
        if (lhs == null || rhs == null) {
            throw new NullPointerException();
        }
        //类型是否一致
        Class c1 = lhs.getClass();
        if (!c1.isInstance(rhs)) {
            throw new ClassCastException();
        }
        Field[] fields = c1.getDeclaredFields();
        //修改属性的可见性
        Field.setAccessible(fields, true);
        //内部创建一个CompareToBuilder对象，构成链式结构
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        //只有当当前的两个属性相等时候（comparison == 0），才继续往下比较
        for (int i = 0; i < fields.length && compareToBuilder.comparison == 0; ++i) {
            Field f = fields[i];
            //是否是临时属性
            if (testTransients || !Modifier.isTransient(f.getModifiers())) {
            	//是否是静态属性
                if (!Modifier.isStatic(f.getModifiers())) {
                    try {
                        compareToBuilder.append(f.get(lhs), f.get(rhs));
                    } catch (IllegalAccessException e) {
                        //this can't happen. Would get a Security exception instead
                        //throw a runtime exception in case the impossible happens.
                        throw new InternalError("Unexpected IllegalAccessException");
                    }
                }
            }
        }
        return compareToBuilder.toComparison();
    }
 
    public CompareToBuilder append(Object lhs, Object rhs) {
        if (comparison != 0) {
            return this;
        }
        if (lhs == rhs) {
            return this;
        }
        if (lhs == null || rhs == null) {
            throw new NullPointerException();
        }
        Class lhsClass = lhs.getClass();
        if (!lhsClass.isArray()) {
            //the simple case, not an array, just test the element 
            comparison = ((Comparable) lhs).compareTo(rhs);
        } else {
            //'Switch' on type of array, to dispatch to the correct handler
            // This handles multi dimensional arrays
            if (lhs instanceof long[]) {
                append((long[]) lhs, (long[]) rhs);
            } else if (lhs instanceof int[]) {
                append((int[]) lhs, (int[]) rhs);
            } else if (lhs instanceof short[]) {
                append((short[]) lhs, (short[]) rhs);
            } else if (lhs instanceof char[]) {
                append((char[]) lhs, (char[]) rhs);
            } else if (lhs instanceof byte[]) {
                append((byte[]) lhs, (byte[]) rhs);
            } else if (lhs instanceof double[]) {
                append((double[]) lhs, (double[]) rhs);
            } else if (lhs instanceof float[]) {
                append((float[]) lhs, (float[]) rhs);
            } else if (lhs instanceof boolean[]) {
                append((boolean[]) lhs, (boolean[]) rhs);
            } else {
                // Not an array of primitives
                append((Object[]) lhs, (Object[]) rhs);
            }
        }
        return this;
    }
}

该类的使用方法：
1.重写一个类的comapareTo方法,该类需要继承Comparable接口。这种方法是比较两个对象所有属性是否相等来判断两个对象是否相等：
<

^?View Code JAVA

public int comapareTo(Object o) {
     MyClass rhs = (MyClass) o;
     return new CompareToBuilder()
                  .append(field1, rhs.field1)
                  .append(field2, rhs.field2)
                  .appendb(field3, rhs.field3)
                  .toComparison();
}

2.直接比较两个对象是否相等，需要用到CompareToBuilder的reflectionCompare反射方法，这种方法自动去判断两个对象的所有属性是否相等。

^?View Code JAVA

1
2
3

 public int compareTo(Object o) {
    return CompareToBuilder.reflectionCompare(this, obj);
 }

最后需要注意的是compareTo的逻辑需要与equals和hashcode保持一致性。

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

SAX解析XML的一点介绍

JavaChen — Sat, 04 Dec 2010 15:51:19 +0000

SAX (Simple API for XML) 和 DOM (Document Object Model) 是当前两个主要的XML API，几乎所有商用的xml 解析器都同时实现了这两个接口。
DOM 虽然是 W3C 的标准，提供了标准的解析方式，但它的解析效率一直不尽如人意，因为使用DOM解析XML时，解析器读入整个文档并构建一个驻留内存的树结构（节点树），然后您的代码才可以使用 DOM 的标准接口来操作这个树结构。但大部分情况下我们只对文档的部分内容感兴趣，根本就不用先解析整个文档，并且从节点树的根节点来索引一些我们需要的数据也是非常耗时的。
Simple API for XML（简称SAX）是个循序存取XML的解析器API。SAX提供一个机制从XML文件读取资料。它是除了文档对象模型（DOM）的另外一种流行选择。
SAX是Simple API for XML的缩写，它并不是由W3C官方所提出的标准，可以说是“民间”的事实标准。实际上，它是一种社区性质的讨论产物。
SAX 允许您在读取文档时处理它，从而不必等待整个文档被存储之后才采取操作。它不涉及 DOM 所必需的开销和概念跳跃。 SAX API是一个基于事件的API ，适用于处理数据流，即随着数据的流动而依次处理数据。SAX API在其解析您的文档时发生一定事件的时候会通知您。在您对其响应时，您不作保存的数据将会被抛弃。
XML属性也作为传给元素事件资料的一部份。

SAX 处理是单方向性的；解析过的资料无法在不重新开始的情况下再次读取。

因为SAX事件驱动的本质，处理文件通常会比DOM风格的解析器快。内存存取耗时，所以DOM较大的内存使用也是一个效能议题。
因为SAX的本质，从磁盘串流读取是可行的。无法放入内存的XML文件只可能使用SAX解析器（或另外的串流XML解析器）来处理。

缺点

SAX事件驱动的模型对于XML解析很有用，但它确实有某些缺点。某些种类的XML验证需要存取整份文件。

例如，一个DTD IDREF属性需要文件内有项目使用指定字串当成DTD ID属性。要在SAX解析器内验证，必须追踪每个之前遇过的ID和IDREF属性，检查是否有任何相符。更甚者，一个IDREF找不到对应的ID，使用者只会在整份文件都解析完后才发现，若这种连结对于建立有效输出是重要的，那用在处理整份文件的时间只是浪费。
另外，某些XML处理仅要求存取整份文件。举例来说，XSLT及XPath需要能够任何时间存取任何解析过的XML树。当SAX以用来建构此树时，DOM解析器在设计上已经是如此了。

如何在 SAX 和 DOM 之间选择

选择 DOM 还是选择 SAX，这取决于下面几个因素：
1.应用程序的目的：如果打算对数据作出更改并将它输出为 XML，那么在大多数情况下，DOM 是适当的选择。并不是说使用 SAX 就不能更改数据，但是该过程要复杂得多，因为您必须对数据的一份拷贝而不是对数据本身作出更改。
2.数据容量： 对于大型文件，SAX 是更好的选择。
数据将如何使用：如果只有数据中的少量部分会被使用，那么使用 SAX 来将该部分数据提取到应用程序中可能更好。另一方面，如果您知道自己以后会回头引用已处理过的大量信息，那么 SAX 也许不是恰当的选择。
3.对速度的需要： SAX 实现通常要比 DOM 实现更快。
SAX 和 DOM 不是相互排斥的，记住这点很重要。您可以使用 DOM 来创建 SAX 事件流，也可以使用 SAX 来创建 DOM 树。事实上，用于创建 DOM 树的大多数解析器实际上都使用 SAX 来完成这个任务！

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

Java ClassLoader

JavaChen — Sat, 04 Dec 2010 06:19:05 +0000

Java的类装载器是Java动态性的核心,是用来把类(class)装载进JVM的。VM规范定义了两种类型的类装载器：启动内装载器(bootstrap)和用户自定义装载器(user-defined class loader)。所有user-defined的class loader都是java.lang.ClassLoader的子类。jvm内置的class loader有3种，分别是 Bootstrap ClassLoader， Extension ClassLoader（即ExtClassLoader），System ClassLoader(即AppClassLoader)
bootstrap是JVM自带的类装载器，用来装载核心类库，如java.lang.*等。
Extension ClassLoader是用来加载扩展类，即/lib/ext中的类。
AppClassLoader用来加载Classpath的类，是和我们关系最密切的类。
URLClassLoader用来加载网络上远程的类，暂且不讨论。

它们之间的关系:
1.Parent-Child，按顺序从大到小。不是简单的继承关系。
2.ClassLoader有个getParent的方法，但是Ext ClassLoader调用后得到的是null，bootstrap是JVM自己的，用户看不到。
3.classloader的委托机制：当等级比较低的ClassLoader要加载某个类的时候，它首先会请求Parent加载器来加载，Parent再请求它的Parent

测试你所使用的JVM的ClassLoader：

^?View Code JAVA

package test.commons.reflect;
 
public class LoaderSample {
    public static void main(String[] args) {
    Class c;
    ClassLoader cl;
    cl = ClassLoader.getSystemClassLoader();
    System.out.println(cl);
    while (cl != null) {
        cl = cl.getParent();
        System.out.println(cl);
    }
    try {
        c = Class.forName("java.lang.Object");
        cl = c.getClassLoader();
        System.out.println("java.lang.Object’s loader is " + cl);
        c = Class.forName("test.commons.reflect.LoaderSample");
        cl = c.getClassLoader();
        System.out.println("LoaderSample’s loader is " + cl);
    } catch (Exception e) {
        e.printStackTrace();
    }
    }
}

运行结果：

^?View Code JAVA

sun.misc.Launcher$AppClassLoader@6b97fd
sun.misc.Launcher$ExtClassLoader@1c78e57
null
java.lang.Object’s loader is null
LoaderSample’s loader is sun.misc.Launcher$AppClassLoader@6b97fd

第一行表示，系统类装载器实例化自类sun.misc.Launcher$AppClassLoader
第二行表示，系统类装载器的parent实例化自类sun.misc.Launcher$ExtClassLoader
第三行表示，系统类装载器parent的parent为bootstrap
第四行表示，核心类java.lang.Object是由bootstrap装载的
第五行表示，用户类LoaderSample是由系统类装载器装载的

双亲委派模型：

从1.2版本开始，Java引入了双亲委托模型，从而更好的保证Java平台的安全。在此模型下，当一个装载器被请求装载某个类时，它首先委托自己的parent去装载，
若parent能装载，则返回这个类所对应的Class对象，若parent不能装载，则由parent的请求者去装载。
loader2的parent为loader1，loader1的parent为system class loader。假设loader2被要求装载类MyClass，在双亲委派模型下，loader2首先请求loader1代为装载，loader1再请求系统类装载器去装载MyClass。若系统装载器能成功装载，则将MyClass所对应的Class对象的reference返回给loader1，loader1再将reference返回给loader2，从而成功将类MyClass装载进虚拟机。若系统类装载器不能装载MyClass，loader1会尝试装载MyClass，若loader1也不能成功装载，loader2会尝试装载。若所有的parent及loader2本身都不能装载，则装载失败若有一个能成功装载，实际装载的类装载器被称为定义类装载器，所有能成功返回Class对象的装载器（包括定义类装载器）被称为初始类装载器。如图1所示，假设loader1实际装载了MyClass，则loader1为MyClass的定义类装载器，loader2和loader1为MyClass的初始类装载器。
system class loader
loader1
loader2
MyClass
需要指出的是，Class Loader是对象，它的父子关系和类的父子关系没有任何关系。一对父子loader可能实例化自同一个Class，也可能不是，甚至父loader实例化自子类，子loader实例化自父类。假设MyClassLoader继承自ParentClassLoader，我们可以有如下父子loader：

^?View Code JAVA

1 2	Class loadClass(String name) Class loadClass(String name, boolean resolve)

在JVM加载类的时候，需要经过三个步骤，装载、连接、初始化。装载就是找到相应的class文件，读入JVM，初始化就不用说了，最主要就说说连接。
连接分三步，第一步是验证class是否符合规格，第二步是准备，就是为类变量分配内存同时设置默认初始值，第三步就是解释，而这步就是可选的，
根据上面 loadClass方法的第二个参数来判定是否需要解释，所谓的解释根据《深入JVM》这本书的定义就是根据类中的符号引用查找相应的实体，
再把符号引用替换成一个直接引用的过程。
我们再来看看那个两个参数的loadClass方法，在JAVA API 文档中，该方法的定义是protected，那也就是说该方法是被保护的，而用
户真正应该使用的方法是一个参数的那个，一个参数的loadclass方法实际上就是调用了两个参数的方法，而第二个参数默认为false，
因此在这里可以看出通过loadClass加载类实际上就是加载的时候并不对该类进行解释，因此也不会初始化该类。而Class类的forName方法则是相反，
使用forName加载的时候就会将Class进行解释和初始化，forName也有另外一个版本的方法，可以设置是否初始化以及设置ClassLoader。
在实际项目中要加载一个类，可以采用Thread.currentThread().getContextClassLoader(),getClass().getClassLoader(),ClassLoader.getSystemClassLoader() 三种方式依次加载知道成功加载类。

^?View Code JAVA

public Class classForName(String name, ClassLoader classLoader)
            throws ClassNotFoundException {
        return classForName(name,
                new ClassLoader[] { classLoader, defaultClassLoader,
                     Thread.currentThread().getContextClassLoader(),
                     getClass().getClassLoader(),
                     ClassLoader.getSystemClassLoader() });
    }
    Class classForName(String name, ClassLoader[] classLoader)
            throws ClassNotFoundException {
 
        for (ClassLoader cl : classLoader) {
            if (null != cl) {
                try {
                    Class c = Class.forName(name, true, cl);
                    if (null != c)
                        return c;
                } catch (ClassNotFoundException e) {
                }
            }
        }
 
        throw new ClassNotFoundException("Cannot find class: "
            + name);
 
    }

参考资料：

Java的类装载器(ClassLoader)和命名空间(NameSpace) by rostone
Java ClassLoader基础知识 by 董涵

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

您可能也喜欢：
Java5中的注释Annotation	获得一个类上的注解	Jboss Seam的注解	prototype.js 源码之Prototype	模仿QQ空间的警告提示栏
无觅

您可能也喜欢：
commons-lang-1.0中的CompareToBuilder	java.lang.reflect.Array	Apache Commons Lang ToStringStyle	Java中比较两个对象是否相等	Java 反射机制
无觅

您可能也喜欢：
commons-lang-1.0中的EqualsBuilder和HashCodeBuilder	java.lang.reflect.Array	Apache Commons Lang ToStringStyle	Java 反射机制	Java5中的注释Annotation
来自无觅网络的相关文章：
一条评论引发的思考。 (@wx)	社交化搜索 Google +1 (@tumutanzi)	超1亿用户密码被黑客公开泄露中国互联网史上最大泄密事件 (@laixijin)	熊府 (@xiongx)	《尼基塔》(Nikita)第1季第13集 (@immtime)
无觅

您可能也喜欢：
在Dom4j中使用xpath解析xml	用JDOM操作XML文件	DOM 事件模型	Ext读取xml文件生成动态表格和表单	javascript的DOM函数方法
无觅

您可能也喜欢：
Java interface RandomAccess	Java中的字符串截取	java中关于时间日期操作的常用函数	Java中的两类异常	Java集合框架使用总结
无觅