<?xml version = '1.0' encoding = 'gb2312'?> <ROOT>    <ARSUBITEM num="1">       <C_ITEMNO>300200500009</C_ITEMNO>       <C_ITEMNAME>20050112测试</C_ITEMNAME>       <C_SUBITEMNO>200543030000010</C_SUBITEMNO>       <C_SUBITEMNAME>20010112标段2</C_SUBITEMNAME>       <C_FUNCNAME>监督备案</C_FUNCNAME>    </ARSUBITEM> </ROOT>

    该 XML 文件描述了一个标段当前流程信息，接下来把它翻译成 VO ：

public class BidProcess implements Serializable{  private String itemNo;  private String itemName;  private String subItemNo;  private String subItemName;  private String functionName;  /**   * @return 返回 functionName。   */  public String getFunctionName() {   return functionName;  }  /**   * @param functionName 要设置的 functionName。   */  public void setFunctionName(String functionName) {   this.functionName = functionName;  }  /**   * @return 返回 itemName。   */  public String getItemName() {   return itemName;  }  /**   * @param itemName 要设置的 itemName。   */  public void setItemName(String itemName) {   this.itemName = itemName;  }  /**   * @return 返回 itemNo。   */  public String getItemNo() {   return itemNo;  }  /**   * @param itemNo 要设置的 itemNo。   */  public void setItemNo(String itemNo) {   this.itemNo = itemNo;  }  /**   * @return 返回 subItemName。   */  public String getSubItemName() {   return subItemName;  }  /**   * @param subItemName 要设置的 subItemName。   */  public void setSubItemName(String subItemName) {   this.subItemName = subItemName;  }  /**   * @return 返回 subItemNo。   */  public String getSubItemNo() {   return subItemNo;  }  /**   * @param subItemNo 要设置的 subItemNo。   */  public void setSubItemNo(String subItemNo) {   this.subItemNo = subItemNo;  } }

    从 XML 构造 VO ，放入 List 中，代码如下：

public class VOFactory {  // 构造出的对象集合  private ArrayList list=new ArrayList();    /** 利用反射获取结果集  */  public List parse(Serializable source, String xml){   try{    //构造 XML 输入流    ByteArrayInputStream ba=new ByteArrayInputStream(xml.getBytes());    //Dom4J 初始化    SAXReader reader = new SAXReader();    Document document = reader.read(ba);    Element root = document.getRootElement();    //获得类对象    Class c = source.getClass();    //获得构造函数    Constructor[] cons=c.getDeclaredConstructors();    Constructor con=cons[0];    //获得类中的字段    Field[] fields = c.getDeclaredFields();    //设置访问private字段的权限    AccessibleObject.setAccessible(fields,true);    //以特定名称获得 XML 元素列表    List lis = root.elements("ARSUBITEM");    //"ARSUBITEM"元素下的子元素    for(int i=0;i<lis.size();i++){     Element element=(Element)lis.get(i);     Iterator iter=element.elementIterator();     //从构造函数实例化对象     Serializable localObj=(Serializable)con.newInstance(null);     //按照字段个数循环     int j=0;     while(iter.hasNext()){      Element e=(Element)iter.next();      fields[j].set(localObj,e.getText());      j++;     }     list.add(localObj);    }   }catch(Exception e){    e.printStackTrace();   }   return list;  } }

   
    通过对以上代码原形进行修改，可实现分页、结果集嵌套等需求。在写作本文时，我偶然发现了 Jakarta Commons BeanUtils 也提供了类似的功能。那么本文就作为一个了解反射的范例罢了。


请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

非短路运算符包括 “& 与”、“| 或”、“^ 异或”，一般称为“逻辑操作”

    “^”运算符道理是一样的，就不在这里罗索了。

    最后。短路运算符只能用于逻辑表达式内，非短路运算符可用于位表达式和逻辑表达式内。也可以说：短路运算只能操作布尔型的，而非短路运算不仅可以操作布尔型，而且可以操作数值型。


请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

    包括：
    “>> 右移”；“<< 左移”；“>>> 无符号右移”

例子：
-5>>3=-1
1111 1111 1111 1111 1111 1111 1111 1011
1111 1111 1111 1111 1111 1111 1111 1111
其结果与 Math.floor((double)-5/(2*2*2)) 完全相同。

-5<<3=-40
1111 1111 1111 1111 1111 1111 1111 1011
1111 1111 1111 1111 1111 1111 1101 1000
其结果与 -5*2*2*2 完全相同。

5>>3=0
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0000 0000
其结果与 5/(2*2*2) 完全相同。

5<<3=40
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0010 1000
其结果与 5*2*2*2 完全相同。

-5>>>3=536870911     
1111 1111 1111 1111 1111 1111 1111 1011
0001 1111 1111 1111 1111 1111 1111 1111

无论正数、负数，它们的右移、左移、无符号右移 32 位都是其本身，比如 -5<<32=-5、-5>>32=-5、-5>>>32=-5。
一个有趣的现象是，把 1 左移 31 位再右移 31 位，其结果为 -1。
0000 0000 0000 0000 0000 0000 0000 0001
1000 0000 0000 0000 0000 0000 0000 0000
1111 1111 1111 1111 1111 1111 1111 1111

位逻辑运算符

    包括：
    & 与；| 或；~ 非（也叫做求反）；^ 异或

    “& 与”、“| 或”、“~ 非”是基本逻辑运算，由此可以演变出“与非”、“或非”、“与或非”复合逻辑运算。“^ 异或”是一种特殊的逻辑运算，对它求反可以得到“同或”，所以“同或”逻辑也叫“异或非”逻辑。

例子：
5&3=1
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0001

-5&3=3
1111 1111 1111 1111 1111 1111 1111 1011
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0011

5|3=7
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0111

-5|3=-5
1111 1111 1111 1111 1111 1111 1111 1011
0000 0000 0000 0000 0000 0000 0000 0011
1111 1111 1111 1111 1111 1111 1111 1011

~5=-6
0000 0000 0000 0000 0000 0000 0000 0101
1111 1111 1111 1111 1111 1111 1111 1010

~-5=4
1111 1111 1111 1111 1111 1111 1111 1011
0000 0000 0000 0000 0000 0000 0000 0100

5^3=6
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0110

-5^3=-8
1111 1111 1111 1111 1111 1111 1111 1011
0000 0000 0000 0000 0000 0000 0000 0011
1111 1111 1111 1111 1111 1111 1111 1000



请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

    今天是一特殊日子，本人特推出一小篇译文，希望大家喜欢！

    本文列出了 Bruce Eckel 所推荐的各种 Java 工具，不知道你用了吗？

正文

    非常荣幸，我在这里向大家探讨关于最好的 Java 工具的话题。它们已被全部罗列在下面了。每个工具都是从他人的建议以及我的切身体会中提炼出来的。

IDE ： Eclipse (www.Eclipse.org)

    它拥有杰出的性能（在各个方面），并且还是免费的。免费并不总是重点，但是对于一个 IDE 来说，免费很重要，因为它降低了开发的屏障（成本），也为想要从书本上学习编码技术的一类人提供了条件。

    另外，实际上 Eclipse 被设计为可进行二次开发的产品，可以扩展和重新发布成为独立的应用程序平台，这是非常吸引人的。它将会吸引人们对它进行更多的关注（投资）。

代码的格式化器：暂缺

    Eclipse 有一内建工具，几乎可以在这方面做得很完美，但也不是万能的。如果特别挑剔的话，据我所知，无论哪一个格式化器，对注释的重定格式不会让人那么满意。我所需要的是所有的东西都要精确的放在所规定的格式限制中。

    Jalopy 像是一个领跑者，但是纵观历史，它也不能解决注释的重定格式问题。它是一个商业化的产品（ 40 美元非常合理）。

单元测试： JUnit

    我发现 JUnit 初始版本不太令人愉快，所以我就自己开发了一个。接着 JUnit 小组魔法般的修正了 JUnit ，以至于它可以和我的产品做一样的事情，所以 JUnit 可以以这一点来推销自己（好像有点傲慢）。目前，大多数用户都在使用它，以至于 JUnit 成为一种事实上的标准。

为单元测试进行覆盖测试： Clover

    不太了解这个工具，我没有使用过，但是这种概念看上去很好。它有 250 美元的高价。

架构管理： Ant

    参考 http://mindview.net/WebLog/log-0046 来学习“为什么使用 Ant ”。 Maven 像是作为 Ant 的替换产品，但如果要用的话，还必须更深入的研究一下。

样式检查 /Bug 探测器

    Checkstyle 是开源的，有点像下面的工具：

    PMD

    FindBugs

    Teamstudio 295 美元，我认为官方站点只是一个演示。 2003 12 月份有一个 JDJ 的评论，其他的我就不清楚了。如果你已经体验过的话，请给我留言。

性能调整： JProbe

    我没有用过它，不能从它的网站上断定出这个产品的性能（价格）。

字节码混淆器： YGuard

    如果你不想他人反编译 (reverse-engineer) 你的代码，你就可以用它。再次重申，我也没有用过。显然这是一个基于 LGPL 协议发布的工具，给你一个免费的选择。


请注意！引用、转贴本文应注明原译者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

现在有一典型的 VO 类 Auto(LightWeight)：

package com.test; public class Auto implements Cloneable{       private String No;     private String Addr;       public Object clone() throws CloneNotSupportedException{  return super.clone();     }     public String setNo(String no){         return this.No=no;     }      public String getNo(){         return this.No;     }          public String setAddr(String addr){         return this.Addr=addr;     }      public String getAddr(){         return this.Addr;     } }

    接着分别通过使用克隆和不使用克隆的 Bean 来构造 Auto 实例。

使用克隆的 Bean：

package com.test; import java.io.*; import java.util.*; import org.dom4j.*; import org.dom4j.io.*; public class MyXMLReader {     Auto auto=new Auto();                                 //请比较不同     ArrayList al=new ArrayList();     public ArrayList go() {  long lasting = System.currentTimeMillis();  try {      File f = new File("data_100k.xml");      SAXReader reader = new SAXReader();      Document doc = reader.read(f);      Element root = doc.getRootElement();      Element foo;      for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {          foo = (Element) i.next();          auto.setNo(foo.elementText("NO"));          auto.setAddr(foo.elementText("ADDR"));                 al.add(auto.clone());                    //请比较不同      }  } catch (Exception e) {      e.printStackTrace();  }  System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");  return al;     } }

    取八次运行时间
    运行时间：172 毫秒
    运行时间：93 毫秒
    运行时间：94 毫秒
    运行时间：141 毫秒
    运行时间：125 毫秒
    运行时间：78 毫秒
    运行时间：203 毫秒
    运行时间：63 毫秒

没有使用克隆的 Bean：

package com.test; import java.io.*; import java.util.*; import org.dom4j.*; import org.dom4j.io.*; public class MyXMLReader {     ArrayList al=new ArrayList();     public ArrayList go() {         long lasting = System.currentTimeMillis();  try {      File f = new File("data_100k.xml");      SAXReader reader = new SAXReader();      Document doc = reader.read(f);      Element root = doc.getRootElement();      Element foo;      for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {   foo = (Element) i.next();   Auto auto=new Auto();                     //请比较不同          auto.setNo(foo.elementText("NO"));          auto.setAddr(foo.elementText("ADDR"));                 al.add(auto);                             //请比较不同      }  } catch (Exception e) {      e.printStackTrace();  }  System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");  return al;     } }

    取八次运行时间
    运行时间：187 毫秒
    运行时间：93 毫秒
    运行时间：172 毫秒
    运行时间：78 毫秒
    运行时间：204 毫秒
    运行时间：79 毫秒
    运行时间：204 毫秒
    运行时间：78 毫秒

    通过比较，克隆与非克隆，在构造 Auto 上花的时间是差不多的。
    且慢，让我们再看下面的 Auto 类。

修改一下 Auto 类的构造函数，像这样(HeavyWeight)：

package com.test; import java.io.*; public class Auto implements Cloneable{       private String No;     private String Addr;     private String str;     private File f = new File("data_10k.xml");     private StringBuffer sb=new StringBuffer();       public Object clone() throws CloneNotSupportedException{  return super.clone();     }     //以下方法仅仅为了构造一个 HeavyWeight 对象。     public Auto(){         try{             BufferedReader inbuffer=new BufferedReader(new FileReader(f));      while ((str=inbuffer.readLine())!=null){   sb.append(str);      }  }catch(Exception e){      System.out.println(e.toString());  }     }     public String setNo(String no){         return this.No=no;     }      public String getNo(){         return this.No;     }          public String setAddr(String addr){         return this.Addr=addr;     }      public String getAddr(){         return this.Addr;     } }

    再看看测试数据呢？

    使用克隆构造 Auto 实例：     不使用克隆构造 Auto 实例：

    运行时间：188 毫秒           运行时间：2219 毫秒
    运行时间：78 毫秒            运行时间：2266 毫秒
    运行时间：109 毫秒           运行时间：2156 毫秒
    运行时间：219 毫秒           运行时间：2093 毫秒
    运行时间：110 毫秒           运行时间：2266 毫秒
    运行时间：78 毫秒            运行时间：2141 毫秒
    运行时间：157 毫秒           运行时间：2078 毫秒
    运行时间：78 毫秒            运行时间：2172 毫秒

    好了，让我们查看一下 Auto 类。可以看见只是在其构造函数中加入读取10K XML文件的代码，而克隆与非克隆运行时间却有近 10 倍的差距！
   
   
    为什么会这样？

    对象的构建不仅仅是“分配内存＋初始化一些值域”那么简单，它可能涉及非常多个步骤。所以将“待建对象”的数量和体积减到最低，才是明智之举。

    让我们看看创建一个 LightWeight 类都发生了什么：

    1、从 heap 分配内存，用来存放 Auto 类的实例变量，以及一份“实现专署数据”。
    2、Auto 类的实例变量 No 和 Addr，被初始化为缺省值，缺省值都为null。
    3、调用 Auto 类构造函数。
    4、Auto 类构造函数调用其超类（java.lang.Object）的构造函数。
    5、java.lang.Object 构造函数返回。
    6、对象引用“auto”指向 heap 中完成的 Auto 对象。
   
    再让我们看看创建一个 HeavyWeight 类都发生了什么：

    1、从 heap 分配内存，用来存放 Auto 类的实例变量，以及一份“实现专署数据”。
    2、Auto 类的实例变量 No、Addr、str、f、sb，被初始化为缺省值，缺省值都为null。
    3、File 类的构造函数载入 10K XML 文件得到实例变量 f，调用 StringBuffer 的构造函数得到实例变量 sb，接着调用 Auto 类构造函数。（在构造函数本体执行之前，所有实例变量的初始设定值和初始化区段先获得执行，然后才执行构造函数本体。针对 f 和 sb，又从步骤 1 开始重复这个过程。）
    4、Auto 类构造函数中调用 FileReader 类的构造函数将实例变量 f 载入，接着调用 BufferedReader 类的构造函数将 FileReader 类的实例载入，得到局部变量 inbuffer。（针对 FileReader 类的实例和 inbuffer，又从步骤 1 开始重复这个过程。）
    5、读取 inbuffer 中的数据，实例变量 sb 被循环赋值。
    6、跳出循环后，实例变量 sb 经过方法调用返回给实例变量 str。
    7、Auto 类构造函数调用其超类（java.lang.Object）的构造函数。
    8、java.lang.Object 构造函数返回。
    9、对象引用“auto”指向 heap 中完成的 Auto 对象。
   
    通过比较可以看出，建立 HeavyWeight 对象比建立 LightWeight 对象的性能相差很多。步骤 3、4 代价最高，因为它不得不对四个聚合对象重复全过程。
    创建对象代价高昂（特别是 HeavyWeight 对象）！应尽量减少创建次数。创建对象的次数越少，意味代码执行越快。对于 Auto 类(HeavyWeight)，复用对象引用“auto”所指向的对象才是正解。
    对象复用的一种重要方式就是克隆。任何类如果支持克隆操作，就必须实现 Cloneable 接口，这只是一个标识接口，它并没有实现任何方法。任何类如果实现 Cloneable，就宣布它支持克隆操作。正如以上这些代码，利用克隆来提高性能是非常简单的。


请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

    许多书上都讨论了自动测试，但是只有很少的著作注意到这么一个问题，那就是怎样把这些测试组织起来。随着测试的增加，放置和调用这些测试却变得更加麻烦。这将成为一个重要问题，以至于出现了TDD，极限编程（XP）使TDD得以普及。另外，你可以这样理解TDD：通过测试来开发。    

    TDD的主要规范：    

    在编写程序代码之前，与之对应的自动测试必须被写好。甚至程序代码并不存在，那也要看见一个失败的测试结果。

    在测试通过后，副本代码必须被丢弃。    

    有一个具体步骤（可能指的是《Extreme Programming》）可以被任何一个程序员来参考，而不需要特殊的其他方法。在我们开始写测试之前，这些步骤（章节）应该被首先阅读——怎样组织自动测试。    

    讲解一下不同种类的测试：    

    单元测试：检测模块（也就是类）的正确性。如果对象需要访问外部的数据资源，例如数据库，就需要模拟一个mock objects，但在实际中真实数据与测试环境是不同的。

    客户测试：这是功能性、系统、和验收测试。用来测试整体的系统特性。在XP中，这些测试由用户编写。

    综合测试：介于用户测试和单元测试之间的桥梁。综合测试帮助测试应用程序的交互性。一般情况下，mock objects不被用于综合测试，它会增加测试时间。同样，综合测试经常依赖特殊的测试环境，例如数据库送来的测试数据。综合测试也需要用到外部类库。例如为J2EE应用程序进行综合测试的类库Cactus。解释这些测试超出了本文的范围，需要更加详细的信息请参考http://jakarta.apache.org/cactus/。

    开发人员测试：这是用来让开发人员检验自己代码或新函数的。对于每一个开发人员，只要有可能，就需要有更多的测试来检验代码。组织这些测试和组织程序代码一样重要。    

    在以下章节，只要提到“测试”，那就指的是开发人员测试。     

    我们几乎准备好开始建立测试了，先应该为我们的测试选择名字。你也许会说，“这不是问题：把‘Test’这个字放在类名前面，就好了！”不会这么快！让我来说一下这个步骤存在的问题：    

    在TDD中，被测试的类或者方法还不存在。

    一个测试能够覆盖多个方法，甚至多个类，这是可能的。    

    以上只是一些普遍问题；还存在更多的问题。    

    让我来提一个建议，在测试命名时：测试类的名字应该让人一眼就知道这是一个测试类，且能说明它要测试什么，注意是否和其他类重名。按照以上建议做，就很简单了，也不用担心名字太长或难听。   

    即将在Eclipse中用JUnit工具创建我们第一个测试了。假设你已经下载了一个最新的Eclipse版本。如果还没有，你应该去官方站点http://www.eclipse.org下载。还需要JUnit，也可以从http://www.junit.org/下载。    

    运行Eclipse。新建一个workplace项目，点击文件->新建->项目，选择Java项目，点击下一步。起一个项目名称，例如ProjectWithJUnit。点击完成。这样就完成新项目的建立了。再来配置一下Eclipse，在构建路径中添加JUnit类库。在工具条上点击项目->属性，选择Java构建路径，库，选择添加外部JAR，浏览Junit被存储的目录，选择junit.jar，点击打开。你将会看见JUnit出现在库的列表中。点击确定，让Eclipse重建路径。    

    现在开发我们的“Hello World”例子。按照TDD的规则，应该在代码建立以前先把测试写好。为了能够在某出开始，我们假设未来的类名是HelloWorld，并且有一个方法Say()，这个方法返回String的值（例如“Hello World!”）。    

    建立测试，在ProjectWithJUnit的标题上面点击右键，选择新建->其他，展开“Java”选项，选择JUnit。在右边的栏目对话框中选择测试案例，然后下一步。参考图1。 

                    图1. 在Eclipse中建立JUnit测试

    在测试类这一栏中，写上将要被测试的类名HelloWorld。选择一个测试案例的名字，例如TestThatWeGetHelloWorldPrompt（是的，看上去很长，但是很清楚它的行为。）点击完成。    

    TestThatWeGetHelloWorldPrompt的代码如下：

    import junit.framework.TestCase;
    public class TestThatWeGetHelloWorldPrompt 
    extends TestCase { 

        public TestThatWeGetHelloWorldPrompt( 
            String name) { 
            super(name); 
        }

        public void testSay() { 
            HelloWorld hi = new HelloWorld(); 
            assertEquals("Hello World!", hi.say());

        }

        public static void main(String[] args) { 
            junit.textui.TestRunner.run( 
                TestThatWeGetHelloWorldPrompt.class); 
        } 
    }

    代码并不复杂；只是有点与众不同。然而，让我们考察一下细节。我们继承了JUnit的TestCase类，它在JUnit的javadocs定义为“运行众多测试的夹具。”JUnit也有TestSuite类，它是一组测试案例的集合，但在本文中不做讨论。

    建立测试案例的步骤如下：

    1、建立一个junit.framework.TestCase的实例。

    2、定义一些以“test”开头的无返回方法（例如testWasTransactionSuccessful()，testShow()，等等）。

    TestThatWeGetHelloWorldPrompt.java包含这些：TestCase的子类和一个叫做testSay()的方法。这个方法调用了assertEquals()函数，它用来比较我们预期的值和由say()返回的值。    

    main()方法用来运行测试和显示输出的。JUnit的TestRunner处理测试，提供基于图像和文本的输出表现形式。我们使用基于文本的版本，因为Eclipse支持它，且也适合我们。当开始运行后，基于文本的版本测试会以文本形式输出，Eclipse会把这些输出自动变成图像界面的输出。    

    按照TDD规范，首次运行测试，应该故意让它失败。点击运行->运行为->Junit测试（记住TestThatWeGetHelloWorldPrompt.java应该被突出的显示在包资源管理器中）。在左边窗口，应该看见JUnit窗口而不是包资源管理器，它显示一个红条，一次失败的测试，具体的失败原因参看图2。如果没有自动显示这些内容，点击JUnit标签（在底部的左边）。 

                    图2. JUnit中失败的测试    

    很好！的却失败了。现在我们来建立被测试代码：在包资源管理器窗口的ProjectWithJUnit标题上右击，选择新建->类。选择类名，我们已经假设了它叫HelloWorld，然后直接点击完成。为HelloWorld.java填入下列代码：

        public class HelloWorld {

            public String say() { 
                return("Hello World!"); 
            } 
        }

    这段代码很简单，甚至不需要注解，我们再来看看结果。按照上面描述过的方式，在JUnit的窗口中显示了一个绿条，参看图3。绿条证明测试成功。

                     图3. JUnit中成功的测试                  

    现在，我们想再让测试失败一次，但原因不同。这有助于展示JUnit测试中不同的报错信息。修改assertEquals()代码，把“Hello World!”变成“Hello Me!”。当再次运行JUnit时，结果变成了红条，在JUnit窗口的底部输出了失败原因，参看图4。

                    图4. JUnit中的ComparisonError  

    最后，我想说一下关于测试是开发过程中的必要部分的话题。测试代码一直是开发中的重要部分。经过近几年的发展，已得到了很大的提高，这要归功于强大的理论研究（比如“expectations-based development”等等），和快速发展的测试工具包，还有测试过程的改进。如果你对这篇文章感兴趣，那请你花一些时间来正式的学习一下测试理论吧，这对你的工作很有用。

    关于作者：

    Alexander Prohorenko 一名UNIX系统管理员、网络安全管理员。

    Olexiy Prohorenko    一名Java开发者居住在乌克兰的Dniepropetrovsk。



请注意！引用、转贴本文应注明原译者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen