import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class ReadMac {
    public ReadMac() {
    }

    public static String getMACAddress() {

        String address = "";
        String os = System.getProperty("os.name");
        if (os != null && os.startsWith("Windows")) {
            try {
                String command = "cmd.exe /c ipconfig /all";
                Process p = Runtime.getRuntime().exec(command);
                BufferedReader br =
                        new BufferedReader(
                                new InputStreamReader(p.getInputStream()));
                String line;
                while ((line = br.readLine()) != null) {
                    if (line.indexOf("Physical Address") > 0) {
                        int index = line.indexOf(":");
                        index += 2;
                        address = line.substring(index);
                        break;
                    }
                }
                br.close();
                return address.trim();
            } catch (IOException e) {}
        }
        return address;
    }

public static void main(String[] args) {
    System.out.println("Mac:"+ReadMac.getMACAddress());
}
}

set CATALINA_HOME=..//在这句下面加入
//设定jdk的路径
set JAVA_HOME=..\..\%CATALINA_HOME%\jdk1.4
:gotHome  //=..//在这句上面加入

但是用了tomcat5.5却没有了这两个文件,它将自已的安装路径和jdk的路径都写到注册表中了.

这就需要在打包时动态的修改注册表,否则将不能正常使用.

-- 安装路径:your_variable
--Dialog.Message(your_variable, your_variable, MB_OK, MB_ICONEXCLAMATION);

-- 创建一个全局变量，并赋予一个字符串
your_variable1 = "";

--Dialog.Message(your_variable, your_variable, MB_OK, MB_ICONEXCLAMATION);
-- 从注册表中导入的值:
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Tomcat");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Tomcat\\5.5");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters");
your_variable1=String.Replace("D:\\Software\\Tomcat 5.5","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Tomcat\\5.5", "InstallPath", your_variable1, 7);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Tomcat\\5.5", "Version", "5.5.12", 7);
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Java");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Log");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Start");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Stop");
your_variable1=String.Replace("D:\\Software\\jdk1.5\\bin\\client\\jvm.dll","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Java", "Jvm",your_variable1, 1);
your_variable1=String.Replace("D:\\Software\\Tomcat 5.5\\bin\\bootstrap.jar","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Java", "Classpath",your_variable1, 1);

your_variable1=String.Replace("-Dcatalina.home=D:\\Software\\Tomcat 5.5|-Dcatalina.base=D:\\Software\\Tomcat 5.5|-Djava.endorsed.dirs=D:\\Software\\Tomcat 5.5\\common\\endorsed|-Djava.io.tmpdir=D:\\Software\\Tomcat 5.5\\temp|-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager|-Djava.util.logging.config.file=D:\\Software\\Tomcat 5.5\\conf\\logging.properties","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Java", "Options", your_variable1, 7);

your_variable1=String.Replace("D:\\Software\\Tomcat 5.5\\logs","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Log", "Path",your_variable1 , 1);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Log", "StdError", "auto", 1);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Log", "StdOutput", "auto", 1);

your_variable1=String.Replace("D:\\Software\\Tomcat 5.5","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Start", "WorkingPath", your_variable1, 1);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Start", "Class", "org.apache.catalina.startup.Bootstrap", 1);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Start", "Params", "start", 7);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Start", "Mode", "jvm", 1);

your_variable1=String.Replace("D:\\Software\\Tomcat 5.5","D:\\Software",your_variable,true);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Stop", "WorkingPath", your_variable1, 1);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Stop", "Class", "org.apache.catalina.startup.Bootstrap", 1);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Stop", "Params", "stop", 7);
Registry.SetValue(3, "Software\\Apache Software Foundation\\Procrun 2.0\\Tomcat5\\Parameters\\Stop", "Mode", "jvm", 1);

-- 从注册表中导入的值:
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "Type", "16", 4);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "Start", "3", 4);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "ErrorControl", "1", 4);
your_variable1=String.Replace("\"D:\\Program Files\\Apache Software Foundation\\Tomcat 5.5\\bin\\Tomcat5.exe\" //RS//Tomcat5","D:\\Program Files\\Apache Software Foundation",your_variable,true);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "ImagePath", your_variable1, 2);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "DisplayName", "Apache Tomcat", 7);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "ObjectName", "LocalSystem", 7);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5", "Description", "Apache Tomcat 5.5.12 Server - http://tomcat.apache.org/", 7);
Registry.CreateKey(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Enum");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Parameters");
Registry.CreateKey(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Security");
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Enum", "0", "Root\\LEGACY_Tomcat5\\0000", 7);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Enum", "Count", "1", 4);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Enum", "NextInstance", "1", 4);
Registry.SetValue(3, "SYSTEM\\CurrentControlSet\\Services\\Tomcat5\\Security", "Security", "01 00 14 80 90 00 00 00 9C 00 00 00 14 00 00 00 30 00 00 00 02 00 1C 00 01 00 00 00 02 80 14 00 FF 01 0F 00 01 01 00 00 00 00 00 01 00 00 00 00 02 00 60 00 04 00 00 00 00 00 14 00 FD 01 02 00 01 01 00 00 00 00 00 05 12 00 00 00 00 00 18 00 FF 01 0F 00 01 02 00 00 00 00 00 05 20 00 00 00 20 02 00 00 00 00 14 00 8D 01 02 00 01 01 00 00 00 00 00 05 0B 00 00 00 00 00 18 00 FD 01 02 00 01 02 00 00 00 00 00 05 20 00 00 00 23 02 00 00 01 01 00 00 00 00 00 05 12 00 00 00 01 01 00 00 00 00 00 05 12 00 00 00", 3);

import java.io.File;
import org.apache.tools.zip.ZipOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipEntry;

public class CompressBook {
  public CompressBook() {
  }

  /*
   * inputFileName 输入一个文件夹
   * zipFileName 输出一个压缩文件夹
   */
  public void zip(String inputFileName) throws Exception {
    String zipFileName = "c:\\test.zip"; //打包后文件名字
    System.out.println(zipFileName);
    zip(zipFileName, new File(inputFileName));
  }

  private void zip(String zipFileName, File inputFile) throws Exception {
    ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
    zip(out, inputFile, "");
    System.out.println("zip done");
    out.close();
  }

  private void zip(ZipOutputStream out, File f, String base) throws Exception {
    if (f.isDirectory()) {
      File[] fl = f.listFiles();
      out.putNextEntry(new org.apache.tools.zip.ZipEntry(base + "/"));
      base = base.length() == 0 ? "" : base + "/";
      for (int i = 0; i < fl.length; i++) {
        zip(out, fl[i], base + fl[i].getName());
      }
    }
    else {
      out.putNextEntry(new org.apache.tools.zip.ZipEntry(base));
      FileInputStream in = new FileInputStream(f);
      int b;
      System.out.println(base);
      while ( (b = in.read()) != -1) {
        out.write(b);
      }
      in.close();
    }
  }

  public static void main(String [] temp){
    CompressBook book = new CompressBook();
    try {
      book.zip("c:\\test",new File("c:\\test"));
    }
    catch (Exception ex) {
    }
  }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
import java.util.zip.GZIPInputStream;
import java.io.DataInputStream;

/**
 * Description: 此类用于...
 *
 * @author    wunaigang(2005-6-21)
 * @version   1.0.0
 */
public class ZipManager {

        /**
         * zip压缩功能测试. 将d:\\temp\\zipout目录下的所有文件连同子目录压缩到d:\\temp\\out.zip.
         *
         * @param baseDir 所要压缩的目录名（包含绝对路径）
         * @param objFileName 压缩后的文件名
         * @throws Exception
         */
        public void createZip(String baseDir, String objFileName) throws Exception {
                File folderObject = new File(baseDir);

                if (folderObject.exists()){
                        List fileList = getSubFiles(new File(baseDir));

                        //压缩文件名
                        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(objFileName));

                        ZipEntry ze = null;
                        byte[] buf = new byte[1024];
                        int readLen = 0;
                        for (int i = 0; i < fileList.size(); i++) {
                                File f = (File) fileList.get(i);
                                System.out.println("Adding: " + f.getPath() + f.getName());

                                //创建一个ZipEntry，并设置Name和其它的一些属性
                                ze = new ZipEntry(getAbsFileName(baseDir, f));
                                ze.setSize(f.length());
                                ze.setTime(f.lastModified());

                                //将ZipEntry加到zos中，再写入实际的文件内容
                                zos.putNextEntry(ze);
                                InputStream is = new BufferedInputStream(new FileInputStream(f));
                                while ((readLen = is.read(buf, 0, 1024)) != -1) {
                                        zos.write(buf, 0, readLen);
                                }
                                is.close();
                                System.out.println("done...");
                        }
                        zos.close();
                }else{
                        throw new Exception("this folder isnot exist!");
                }
        }
        /**
         * zip压缩功能测试. 将指定文件压缩后存到一压缩文件中
         *
         * @param baseDir 所要压缩的文件名
         * @param objFileName 压缩后的文件名
         * @return 压缩后文件的大小
         * @throws Exception
         */
        public long createFileToZip(String zipFilename,String sourceFileName) throws Exception {

                File  sourceFile = new File(sourceFileName);

                byte[] buf = new byte[1024];

                //压缩文件名
                File objFile = new File(zipFilename);

                ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(objFile));

                ZipEntry ze = null;
                //创建一个ZipEntry，并设置Name和其它的一些属性
                ze = new ZipEntry(sourceFile.getName());
                ze.setSize(sourceFile.length());
                ze.setTime(sourceFile.lastModified());

                //将ZipEntry加到zos中，再写入实际的文件内容
                zos.putNextEntry(ze);

                InputStream is = new BufferedInputStream(new FileInputStream(sourceFile));

                int readLen = -1;
                while ((readLen = is.read(buf, 0, 1024)) != -1) {
                        zos.write(buf, 0, readLen);
                }
                is.close();
                zos.close();

                return objFile.length();
        }
        /**
         * zip压缩功能测试. 将指定文件压缩后存到一压缩文件中
         *
         * @param baseDir 所要压缩的文件名
         * @param objFileName 压缩后的文件名
         * @return 压缩后文件的大小
         * @throws Exception
         */
        public long createFileToZip(File sourceFile,File zipFile)throws IOException {

                byte[] buf = new byte[1024];

                //压缩文件名
                File objFile = zipFile;

                ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(objFile));

                ZipEntry ze = null;
                //创建一个ZipEntry，并设置Name和其它的一些属性
                ze = new ZipEntry(sourceFile.getName());
                ze.setSize(sourceFile.length());
                ze.setTime(sourceFile.lastModified());

                //将ZipEntry加到zos中，再写入实际的文件内容
                zos.putNextEntry(ze);

                InputStream is = new BufferedInputStream(new FileInputStream(sourceFile));

                int readLen = -1;
                while ((readLen = is.read(buf, 0, 1024)) != -1) {
                        zos.write(buf, 0, readLen);
                }
                is.close();
                zos.close();

                return objFile.length();
        }

        /**
         * 测试解压缩功能. 将d:\\download\\test.zip连同子目录解压到d:\\temp\\zipout目录下.
         *
         * @throws Exception
         */
        public void releaseZipToFile(String sourceZip, String outFileName)
                        throws IOException{
                      ZipFile zfile=new ZipFile(sourceZip);
                      System.out.println(zfile.getName());
                      Enumeration zList=zfile.entries();
                      ZipEntry ze=null;
                      byte[] buf=new byte[1024];
                      while(zList.hasMoreElements()){
                      //从ZipFile中得到一个ZipEntry
                      ze=(ZipEntry)zList.nextElement();
                      if(ze.isDirectory()){
                      continue;
                      }
                      //以ZipEntry为参数得到一个InputStream，并写到OutputStream中
                      OutputStream os=new BufferedOutputStream(new FileOutputStream(getRealFileName(outFileName, ze.getName())));
                      InputStream is=new BufferedInputStream(zfile.getInputStream(ze));
                      int readLen=0;
                      while ((readLen=is.read(buf, 0, 1024))!=-1) {
                      os.write(buf, 0, readLen);
                      }
                      is.close();
                      os.close();
                      System.out.println("Extracted: "+ze.getName());
                      }
                      zfile.close();

        }

        /**
         * 取得指定目录下的所有文件列表，包括子目录.
         *
         * @param baseDir
         *            File 指定的目录
         * @return 包含java.io.File的List
         */
        private List getSubFiles(File baseDir) {
                List ret = new ArrayList();
                //File base=new File(baseDir);
                File[] tmp = baseDir.listFiles();
                for (int i = 0; i < tmp.length; i++) {
                        if (tmp[i].isFile()) {
                                ret.add(tmp[i]);
                        }
                        if (tmp[i].isDirectory()) {
                                ret.addAll(getSubFiles(tmp[i]));
                        }
                }
                return ret;
        }

        /**
         * 给定根目录，返回一个相对路径所对应的实际文件名.
         *
         * @param baseDir
         *            指定根目录
         * @param absFileName
         *            相对路径名，来自于ZipEntry中的name
         * @return java.io.File 实际的文件
         */
        private File getRealFileName(String baseDir, String absFileName) {
                String[] dirs = absFileName.split("/");
                //System.out.println(dirs.length);
                File ret = new File(baseDir);
                //System.out.println(ret);
                if (dirs.length > 1) {
                        for (int i = 0; i < dirs.length - 1; i++) {
                                ret = new File(ret, dirs[i]);
                        }
                }
                if (!ret.exists()) {
                        ret.mkdirs();
                }
                ret = new File(ret, dirs[dirs.length - 1]);
                return ret;
        }

        /**
         * 给定根目录，返回另一个文件名的相对路径，用于zip文件中的路径.
         *
         * @param baseDir
         *            java.lang.String 根目录
         * @param realFileName
         *            java.io.File 实际的文件名
         * @return 相对文件名
         */
        private String getAbsFileName(String baseDir, File realFileName) {
                File real = realFileName;
                File base = new File(baseDir);
                String ret = real.getName();
                while (true) {
                        real = real.getParentFile();
                        if (real == null)
                                break;
                        if (real.equals(base))
                                break;
                        else {
                                ret = real.getName() + "/" + ret;
                        }
                }
                System.out.println("TTTTT" + ret);
                return ret;
        }

        public void testReadZip() throws Exception{
        String baseDir="d:\\temp\\zipout";
        ZipFile zfile=new ZipFile("d:\\download\\src.zip");
        System.out.println(zfile.getName());
        Enumeration zList=zfile.entries();
        ZipEntry ze=null;
        byte[] buf=new byte[1024];
        while(zList.hasMoreElements()){
        //从ZipFile中得到一个ZipEntry
        ze=(ZipEntry)zList.nextElement();
        if(ze.isDirectory()){
        continue;
        }
        //以ZipEntry为参数得到一个InputStream，并写到OutputStream中
        OutputStream os=new BufferedOutputStream(new FileOutputStream(getRealFileName(baseDir, ze.getName())));
        InputStream is=new BufferedInputStream(zfile.getInputStream(ze));
        int readLen=0;
        while ((readLen=is.read(buf, 0, 1024))!=-1) {
        os.write(buf, 0, readLen);
        }
        is.close();
        os.close();
        System.out.println("Extracted: "+ze.getName());
        }
        zfile.close();
        }

   public static void main(String args[]){
     ZipManager manager = new ZipManager();
     try {
       //manager.releaseZipToFile("c:\\test.zip","c:\\test");
       manager.testReadZip();
     }
     catch (Exception e) {}
     System.out.println("over");
   }
 

}

　VO和PO的主要区别在于：
　　VO是独立的Java Object。
　　PO是由Hibernate纳入其实体容器（Entity Map）的对象，它代表了与数据库中某条记录对应的Hibernate实体，PO的变化在事务提交时将反应到实际数据库中。

　实际上，这个VO被用作Data Transfer Object，即所谓的DTO。想必，VO就是Data Access Object ---DAO了啦。为什么要有这二者之分呢？如在传统的MVC架构中，位于Model层的PO，是否允许被传递到其他层面。由于PO的更新最终将被映射到实际数据库中，如果PO在其他层面（如View层）发生了变动，那么可能会对Model层造成意想不到的破坏。

　主要想说的还是如何进行二者之间的转换：
　　属性复制可以通过Apache Jakarta Commons Beanutils（http://jakarta.apache.org/commons/beanutils/）组件提供的属性批量复制功能，避免繁复的get/set操作。down下来之后，里面的API DOC一应俱全。

　对于一些无需处理其它处理（如过滤）直接用BeanUtilsBean.copyProperties方法，其参考如下：

public static void copyProperties(java.lang.Object dest,
                                  java.lang.Object orig)
                           throws java.lang.IllegalAccessException,
                                  java.lang.reflect.InvocationTargetExceptioCopy property values from the origin bean to the destination bean for all cases where the property names are the same.
　范例１：

 TUser user  =   new  TUser();
TUser anotherUser  =   new  TUser();
user.setName( " Emma " );
user.setUserType( 1 );
 try    {
BeanUtils.copyProperties(anotherUser,user);
System.out.println( " UserName =>  "
 + anotherUser.getName()
);
System.out.println( " UserType =>  "
 +  anotherUser.getUserType()
);
}   catch  (IllegalAccessException e)   {
e.printStackTrace();
}   catch  (InvocationTargetException e)   {
e.printStackTrace();
} 　
 

　也可以利用其中的一些方法在copy属性的时候达到自己的要求，如：

　范例２

  /** */ /** //*
 * Created on 2006-4-26
  */
 package  com.util;

 import  java.beans.PropertyDescriptor;
 import  java.util.Collection;

 import  org.apache.commons.beanutils.PropertyUtils;

 /** */ /**   */ /** */ /**
 * CopyUtil
 *  @author  Jkallen
  */
  public   class  CopyUtil   {
   
     /** */ /**   */ /** */ /**
     * Copy properties of orig to dest
     * Exception the Entity and Collection Type
     *  @param  dest
     *  @param  orig
     *  @return  the dest bean
      */
      public   static  Object copyProperties(Object dest, Object orig)   {
         if  (dest  ==   null   ||  orig  ==   null )   {
             return  dest;
        }
       
        PropertyDescriptor[] destDesc  =  PropertyUtils.getPropertyDescriptors(dest);
         try    {
             for  ( int  i  =   0 ; i  <  destDesc.length; i ++ )   {
                Class destType  =  destDesc[i].getPropertyType();
                Class origType  =  PropertyUtils.getPropertyType(orig, destDesc[i].getName());
                 if (destType  !=   null   &&  destType.equals(origType)
                         &&   ! destType.equals(Class. class ))   {
                     if ( ! Collection. class .isAssignableFrom(origType))  {                   
                         try  {
                            Object value  =  PropertyUtils.getProperty(orig, destDesc[i].getName());
                            PropertyUtils.setProperty(dest, destDesc[i].getName(), value);
                        } catch (Exception ex)  {                           
                        }
                    }
                }
            }
           
             return  dest;
        } catch (Exception ex)   {
             throw   new  CopyException(ex);
 //             return dest;
         }
    }    
   
     /** */ /**   */ /** */ /**
     * Copy properties of orig to dest
     * Exception the Entity and Collection Type
     *  @param  dest
     *  @param  orig
     *  @param  ignores
     *  @return  the dest bean
      */
      public   static  Object copyProperties(Object dest, Object orig, String[] ignores)   {
         if  (dest  ==   null   ||  orig  ==   null )   {
             return  dest;
        }
       
        PropertyDescriptor[] destDesc  =  PropertyUtils.getPropertyDescriptors(dest);
         try    {
             for  ( int  i  =   0 ; i  <  destDesc.length; i ++ )   {
                 if  (contains(ignores, destDesc[i].getName()))   {
                     continue ;
                }
               
                Class destType  =  destDesc[i].getPropertyType();
                Class origType  =  PropertyUtils.getPropertyType(orig, destDesc[i].getName());
                 if (destType  !=   null   &&  destType.equals(origType)
                         &&   ! destType.equals(Class. class ))   {
                     if ( ! Collection. class .isAssignableFrom(origType))  {
                        Object value  =  PropertyUtils.getProperty(orig, destDesc[i].getName());
                        PropertyUtils.setProperty(dest, destDesc[i].getName(), value);
                    }
                }
            }
           
             return  dest;
        } catch (Exception ex)   {
             throw   new  CopyException(ex);
        }
    }
   
     static   boolean  contains(String[] ignores, String name)   {
         boolean  ignored  =   false ;
         for  ( int  j  =   0 ; ignores  !=   null   &&  j  <  ignores.length; j ++ )   {
             if  (ignores[j].equals(name))   {
                ignored  =   true ;
                 break ;
            }
        }
       
         return  ignored;
    }
}
 
 
　　

　　可以看到，在范例１中通过方法copyProperties的时候，二者之间在的属性名必须相同（Copy property values from the origin bean to the destination bean for all cases where the property names are the same）。而在范例２中通过
 　　Object value = PropertyUtils.getProperty(orig, destDesc[i].getName());
  　　PropertyUtils.setProperty(dest, destDesc[i].getName(), value);
　　也是将源与目的之间copy相同的属性名。而VO是在前台显示，所以难免会用到PO中所不存在的属性值。比如PO中可能是一个对象，而VO中则可能是此对象的全部属性。其中的一些转换则需要依据前台需要针对性地处理啦！

Reference:  Apache DOC and <>

板桥里人 http://www.jdon.com 2005/09/12

　　Struts/Tapestry/JSF是目前J2EE表现层新老组合的框架技术。从诞生时间上看，Struts应该比较早，使用得非常广泛，Tapestry 3.0逐渐引起广泛的重视，正当Tapestry即将大显身手时期，SUN推出JSF标准技术，虽然JSF一开始推出尚不成熟，留出了一段空白期，但是随着JSF1.1标准推出，JSF开始正面出击，粉面隆重登场了。

　　其实，JSF和Tapestry也并不是那种头碰头的相同竞争性技术，两者还是各有侧重点的，不过比较细微，但是这种细微点在实现一个大工程时可能带来不同的感受和变化。

　　首先，我们从一个高度来抽象一下表现层框架应有的技术架构，下图可以说所有表现层框架技术都必须实现的功能架构图：

　　当然，我们不必废话罗嗦MVC模式，MVC模式是基准模式，现在框架技术已经不必再拼是否是MVC模式了。 在上图MVC模式基础上，一个表现层框架无外乎要实现图中的三个功能：

1.在当前页面能够显示一个组件对象的内容；而不是象纯JSP那样，需要在Jsp页面写入“调用对象方法”的Java代码。

2.当用户按下页面的提交按扭或链接后，事件发生，这时应该触发服务器端并将当前页面的参数提交给服务器。这种机制表现在Form表单提交和有参数的链接<a href=""></a>

3.从一个页面视图直接跳转到另外一个页面视图，单纯的导航作用。

我们通过下表来比较这 三种框架在实现上图各个功能时技术细节，从而得出他们的异同点和偏重点。

Struts组件编程模型

　　Struts实现组件编程时有一些复杂：经常为一个页面中需要引入多个组件而头疼，因为Struts中无法直接引入多个组件，必须绕一些圈子:

　　一般分两种情况：如果同一个Action就可以对付这些组件，那么在这种情况下有两个办法：

1.将这多个组件装入一个ActionForm中，如使用MapForm等机制；

2.手工将多个组件装入request/session等scope中，然后根据其名称在jsp中获得。

　　这两个方法都有缺点： 第一种办法经常一个ActionForm弄得面目全非，变成一个大杂烩，违反了OO分派封装的原则；第2种办法其实又回到jsp编程；

　　第二种情况，如果这些组件必须有预先由不同的Action来处理，每个组件必须经过Action -->ActionForm流程，在这种情况下有两种办法：

1.使用Tiles, 不同流程输出到同一个页面的不同区域。是一种并行处理方式。

2. 对多个流程首尾相连，第一Action forward结果是第二个Action，最后输出一个Jsp，在这个jsp中就可以使用前面多个流程的多个ActionForm了，这属于串行方式。

Struts组件模型缺点

　　Struts组件编程必须限定在Action/ActionForm/JSP这三个框框中做文章，难度相对比较大，而Tapestry/JSF则没有太多这些技术框框限制，两者在组件编程方面更让编程者自由一些，方便一些，这也是组件型框架的优势吧。

Struts标签库

　　在Struts中，经常需要使用标签库来显示组件ActionForm中内容，这就涉及到一个结合的问题，标签库是别人写的，参考Struts的标签库用法，而组件是自己的，难度和麻烦就体现在这个结合点上。

　　JSF基本思路和Struts差不多，只不过换了不同标签库，也需要标签库+组件的结合思考，不过因为组件这里是通用组件，没有什么限制，所以这样比Struts要轻松一些。

　　Tapestry使用了组件库概念替代了标签库，没有标签库概念，这样就没有标签库和自己的组件需要结合的问题，都是组件的使用，组件中分Tapestry标准组件和自己定义的组件，这也是接触了Jsp体系的人学习Tapestry面临的一个思路转换。

　　具体以页面跳转为例子，页面跳转是靠链接<a href="目标"></a> 实现，链接是页面经常使用的元素。

　　Struts提供的html:link在频繁使用就特别不方便，尤其在传递多个参数时：其中html:link的page值，是跳转对方页面或Action的path，这个path一般需要到struts-config.xml查找Action的相应path,一旦配置文件path值修改，涉及到这个所有相关页面都要修改。

　　JSF将链接概念划分两个方面：导航性质和事件激活，在导航方面还是需要到配置faces-config查询Navigation的from-outcome的值。

　　由于Tapestry没有标签库概念，只有组件或页面两个概念，因此，链接跳转目标要么是组件，要么是页面，简洁简单，它没有多余的path概念，就是组件名，也就是对象名称，组件名称和path名称合二为一。

总结

　　JSF在很大程度上类似Struts，而不是类似Tapestry，可以说是一种Struts 2.0，都是采取标签库+组件的形式，只是JSF的组件概念没有象Struts那样必须继承ActionForm的限制；JSF在事件粒度上要细腻，不象Struts那样，一个表单一个事件，JSF可以细化到表单中的每个字段上。

　　JSF只有在组件和事件机制这个概念上类似Tapestry，但是不似Tapestry那样是一个完全组件的框架，所以，如果你做一个对页面要求灵活度相当高的系统，选用Tapestry是第一考虑。

　　Struts/JSF则适合在一般的数据页面录入的系统中，对于Struts和JSF的选用，我目前个人观点是：如果你是一个新的系统，可以直接从JSF开始；如果你已经使用Struts，不必转换，如果需要切换，可以将JSF和Tapestry一起考虑。

　　另外，JSF/Tapestry不只是支持Html，也支持多种客户端语言如WML或XUI等。

　　这三者之间关系：如果说Struts是左派；那Tapestry则是右派；而JSF则是中间派，中庸主义是SUN联盟的一贯策略。