首先我们构建两个类People和Person，它们的实例呆会会用来相互复制。

People.java：

package com.mangocity.test;

/**

 *@authorCMTobby

 */

publicclass People {

    public People() {

       // TODO Auto-generated constructor stub

    }

    private String name;//姓名

    privateintage;//年龄

    private String email;

    public String getEmail() {

       returnemail;

    }

    publicvoid setEmail(String email) {

       this.email = email;

    }

    publicint getAge() {

       returnage;

    }

    publicvoid setAge(int age) {

       this.age = age;

    }

    public String getName() {

       returnname;

    }

    publicvoid setName(String name) {

       this.name = name;

    }

}

Person.java：

package com.mangocity.test;

/**

 *@authorCMTobby

 */

publicclass Person {

    private String name;

    privateintage;

    private String address;

    public String getAddress() {

       returnaddress;

    }

    publicvoid setAddress(String address) {

       this.address = address;

    }

    publicint getAge() {

       returnage;

    }

    publicvoid setAge(int age) {

       this.age = age;

    }

    public String getName() {

       returnname;

    }

    publicvoid setName(String name) {

       this.name = name;

    }

}

接着构建我们的测试类

import org.apache.commons.beanutils.*;

publicclass TestBeanUtils {

    /**

     *@paramargs

     */

    publicstaticvoid main(String[] args) {

       // TODO Auto-generated method stub

       People tobby=new People();

       Person cindy=new Person();

       tobby.setAge(23);

       tobby.setName("CMTobby");

       tobby.setEmail("xiaozhu87487705@163.com");

       cindy.setName("Cindyelf");

       cindy.setAge(24);

        try {

             BeanUtils.copyProperties(cindy, tobby);

           System.out.println(cindy.getName()+":"+cindy.getAge());

       } catch (IllegalAccessException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       } catch (InvocationTargetException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       }

    }

}

运行该程序输出是：CMTobby:23。这说明经过BeanUtils.copyProperties之后cindy中name和age属性的值已经被tobby中的同名属性给“覆盖”了，至于tobby中有而cindy中没有的email属性有没有复制到cindy中就不得而知了，据我的猜测应该是没有的，因为在cindy中没有地方放这个属性啊，而且就算复制过去了，我们如何得到这个值呢？难道用cindy.getEmail()吗，可是cindy根本没有这个方法啊？当然这只是我的猜测，不知哪位达人有准确的答案，欢迎指正，^_^。

那么这个复制过程是如何的呢？是直接属性对属性的值拷贝吗，例如cindy.name=tobby.name？还是老办法，将测试进行到底。

1.我将Person中的name属性改名为name11，age属性改为age11，get和set方法都做相应的修改，此时运行程序，输出结果为：CMTobby:23，和前面的一样，由此可以排除值拷贝这个假设了，因为此时cindy中没有了name属性而是name11属性。

2.我将Person中的setName和setAge方法分别改为setName11和setAge11.OK，再次运行我们的程序，这时的输出是：Cindyelf:24，我们发现cindy的name属性和age属性的值都没有被覆盖掉，也就是说tobby中的值都没有拷贝过来，为什么呢？

3.将我们程序恢复到刚开始的样子，即上面所贴的代码那样，然后将Person中的setAge方法注释掉，并注释掉TestBeanUtils中的cindy.setAge(24)这行代码。运行程序，输出结果是：CMTobby:0。tobby中age属性的值没有拷贝过来，为什么呢？

基于上述两个测试，我猜测BeanUtils.copyProperties的行为过程是这样的：首先通过java的反射得到tobby中的所有域，然后根据域的名字调用cindy中相应的set方法。举个例子，BeanUtils发现tobby中有个name属性，那么它会尝试执行cindy.setName()这个方法。这就很容易解释测试2和测试3的结果了：因为cindy中没有了setName或者setAge(被改成了setName11和setAge11或者被注释掉了)，所有cindy的name属性不会变，仍然是以前的值。而在测试1中，因为cindy对象有setName方法，所以name11属性的值会被覆盖掉。

做完上述测试之后，我闲着无聊又做了如下两个测试：

4.将Person中的setName和setAge改为setname和setage，程序输出结果是：CMTobby:23，cindy中的name属性和age属性的值都发生了变化；

5.将Person中的setName和setAge改为setNAme和setAGe,程序输出结果是：Cindyelf:24，tobby中的属性的值都没有拷贝过来。

基于这两个测试，我想过程会不会是这样的：如果BeanUtils发现tobby中有个name属性，那么它就会尝试执行cindy.setName()或者cindy.setname()。当然这些都只是我的推论，仅供参考，所有的答案都会在BeanUtils的源码中找到，^_^，还望哪位达人不吝告知。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1703702

              Class Loaders是动态加载Java类与Resource的一种机制。它支持Laziness，type-safe linkage，user-defined extensibility和multiple communicating namespaces这4种特性。

l         Lazy loading：Class只有在需要的时候才加载。这样减少了内存使用量，能提高系统反映速度；

l         Type-safe linkage：动态类加载不会破坏JVM的类型安全；

l         User-definable class loading policy：开发者可以自定义的类加载器，控制动态类加载过程；

l         Multiple namespaces：JVM允许使用不同的类加载器加载相同的Class名称，但不同内容的类。

Class Loaders早在JDK1.0时就已存在，最开始的目的是使HotJava浏览器能加载Applet。从那以后，动态类加载机制被广泛应用到其他方面，例如web application server中Servlets的加载。class loader在JDK 1.0，1.1版本存在的缺陷，已经在JDK 1.2解决，其缺陷主要是编写不正确的Class Loader会造成类型安全问题。

2．Class Loaders

Class Loader的目的是动态加载Java类和Resource。Java类是平台无关的，标准的，具有规范二进制文件格式的。class文件有编译器生成，可以被任何一中JVM加载。Java类的表现形式不仅只有.class文件，还可以为内存buffer，或是网络数据流。

JVM执行class文件内的Byte code。但是Byte code不是class文件的全部内容，class文件内还包含符号表，表示类，属性和方法名，以及类内引用到其他类，属性，和方法名。例如下面的类

       class C{

                     void f(){

                                   D d=new D();

                     }

       }

类文件内类C引用D。为了能让JVM知道D类是什么，JVM必须要先load D的class file并创建D class对象。

JVM使用类加载器加载类文件，并创建Class对象。类加载器都是ClassLoader的子类实例。ClassLoader.loadClass方法通过获得一个类名，返回一个Class对象，表示该类的类型。上面的代码里，假设C被类加载器L加载，则L是C的加载器。JVM将使用L加载所有被C引用到的其他Java类。

如果D还没有被加载，L将加载D：

       L.loadClass(“D”)

当D已经被加载，JVM就可以创建D的一个对象实例。

一个Java应用程序可以使用不同类型的类加载器。例如Web Application Server中，Servlet的加载使用开发商自定义的类加载器，java.lang.String在使用JVM系统加载器,Bootstrap Class Loader，开发商定义的其他类则由AppClassLoader加载。在JVM里由类名和类加载器区别不同的Java类型。因此，JVM允许我们使用不同的加载器加载相同namespace的java类，而实际上这些相同namespace的java类可以是完全不同的类。这种机制可以保证JDK自带的java.lang.String是唯一的。

ClassLoader子类需要重载loadClass方法以实现用户自己的类加载方式，下面是自定义一个类加载器例子：

package org.colimas.webapp;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.StringTokenizer;

/**

 *类加载器加载Servlet，URLClassLoader是ClassLoader的一个子类，可以通过URL加载Java类或其它资源。

 * @author 趙磊

 *

 */

public class WebAppClassLoader extends URLClassLoader {

    private ClassLoader _parent;

       public WebAppClassLoader(ClassLoader parent) {

                     super(new URL[0], parent);

                     _parent=parent;

        if (parent==null)

            throw new IllegalArgumentException("no parent classloader!");

       }

       //追加一个Class Path。

       public void addClassPath(String classPath) throws IOException{

        if (classPath == null)

            return;

        StringTokenizer tokenizer= new StringTokenizer(classPath, ",;");

        while (tokenizer.hasMoreTokens())

        {        

               URL url=null;

            File file=new File(tokenizer.nextToken()).getCanonicalFile();

            url=file.toURI().toURL(); 

            addURL(url);

        }

       }

       //加载类

       public synchronized Class loadClass(String name)

                     throws ClassNotFoundException {

                     return loadClass(name,false);

       }

       protected synchronized Class loadClass(String name, boolean resolve)

                     throws ClassNotFoundException {

                     Class c= findLoadedClass(name);

                     ClassNotFoundException ex= null;

                     if (c == null && _parent!=null ){

                                   try{

                                                 c= _parent.loadClass(name);

                                   }catch (ClassNotFoundException e){

                       ex= e;

                                   }

                     }

                     if (c == null){

                                   try{

                                                 c= this.findSystemClass(name);

                                   }catch (ClassNotFoundException e){

                       ex= e;

                                   }

                     }

                     if (c == null)

                                   throw ex;

                     if (resolve)

                                   resolveClass(c);

                     return c;

       }

}

loadClass方法中使用findLoadedClass方法检查类是否已经被加载。该方法是Native方法，实现在JVM的ClassLoader.c文件内的Java_java_lang_ClassLoader_findLoadedClass函数。如果返回为null，则表示类还没有被加载，于是在其Parent类加载器重寻找_parent.loadClass，如果仍然返回null，则要在系统中查找，findSystemClass，如果仍然没有，则抛出异常。我们要确保多线程在同一时间只能加载一次，因此需要synchronized。

通常我们需要动态更新一个Class。例如一个Servlet实现发生变化时，我们希望不是重启服务器而是Reload。下面的类ServletWrapper提供了一个Servlet Reload的实现方法：

package org.colimas.webapp;

import javax.servlet.Servlet;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

/**

 * @author 趙磊

 *

 */

public class ServletWrapper {

       private Servlet theServlet;

    private Class servletClass;

    private ServletConfig config;

    private String _servletname;

    public ServletWrapper(ServletConfig config){

                  this.config=config;

    }

    public Servlet getServlet() throws ServletException{

               synchronized (this) {

                       destroy();

                       try {

                                     WebAppClassLoader loader=new WebAppClassLoader(this.getClass().getClassLoader());

                                     String name=getServletName();

                           servletClass = loader.loadClass(name);

                           theServlet = (Servlet) servletClass.newInstance();

                       } catch( ClassNotFoundException ex1 ) {

                       } catch( InstantiationException ex ) {

                       }catch(IllegalAccessException ex2){

                       }

                       theServlet.init(config);

                   }

               return theServlet;          

    }

    public void destroy() {

        if (theServlet != null) {

            theServlet.destroy();

        }

    }   

    protected String getServletName(){

                  return _servletname;

    }

}

getServlet()获得一个Servlet对象。首先创建一个新的Servlet类加载器。loader.loadClass加载最新的Servlet，servletClass.newInstance()实例化新的Servlet对象，并theServlet.init(config);让它运行起来。这种方法只有在不改变Servlet的接口时有效的。如果你要加载的类不实现任何接口，那么就不能在ServletWrapper直接使用该类名。而是定义为Object theServlet，并且theServlet = servletClass.newInstance();，而theServlet.init(config);也不得不改写为：

Method m= servletClass.getMethod(“init”,…);

m.invoke(theServlet,…);

3. Type-safe Linkage和Namespace一致性

JVM使用loaded class cache保存class名和加载该class的类加载器。当JVM通过loadClass获得class之后，它执行以下操作：

l         检查传给loadClass的类名是否和真实类名一致；

l         如果一致，则保存到loaded class cache里。

ClassLoader.findLoadedClass就是在loaded class cache查找class是否存在的。

为了保证Type-safe，Sun公司做了很多工作，目前也有不止一个解决方案。例如，增加约束规则（Contraint Rule）等。

父类

父类

载入

载入

BootstrapLoader

PARENT AppClassLoader

PARENT ExtClassLoader

importjava.math.BigDecimal;
publicclassArith
{
 privatestaticfinalintDEF_DIV_SCALE=10;

  privateArith()
  {

     }

   /**

    *提供精确的加法运算。

    *@paramv1被加数

    *@paramv2加数

    *@return两个参数的和

    */

   publicstaticdoubleadd(doublev1,doublev2)
  {

       BigDecimalb1=newBigDecimal(Double.toString(v1));

       BigDecimalb2=newBigDecimal(Double.toString(v2));

       returnb1.add(b2).doubleValue();

       }

  /**

    *提供精确的减法运算。

    *@paramv1被减数

    *@paramv2减数

    *@return两个参数的差

    */

   publicstaticdoublesub(doublev1,doublev2)
  {

       BigDecimalb1=newBigDecimal(Double.toString(v1));

       BigDecimalb2=newBigDecimal(Double.toString(v2));

       returnb1.subtract(b2).doubleValue();

    }

 /**

    *提供精确的乘法运算。

    *@paramv1被乘数

    *@paramv2乘数

    *@return两个参数的积

    */

   publicstaticdoublemul(doublev1,doublev2)
  {

  BigDecimalb1=newBigDecimal(Double.toString(v1));

  BigDecimalb2=newBigDecimal(Double.toString(v2));

  returnb1.multiply(b2).doubleValue();

  }

 
 /**

    *提供（相对）精确的除法运算，当发生除不尽的情况时，精确到

    *小数点以后10位，以后的数字四舍五入。

    *@paramv1被除数

    *@paramv2除数

    *@return两个参数的商

    */

   publicstaticdoublediv(doublev1,doublev2)
  {

       returndiv(v1,v2,DEF_DIV_SCALE);

       }

  /**

    *提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指

    *定精度，以后的数字四舍五入。

    *@paramv1被除数

    *@paramv2除数

    *@paramscale表示表示需要精确到小数点以后几位。

    *@return两个参数的商

    */

   publicstaticdoublediv(doublev1,doublev2,intscale)
  {

   if(scale<0)
    {

    thrownewIllegalArgumentException("Thescalemustbeapositiveintegerorzero");

     }

       BigDecimalb1=newBigDecimal(Double.toString(v1));

       BigDecimalb2=newBigDecimal(Double.toString(v2));

       returnb1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

    }

  /**

    *提供精确的小数位四舍五入处理。

    *@paramv需要四舍五入的数字

    *@paramscale小数点后保留几位

    *@return四舍五入后的结果

    */

   publicstaticdoubleround(doublev,intscale){

       if(scale<0)
   {

           thrownewIllegalArgumentException("Thescalemustbeapositiveintegerorzero");

           }

       BigDecimalb=newBigDecimal(Double.toString(v));

       BigDecimalone=newBigDecimal("1");

       returnb.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

   }

}