欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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

程序员文章站 2022-07-02 09:34:20
...
java中两个对象间的属性值复制,比较,转为map方法实现
            
    
    博客分类: JAVA java对象字段复制
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();
      }
}
java中两个对象间的属性值复制,比较,转为map方法实现
            
    
    博客分类: JAVA java对象字段复制