java中两个对象间的属性值复制，比较，转为map方法实现

package com.franson.study.util;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class BeanUtil {

    private static Log log = LogFactory.getLog(BeanUtil.class);

    /**
     * 两对象之间的拷贝(在目标对象中存在的所有set方法，如果在源对象中存在对应的get方法，不管源对象的get方法的返回值是否为null,都进行拷贝)
     * 仅拷贝方法名及方法返回类型完全一样的属性值
     * @param desc     目标对象
     * @param orig     源对象
     * @param excludeFields 不拷贝的field（多个用逗号隔开）
     */
    public static void copyPropertiesNotForce(Object desc, Object orig,String excludeFields) {
        copyPropertiesNotForce(desc, orig, excludeFields, true);
    }
    /**
     * 两对象之间的拷贝(在目标对象中存在的所有set方法，如果在源对象中存在对应的get方法，不管源对象的get方法的返回值是否为null,都进行拷贝)
     * 仅拷贝方法名及方法返回类型完全一样的属性值
     * @param desc     目标对象
     * @param orig     源对象
     * @param excludeFields     源对象
     * @param isCopyNull     为null的属性是否拷贝(true拷贝null属性;false不拷贝null属性)
     * @param excludeFields 不拷贝的field（多个用逗号隔开）
     */
    public static void copyPropertiesNotForce(Object desc, Object orig,String excludeFields, boolean isCopyNull) {
        Class<?> origClass = orig.getClass();
        Class<?> descClass = desc.getClass();

        Method[] descMethods = descClass.getMethods();
        Method[] origMethods = origClass.getMethods();

        boolean needExclude = false;                    //是否需要过滤部分字段
        if(!StringUtil.isEmpty(excludeFields)){
            needExclude = true;
            excludeFields = "," + excludeFields.toLowerCase() + ",";
        }

        Map<String,Method> methodMap = new HashMap<String,Method>();
        for (int i = 0; i < origMethods.length; i++) {
            Method method = origMethods[i];
            String methodName = method.getName();
            if (!methodName.equals("getClass")
                    && methodName.startsWith("get")
                    && (method.getParameterTypes() == null || method
                            .getParameterTypes().length == 0)) {
                if(needExclude && excludeFields.indexOf(methodName.substring(3).toLowerCase()) > -1){
                    continue;
                }
                methodMap.put(methodName, method);
            }
        }
        for (int i = 0; i < descMethods.length; i++) {
            Method method = descMethods[i];
            String methodName = method.getName();
            if (!methodName.equals("getClass")
                    && methodName.startsWith("get")
                    && (method.getParameterTypes() == null || method
                            .getParameterTypes().length == 0)) {
                if (methodMap.containsKey(methodName)) {
                    Method origMethod = (Method) methodMap.get(methodName);
                    try {
                        if (method.getReturnType().equals(
                                origMethod.getReturnType())) {
                            Object returnObj = origMethod.invoke(orig, null);
                            if(!isCopyNull && returnObj == null){
                                continue;
                            }

                            String field = methodName.substring(3);
                            String setMethodName = "set" + field;
                            Method setMethod = descClass.getMethod(
                                    setMethodName, new Class[] { method
                                            .getReturnType() });
                            setMethod.invoke(desc, new Object[] { returnObj });
                        }
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    } catch (SecurityException e) {
                        e.printStackTrace();
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 两对象之间的拷贝(在目标对象中存在的所有set方法，如果在源对象中存在对应的get方法，不管源对象的get方法的返回值是否为null,都进行拷贝)
     * 仅拷贝方法名及方法返回类型完全一样的属性值
     * @param desc     目标对象
     * @param orig     源对象
     */
    public static void copyPropertiesNotForce(Object desc, Object orig) {
        copyPropertiesNotForce(desc, orig, null);
    }

    /**
     * 两对象之间的拷贝(在目标对象中存在的所有set方法，如果在源对象中存在对应的get方法，源对象的get方法的返回值为null的不拷贝)
     * 仅拷贝方法名及方法返回类型完全一样的属性值
     * @param desc     目标对象
     * @param orig     源对象
     * @param excludeFields 不拷贝的field（多个用逗号隔开）
     */
    public static void copyPropertiesNotNull(Object desc, Object orig) {
        copyPropertiesNotForce(desc, orig, null, false);
    }

    public static void copyPropertiesNotNull(Object desc, Object orig,String excludeFields) {
        copyPropertiesNotForce(desc, orig, excludeFields, false);
    }
    /**
     * 判断两个对象的所有相同属性值是否相等,注意尽是比较相同的属性,对于A对象属性比B对象属性多，如果相同属性值相同，则返回为true
     * @param desc
     * @param orig
     * @return 相等返回true，否则返回false
     * @throws CrmBaseException
     */
public static boolean isEqualBeanProperties(Object desc, Object orig) throws CrmBaseException {
        String result= compareBeanProperties(desc,orig);
        if(result.equals("[]"))
            return true;
        return false;
}
    /**
     * 比较两个Bean相同字段的值（以源对象的值为基准，json串中显示目标对象中的值）【仅比较可转换为string的类型】
     * @param desc 目标对象
     * @param orig 源对象
     * @return String 不一致的字段json串
     * @throws  ServiceException
     */
    public static String compareBeanProperties(Object desc, Object orig)
            throws CrmBaseException {
        Map<String, Object> map = new HashMap<String, Object>();
        Class<?> origClass = orig.getClass();
        Class<?> descClass = desc.getClass();

        Method[] descMethods = descClass.getMethods();
        Method[] origMethods = origClass.getMethods();

        Map<String,Method> methodMap = new HashMap<String,Method>();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < origMethods.length; i++) {
            Method method = origMethods[i];
            String methodName = method.getName();
            if (!methodName.equals("getClass")
                    && methodName.startsWith("get")
                    && (method.getParameterTypes() == null || method
                            .getParameterTypes().length == 0)) {
                methodMap.put(methodName, method);
            }
        }
        for (int i = 0; i < descMethods.length; i++) {
            Method method = descMethods[i];
            String methodName = method.getName();
            if (!methodName.equals("getClass")
                    && methodName.startsWith("get")
                    && (method.getParameterTypes() == null || method
                            .getParameterTypes().length == 0)) {
                if (methodMap.containsKey(methodName)) {
                    Method origMethod = (Method) methodMap.get(methodName);
                    try {
                        if (method.getReturnType().equals(
                                origMethod.getReturnType())) {
                            Object origObj = origMethod.invoke(orig, null);
                            origObj = origObj == null ? "" : origObj;

                            Method descMethod = descClass.getMethod(methodName,
                                    null);
                            Object descObj = descMethod.invoke(desc, null);
                            descObj = descObj == null ? "" : descObj;

                            if (!origObj.equals(descObj)) {
                                map.put(methodName.substring(3), descObj);
                                sb.append(",{'field':'");
                                sb.append(methodName.substring(3));
                                sb.append("','msg':'");
                                sb.append(descObj.toString().replaceAll("\'",
                                        ""));
                                sb.append("'}");
                            }
                        }
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    } catch (SecurityException e) {
                        e.printStackTrace();
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        String str = "[";
        if (sb.length() > 0) {
            str += sb.substring(1);
        }
        return str + "]";
    }

    /**
     * bean转Map
     * @param bean
     * @return
     */
    public static Map beanToMap(Object bean){
         //return bean2Map(bean);
        return objectToMap(bean);
    }

    /**
     * 通过字段名获取方法数组
     * @param beanClass            Class<?>
     * @param fieldNameArray    要输出的所有字段名数组
     * @return                Method[]
     */
    public static Method[] getMethods(Class<?> beanClass,String[] fieldNameArray){
        Method[] methodArray = new Method[fieldNameArray.length];

        String methodName;
        String fieldName;
        for (int i=0;i<fieldNameArray.length;i++) {
            Method method = null;
            fieldName = fieldNameArray[i];
            methodName = fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);
            try {
                method = beanClass.getMethod("get"+methodName, null);
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                try {
                    method = beanClass.getMethod("is"+methodName, null);
                } catch (SecurityException e1) {
                    e1.printStackTrace();
                } catch (NoSuchMethodException e1) {
                    e1.printStackTrace();
                }
            }
            methodArray[i] = method;
        }

        return methodArray;
    }

    private static <K, V> Map<K, V> bean2Map(Object javaBean) {
        Map<K, V> ret = new HashMap<K, V>();
        try {
            Method[] methods = javaBean.getClass().getDeclaredMethods();
            for (Method method : methods) {
                if (method.getName().startsWith("get")) {
                    String field = method.getName();
                    field = field.substring(field.indexOf("get") + 3);
                    field = field.toLowerCase().charAt(0) + field.substring(1);
                    Object value = method.invoke(javaBean, (Object[]) null);
                    ret.put((K) field, (V) (null == value ? "" : value));
                }
            }
        } catch (Exception e) {
        }
        return ret;
    }

     public static Map objectToMap(Object o){
        return objectToMap(o, "");
      }

     private static Map objectToMap(Object o, String prefix)
      {
        Map ret = new HashMap();
        if (o == null)
          return ret;
        try {
          Map objDesc = PropertyUtils.describe(o);

          prefix = (!("".equals(prefix))) ? prefix + "." : "";
          for (Iterator it = objDesc.keySet().iterator(); it.hasNext(); ) {
            String key = it.next().toString();
            Object val = objDesc.get(key);
            if ((val != null) && (val instanceof CrmValueObject) && (!(o.equals(val))))
            {
              ret.putAll(objectToMap(val, prefix + key)); break;
            }
            ret.put(prefix + key, val);
          }
        } catch (Exception e) {
            e.printStackTrace();
          //logger.error(e);
        }
        //logger.debug("Object " + o + " convert to map: " + ret);
        return ret;
      }

    public static Map objectToMap(List fieldNameList, Object object)
      {
        Map ret = new HashMap();
        for (Iterator it = fieldNameList.iterator(); it.hasNext(); ) {
          String fieldName = (String)it.next();
          String[] fs = fieldName.split(quote("."));
          try {
            Object o = object;
            for (int i = 0; i < fs.length; ++i) {
              Map objDesc = PropertyUtils.describe(o);
              o = objDesc.get(fs[i]);
              if (o == null)
                break;
            }
            ret.put(fieldName, o);
          } catch (Exception e) {
              e.printStackTrace();
            //logger.error(e);
          }
        }
        return ret;
      }

    public static String quote(String s)
      {
        int slashEIndex = s.indexOf("\\E");
        if (slashEIndex == -1)
          return "\\Q" + s + "\\E";

        StringBuffer sb = new StringBuffer(s.length() * 2);
        sb.append("\\Q");
        slashEIndex = 0;
        int current = 0;
        while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
          sb.append(s.substring(current, slashEIndex));
          current = slashEIndex + 2;
          sb.append("\\E\\\\E\\Q");
        }
        sb.append(s.substring(current, s.length()));
        sb.append("\\E");
        return sb.toString();
      }
}