精华内容
下载资源
问答
  • java对象复制和属性值复制工具类

    千次阅读 2017-11-30 16:19:10
    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后...如果同一种类型的对象 属性字段名equals相等 并且类型一致。则完全可以用commons-beanutils包或者spring包

    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后就写了一个这种工具类
    我的类型比较特殊,老系统和新系统的对象命名大小写命名不一致,并且字段相同类型也有不一致的情况,所以自己写了一个,
    不是很完美基本能用。

    温馨提示:
    如果同一种类型的对象 属性字段名equals相等 并且类型一致。则完全可以用commons-beanutils包或者spring包中
    的BeanUtils工具类中的copey属性方法。

    /**
     * 实体类字段值相同的复制
     *
     * @author 隔壁老王 2017年8月18日
     */
    public class CopyBeanUtil {
        static Logger log = LoggerFactory.getLogger(CopyBeanUtil.class);
    
        /**
         * 复制sour里属性不为空的值到obje为空的属性
         *
         * @param obje    目标实体类
         * @param sour    源实体类
         * @param isCover 是否保留obje类里不为null的属性值(true为保留源值,属性为null则赋值)
         * @return obje
         */
        public static Object Copy(Object obje, Object sour, boolean isCover) {
            Field[] fields = sour.getClass().getDeclaredFields();
            for (int i = 0, j = fields.length; i < j; i++) {
                String propertyName = fields[i].getName();
                Object propertyValue = getProperty(sour, propertyName);
                if (isCover) {
                    if (getProperty(obje, propertyName) == null && propertyValue != null) {
                        Object setProperty = setProperty(obje, propertyName, propertyValue);
                    }
                } else {
                    Object setProperty = setProperty(obje, propertyName, propertyValue);
                }
    
            }
            return obje;
        }
    
        /**
         * 复制sour里属性不为空的值到obj里并相加
         *
         * @param obj     目标实体类
         * @param sour    源实体类
         * @param isCover
         * @return obj
         */
        public static Object CopyAndAdd(Object obj, Object sour, boolean isCover) {
            Field[] fields = sour.getClass().getDeclaredFields();
            for (int i = 0, j = fields.length; i < j; i++) {
                String propertyName = fields[i].getName();
                Object sourPropertyValue = getProperty(sour, propertyName);
                Object objPropertyValue = getProperty(obj, propertyName);
                if (isCover) {
                    if (objPropertyValue == null && sourPropertyValue != null) {
                        Object setProperty = setProperty(obj, propertyName, sourPropertyValue);
                    } else if (objPropertyValue != null && sourPropertyValue == null) {
                        Object setProperty = setProperty(obj, propertyName, objPropertyValue);
                    } else if (objPropertyValue != null && sourPropertyValue != null) {
                        Object setProperty = setProperty(obj, propertyName, ((int) sourPropertyValue) + (int) objPropertyValue);
                    }
                }
    
            }
            return obj;
        }
    
    
        /**
         * 得到值
         *
         * @param bean
         * @param propertyName
         * @return
         */
        private static Object getProperty(Object bean, String propertyName) {
            Class clazz = bean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                Method method = clazz.getDeclaredMethod(getGetterName(field.getName(),field.getType()), new Class[]{});
                return method.invoke(bean, new Object[]{});
            } catch (Exception e) {
            }
            return null;
        }
    
        /**
         * 给bean赋值
         *
         * @param bean
         * @param propertyName
         * @param value
         * @return
         */
        private static Object setProperty(Object bean, String propertyName, Object value) {
            Class clazz = bean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                return method.invoke(bean, new Object[]{value});
            } catch (Exception e) {
            }
            return null;
        }
    
        /**
         * 根据变量名得到get方法
         *
         * @param propertyName
         * @return
         */
        private static String getGetterName(String propertyName) {
            String method ;
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                 method = "get" +propertyName;
            }else{
                method = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
        /**
         * 根据变量名和类型获取getter方法
         * @param propertyName
         * @param type
         * @return
         */
        private static String getGetterName(String propertyName, Class<?> type) {
            String method ;
            if(type==Boolean.class|| type==boolean.class){
                if("is".equalsIgnoreCase(propertyName.substring(0, 2))){
                    return propertyName;
                }else{
                    return "is" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                }
    
            }
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                method = "get" +propertyName;
            }else{
                method = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
        /**
         * 得到setter方法
         *
         * @param propertyName 变量名
         * @return
         */
        private static String getSetterName(String propertyName) {
    //        String method = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            String method ;
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                method = "set" +propertyName;
            }else{
                method = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
    
        /**
         * 父类集合转成子类集合集合通用方法(子类集合接收父类集合)
         *
         * @param list 父类集合
         * @param <T>  子类
         * @param <E>  父类
         * @return
         */
        public static <T, E> List<T> chang2ChildClassList(List<E> list) {
            List<T> alist = new ArrayList<>();
            for (E o : list) {
                alist.add((T) o);
            }
            return alist;
    
        }
    
        /**
         * 属性copy  复制sour里属性和obje里属性值忽略大小写相同的 ,不为空的值赋值到obje里
         * 如果存在属性复杂类型并为有效值慎用或改进
         *
         * @param obje
         * @param sour
         * @param isCover 是否保留obje里面属性值不为空的字段值
         * @return
         */
        public static Object copyByIgnoreCase(Object obje, Object sour, boolean isCover) {
    
            try {
                Field[] objFields = obje.getClass().getDeclaredFields();
    
                Field[] sourFields = sour.getClass().getDeclaredFields();
                for (int i = 0; i < sourFields.length; i++) {
                    String sourPropertyName = sourFields[i].getName();
                    //获取来源对象的属性值
                    Object propertyValue = getSourPropertyValue(sour, sourPropertyName);
                    for (int j = 0; j < objFields.length; j++) {
    
                        try {
                            String objPropertyName = objFields[j].getName();
                            if (objPropertyName.equalsIgnoreCase(sourPropertyName)) {
                                if (isCover) {
                                    if (getProperty(obje, objPropertyName) == null && propertyValue != null) {
                                        setObjProperty(obje, objPropertyName, propertyValue);
                                    }
                                } else {
                                    setObjProperty(obje, objPropertyName, propertyValue);
                                }
                                break;
                            }
                        } catch (Exception e) {
                            log.error("给目标bean赋值出错,objPropertyName:{},value:{}",sourPropertyName,propertyValue,e);
                            e.printStackTrace();
                        }
                    }
    
                }
            } catch (SecurityException e) {
                e.printStackTrace();
                log.error("给目标bean赋值出错,obje:{},sour:{}", JSON.toJSONString(obje), JSON.toJSONString(sour),e);
            }
            return obje;
        }
    
        /**
         * 根据属性名获取的值
         *
         * @param sourceBean
         * @param sourcePropertyName
         * @return
         */
        private static Object getSourPropertyValue(Object sourceBean, String sourcePropertyName) {
            Class clazz = sourceBean.getClass();
            try {
                Field field = clazz.getDeclaredField(sourcePropertyName);
                Method method = clazz.getDeclaredMethod(getGetterName(field.getName(),field.getType()), new Class[]{});
                return method.invoke(sourceBean, new Object[]{});
            } catch (Exception e) {
                log.error("获取属性名(不区分大小写)相似的值赋值出差", e);
            }
            return null;
        }
    
    
    
        /**
         * 给目标bean赋值
         *
         * @param objBean
         * @param sourcePropertyName
         * @param value
         * @return
         */
        private static Object setObjPropertyBySourceProperty(Object objBean, String sourcePropertyName, Object value) {
            Class clazz = objBean.getClass();
            Field[] fields = clazz.getDeclaredFields();
            try {
                for (int i = 0, j = fields.length; i < j; i++) {
                    String propertyName = fields[i].getName();
                    if (sourcePropertyName.equalsIgnoreCase(propertyName)) {
                        Field field = clazz.getDeclaredField(propertyName);
                        if (field.getType() == BigDecimal.class) {
                            if (value instanceof String) {
                                value = new BigDecimal(String.valueOf(value));
                            } else if (value instanceof Integer || value instanceof Double) {
    //							传double直接new BigDecimal,数会变大
                                value = BigDecimal.valueOf(Double.parseDouble(String.valueOf(value)));
                            }
                        }
                        if (field.getType() == Double.class || field.getType() == double.class) {
                            if (value instanceof BigDecimal) {
                                DecimalFormat df = new DecimalFormat("#.000000");
                                Double v = Double.parseDouble(String.valueOf(value));
                                value = df.format(v);
                            }
                        }
    
                        Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                        return method.invoke(objBean, new Object[]{value});
                    }
                }
    
            } catch (Exception e) {
            }
            return null;
        }
    
    
        /**
         * 给目标bean赋值
         *
         * @param objBean
         * @param propertyName
         * @param value
         * @return
         */
        private static Object setObjProperty(Object objBean, String propertyName, Object value) {
            Class clazz = objBean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                if (field.getType() == BigDecimal.class) {
                    if (value instanceof String) {
                        value = new BigDecimal(String.valueOf(value));
                    } else if (value instanceof Integer || value instanceof Double) {
    //							传double直接new BigDecimal,数会变大
                        value = BigDecimal.valueOf(Double.parseDouble(String.valueOf(value)));
                    }
                }
                if (field.getType() == Double.class || field.getType() == double.class) {
                    if (value instanceof BigDecimal) {
                        DecimalFormat df = new DecimalFormat("#.000000");
                        Double v = Double.parseDouble(String.valueOf(value));
                        value =new BigDecimal(df.format(v));
                    }
                }
                if (field.getType() == Integer.class || field.getType() == int.class) {
                    if (value instanceof Float) {
                         value = Math.round(Float.parseFloat(String.valueOf(value)));
                    }
                }
                Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                log.info("给目标bean赋值,propertyName:{},value:{}",propertyName,value);
                Object obj = method.invoke(objBean, new Object[]{value});
                return obj;
    
            } catch (Exception e) {
                log.error("给目标bean赋值出错,propertyName:{},value:{}",propertyName,value,e);
            }
            return null;
        }
        public static void main(String[] args) {
    //        ReAlarmResult re= new ReAlarmResult();
    //        re.setAlarmContent("sdfsdfsd");
    //        re.setBlat(2.234343);
    //        re.setBlon(34.34324);
    //        ReAlarmResult s = new ReAlarmResult();
    //        s.setAlarmContent("222");
    //        copyByIgnoreCase(s,re,true);
    //        System.out.printf(JSON.toJSONString(s));
    //        BeanUtils.copyProperties();
            //BeanUtils.copyProperties();
        }
    
    }
    
    展开全文
  • java 对象之间属性值复制

    万次阅读 2012-07-28 13:12:28
    java对象之间属性值复制在许多开源框架中也有实现,在这里介绍下自己的实现、apache commons-beanutils、Spring三种方式实现。 1 自己实现。采用反射,通过源对象getter 方法获取属性值,并通过目标对象的setter...

    java对象之间属性值复制在许多开源框架中也有实现,在这里介绍下自己的实现、apache commons-beanutils、Spring三种方式实现。

    1 自己实现。采用反射,通过源对象getter 方法获取属性值,并通过目标对象的setter方法设置到目标对象中去。没有考虑太多性能,如果需要批量或者经常性执行该操作,建议不采用此种实现。下面给出源码:

    /**
    	 * 利用反射实现对象之间属性复制
    	 * @param from
    	 * @param to
    	 */
    	public static void copyProperties(Object from, Object to) throws Exception {
    		copyPropertiesExclude(from, to, null);
    	}
    	
    	/**
    	 * 复制对象属性
    	 * @param from
    	 * @param to
    	 * @param excludsArray 排除属性列表
    	 * @throws Exception
    	 */
    	@SuppressWarnings("unchecked")
    	public static void copyPropertiesExclude(Object from, Object to, String[] excludsArray) throws Exception {
    		List<String> excludesList = null;
    		if(excludsArray != null && excludsArray.length > 0) {
    			excludesList = Arrays.asList(excludsArray);	//构造列表对象
    		}
    		Method[] fromMethods = from.getClass().getDeclaredMethods();
    		Method[] toMethods = to.getClass().getDeclaredMethods();
    		Method fromMethod = null, toMethod = null;
    		String fromMethodName = null, toMethodName = null;
    		for (int i = 0; i < fromMethods.length; i++) {
    			fromMethod = fromMethods[i];
    			fromMethodName = fromMethod.getName();
    			if (!fromMethodName.contains("get"))
    				continue;
    			//排除列表检测
    			if(excludesList != null && excludesList.contains(fromMethodName.substring(3).toLowerCase())) {
    				continue;
    			}
    			toMethodName = "set" + fromMethodName.substring(3);
    			toMethod = findMethodByName(toMethods, toMethodName);
    			if (toMethod == null)
    				continue;
    			Object value = fromMethod.invoke(from, new Object[0]);
    			if(value == null)
    				continue;
    			//集合类判空处理
    			if(value instanceof Collection) {
    				Collection newValue = (Collection)value;
    				if(newValue.size() <= 0)
    					continue;
    			}
    			toMethod.invoke(to, new Object[] {value});
    		}
    	}
    	
    	/**
    	 * 对象属性值复制,仅复制指定名称的属性值
    	 * @param from
    	 * @param to
    	 * @param includsArray
    	 * @throws Exception
    	 */
    	@SuppressWarnings("unchecked")
    	public static void copyPropertiesInclude(Object from, Object to, String[] includsArray) throws Exception {
    		List<String> includesList = null;
    		if(includsArray != null && includsArray.length > 0) {
    			includesList = Arrays.asList(includsArray);	//构造列表对象
    		} else {
    			return;
    		}
    		Method[] fromMethods = from.getClass().getDeclaredMethods();
    		Method[] toMethods = to.getClass().getDeclaredMethods();
    		Method fromMethod = null, toMethod = null;
    		String fromMethodName = null, toMethodName = null;
    		for (int i = 0; i < fromMethods.length; i++) {
    			fromMethod = fromMethods[i];
    			fromMethodName = fromMethod.getName();
    			if (!fromMethodName.contains("get"))
    				continue;
    			//排除列表检测
    			String str = fromMethodName.substring(3);
    			if(!includesList.contains(str.substring(0,1).toLowerCase() + str.substring(1))) {
    				continue;
    			}
    			toMethodName = "set" + fromMethodName.substring(3);
    			toMethod = findMethodByName(toMethods, toMethodName);
    			if (toMethod == null)
    				continue;
    			Object value = fromMethod.invoke(from, new Object[0]);
    			if(value == null)
    				continue;
    			//集合类判空处理
    			if(value instanceof Collection) {
    				Collection newValue = (Collection)value;
    				if(newValue.size() <= 0)
    					continue;
    			}
    			toMethod.invoke(to, new Object[] {value});
    		}
    	}
    	
    	
    
    	/**
    	 * 从方法数组中获取指定名称的方法
    	 * 
    	 * @param methods
    	 * @param name
    	 * @return
    	 */
    	public static Method findMethodByName(Method[] methods, String name) {
    		for (int j = 0; j < methods.length; j++) {
    			if (methods[j].getName().equals(name))
    				return methods[j];
    		}
    		return null;
    	}

    2 利用apache commons-beanutils的开源实现。

    BeanUtils.copyProperties(dst, src)。方法能够将源对象和目标对象中相同名称的属性值复制过去。注意的是参数前面的是目标对象,后面是源对象。使用该方法需要注意:不能将入口方法与源对象、目标对象之一放在同一源文件之内,否者将没有任何效果。

    PropertyUtils.copyProperties(dst, src)。功能与BeanUtils.copyProperties类似,只是在同属性名称的类型参数之间可以执行转换操作。

    3 利用Spring实现属性之间的复制。spring内部自有实现方法,如果我们需要在外面采用spring的托管复制,需要修改spring的源码,将spring中的org.springframework.beans.CachedIntrospectionResults类的forClass、getPropertyDescriptor、getBeanInfo改为可见的后重新打包。然后将Spring中关于复制的代码提取出来,最后修改成代码如下:

    /**
    	 * 利用spring实现bean之间属性复制
    	 * @param source
    	 * @param target
    	 */
    	@SuppressWarnings("unchecked")
    	public static void copyPropertiesBySpring(Object source, Object target) throws Exception {
    		Class actualEditable = target.getClass();
    		PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
    		for (int i = 0; i < targetPds.length; i++) {
    			PropertyDescriptor targetPd = targetPds[i];
    			if (targetPd.getWriteMethod() != null) {
    				PropertyDescriptor sourcePd = getPropertyDescriptor(source
    						.getClass(), targetPd.getName());
    				if (sourcePd != null && sourcePd.getReadMethod() != null) {
    					try {
    						Method readMethod = sourcePd.getReadMethod();
    						if (!Modifier.isPublic(readMethod.getDeclaringClass()
    								.getModifiers())) {
    							readMethod.setAccessible(true);
    						}
    						Object value = readMethod.invoke(source, new Object[0]);
    						if(value == null)
    							continue;
    						//集合类判空处理
    						if(value instanceof Collection) {
    //							Collection newValue = (Collection)value;
    //							if(newValue.size() <= 0)
    								continue;
    						}
    						Method writeMethod = targetPd.getWriteMethod();
    						if (!Modifier.isPublic(writeMethod.getDeclaringClass()
    								.getModifiers())) {
    							writeMethod.setAccessible(true);
    						}
    						writeMethod.invoke(target, new Object[] { value });
    					} catch (Throwable ex) {
    					}
    				}
    			}
    		}
    	}	
    	/**
    	 * 获取指定类指定名称的属性描述符
    	 * @param clazz
    	 * @param propertyName
    	 * @return
    	 * @throws BeansException
    	 */
    	@SuppressWarnings("unchecked")
    	public static PropertyDescriptor getPropertyDescriptor(Class clazz,
    			String propertyName) throws BeansException {
    		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
    		return cr.getPropertyDescriptor(propertyName);
    	}
    	
    	
    	/**
    	 * 获取指定类得所有属性描述符
    	 * @param clazz
    	 * @return
    	 * @throws BeansException
    	 */
    	@SuppressWarnings("unchecked")
    	public static PropertyDescriptor[] getPropertyDescriptors(Class clazz) throws BeansException {
    		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
    		return cr.getBeanInfo().getPropertyDescriptors();
    	}
    


     

    展开全文
  • java不同对象之间同名属性值复制

    千次阅读 2017-09-18 12:50:21
    方法能够将源对象和目标对象中相同名称的属性值复制过去。注意的是参数前面的是目标对象,后面是源对象。使用该方法需要注意:不能将入口方法与源对象、目标对象之一放在同一源文件之内,否者将没有任何效果。 使用...

    1. 利用apache commons-beanutils的开源实现

    BeanUtils.copyProperties(dst, src)。方法能够将源对象和目标对象中相同名称的属性值复制过去。注意的是参数前面的是目标对象,后面是源对象。使用该方法需要注意:不能将入口方法与源对象、目标对象之一放在同一源文件之内,否者将没有任何效果。

    使用该方法,代码简洁,但是底层利用反射机制,还有许多校验,性能不是十分好。


    2.利用ReflectASM,自己编写copyProperties方法

    ReflectASM,高性能的反射:

    什么是ReflectASM    ReflectASM是一个很小的java类库,主要是通过asm生产类来实现java反射,执行速度非常快,看了网上很多和反射的对比,觉得ReflectASM比较神奇,很想知道其原理,下面介绍下如何使用及原理;

    [java]  view plain  copy
     print ?
    1. public static void main(String[] args) {    
    2.         User user = new User();    
    3.         //使用reflectasm生产User访问类    
    4.         MethodAccess access = MethodAccess.get(User.class);    
    5.         //invoke setName方法name值    
    6.         access.invoke(user, "setName""张三");    
    7.         //invoke getName方法 获得值    
    8.         String name = (String)access.invoke(user, "getName"null);    
    9.         System.out.println(name);    
    10.     }    
    原理 
       上面代码的确实现反射的功能,代码主要的核心是 MethodAccess.get(User.class); 
    看了下源码,这段代码主要是通过asm生产一个User的处理类 UserMethodAccess(这个类主要是实现了invoke方法)的ByteCode,然后获得该对象,通过上面的invoke操作user类。 

    ASM反射转换:

    [java]  view plain  copy
     print ?
    1. private static Map<Class, MethodAccess> methodMap = new HashMap<Class, MethodAccess>();  
    2.   
    3.     private static Map<String, Integer> methodIndexMap = new HashMap<String, Integer>();  
    4.   
    5.     private static Map<Class, List<String>> fieldMap = new HashMap<Class, List<String>>();  
    6.   
    7.     public static void copyProperties(Object desc, Object orgi) {  
    8.         MethodAccess descMethodAccess = methodMap.get(desc.getClass());  
    9.         if (descMethodAccess == null) {  
    10.             descMethodAccess = cache(desc);  
    11.         }  
    12.         MethodAccess orgiMethodAccess = methodMap.get(orgi.getClass());  
    13.         if (orgiMethodAccess == null) {  
    14.             orgiMethodAccess = cache(orgi);  
    15.         }  
    16.   
    17.         List<String> fieldList = fieldMap.get(orgi.getClass());  
    18.         for (String field : fieldList) {  
    19.             String getKey = orgi.getClass().getName() + "." + "get" + field;  
    20.             String setkey = desc.getClass().getName() + "." + "set" + field;  
    21.             Integer setIndex = methodIndexMap.get(setkey);  
    22.             if (setIndex != null) {  
    23.                 int getIndex = methodIndexMap.get(getKey);  
    24.                 // 参数一需要反射的对象  
    25.                 // 参数二class.getDeclaredMethods 对应方法的index  
    26.                 // 参数对三象集合  
    27.                 descMethodAccess.invoke(desc, setIndex.intValue(),  
    28.                         orgiMethodAccess.invoke(orgi, getIndex));  
    29.             }  
    30.         }  
    31.     }  
    32.   
    33.     // 单例模式  
    34.     private static MethodAccess cache(Object orgi) {  
    35.         synchronized (orgi.getClass()) {  
    36.             MethodAccess methodAccess = MethodAccess.get(orgi.getClass());  
    37.             Field[] fields = orgi.getClass().getDeclaredFields();  
    38.             List<String> fieldList = new ArrayList<String>(fields.length);  
    39.             for (Field field : fields) {  
    40.                 if (Modifier.isPrivate(field.getModifiers())  
    41.                         && !Modifier.isStatic(field.getModifiers())) { // 是否是私有的,是否是静态的  
    42.                     // 非公共私有变量  
    43.                     String fieldName = StringUtils.capitalize(field.getName()); // 获取属性名称  
    44.                     int getIndex = methodAccess.getIndex("get" + fieldName); // 获取get方法的下标  
    45.                     int setIndex = methodAccess.getIndex("set" + fieldName); // 获取set方法的下标  
    46.                     methodIndexMap.put(orgi.getClass().getName() + "." + "get"  
    47.                             + fieldName, getIndex); // 将类名get方法名,方法下标注册到map中  
    48.                     methodIndexMap.put(orgi.getClass().getName() + "." + "set"  
    49.                             + fieldName, setIndex); // 将类名set方法名,方法下标注册到map中  
    50.                     fieldList.add(fieldName); // 将属性名称放入集合里  
    51.                 }  
    52.             }  
    53.             fieldMap.put(orgi.getClass(), fieldList); // 将类名,属性名称注册到map中  
    54.             methodMap.put(orgi.getClass(), methodAccess);  
    55.             return methodAccess;  
    56.         }  
    57.     }  

    展开全文
  • java 复制非空对象属性值

    千次阅读 2017-02-15 11:31:27
    很多时候,我们需要通过对象拷贝,比如说VO类与数据库实体bean类、更新时非空对象不更新,对同一对象不同...但是对于非空属性拷贝就需要自己处理了 在这里借用spring中org.springframework.beans.BeanUtils类提供的方

    很多时候,我们需要通过对象拷贝,比如说VO类与数据库实体bean类、更新时非空对象不更新,对同一对象不同数据分开存储等

    用于对象拷贝,spring 和 Apache都提供了相应的工具类方法,BeanUtils.copyProperties

    但是对于非空属性拷贝就需要自己处理了

    在这里借用spring中org.springframework.beans.BeanUtils类提供的方法copyProperties(Object source, Object target, String... ignoreProperties) 

     

    /**
         * Copy the property values of the given source bean into the given target bean,
         * ignoring the given "ignoreProperties".
         * <p>Note: The source and target classes do not have to match or even be derived
         * from each other, as long as the properties match. Any bean properties that the
         * source bean exposes but the target bean does not will silently be ignored.
         * <p>This is just a convenience method. For more complex transfer needs,
         * consider using a full BeanWrapper.
         * @param source the source bean
         * @param target the target bean
         * @param ignoreProperties array of property names to ignore
         * @throws BeansException if the copying failed
         * @see BeanWrapper
         */
        public static void copyProperties(Object source, Object target, String... ignoreProperties) throws BeansException {
            copyProperties(source, target, null, ignoreProperties);
     
     
     
    /**
         * Copy the property values of the given source bean into the given target bean.
         * <p>Note: The source and target classes do not have to match or even be derived
         * from each other, as long as the properties match. Any bean properties that the
         * source bean exposes but the target bean does not will silently be ignored.
         * @param source the source bean
         * @param target the target bean
         * @param editable the class (or interface) to restrict property setting to
         * @param ignoreProperties array of property names to ignore
         * @throws BeansException if the copying failed
         * @see BeanWrapper
         */
        private static void copyProperties(Object source, Object target, Class<?> editable, String... ignoreProperties)
                throws BeansException {
     
            Assert.notNull(source, "Source must not be null");
            Assert.notNull(target, "Target must not be null");
     
            Class<?> actualEditable = target.getClass();
            if (editable != null) {
                if (!editable.isInstance(target)) {
                    throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                            "] not assignable to Editable class [" + editable.getName() + "]");
                }
                actualEditable = editable;
            }
            PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
            List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
     
            for (PropertyDescriptor targetPd : targetPds) {
                Method writeMethod = targetPd.getWriteMethod();
                if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                    PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                    if (sourcePd != null) {
                        Method readMethod = sourcePd.getReadMethod();
                        if (readMethod != null &&
                                ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                            try {
                                if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                    readMethod.setAccessible(true);
                                }
                                Object value = readMethod.invoke(source);
                                if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                    writeMethod.setAccessible(true);
                                }
                                writeMethod.invoke(target, value);
                            }
                            catch (Throwable ex) {
                                throw new FatalBeanException(
                                        "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                            }
                        }
                    }
                }
            }
        }


    然后封装一下得到以下方法:

     

     

     

     

    /**
         * @author zml2015
         * @Email zhengmingliang911@gmail.com
         * @Time 2017年2月14日 下午5:14:25
         * @Description <p>获取到对象中属性为null的属性名  </P>
         * @param source 要拷贝的对象
         * @return
         */
        public static String[] getNullPropertyNames(Object source) {
            final BeanWrapper src = new BeanWrapperImpl(source);
            java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors();
     
            Set<String> emptyNames = new HashSet<String>();
            for (java.beans.PropertyDescriptor pd : pds) {
                Object srcValue = src.getPropertyValue(pd.getName());
                if (srcValue == null)
                    emptyNames.add(pd.getName());
            }
            String[] result = new String[emptyNames.size()];
            return emptyNames.toArray(result);
        }
     
        /**
         * @author zml2015
         * @Email zhengmingliang911@gmail.com
         * @Time 2017年2月14日 下午5:15:30
         * @Description <p> 拷贝非空对象属性值 </P>
         * @param source 源对象
         * @param target 目标对象
         */
        public static void copyPropertiesIgnoreNull(Object source, Object target) {
            BeanUtils.copyProperties(source, target, getNullPropertyNames(source));
        }

     

     

     

    测试方法就不提供了,自行测试即可

     如果项目中使用的框架有Hibernate的话,则可以通过在实体类上添加下面两条注解

    @DynamicInsert(true)
    @DynamicUpdate(true)

     

    如果想对该注解进一步了解的话,那么可以去官网看英文文档,文档解释的很清楚,在此不再赘述了

     

    https://www.mkyong.com/hibernate/hibernate-dynamic-insert-attribute-example/

    文章首次发布于个人博客(吾勇士的博客)http://wuyongshi.top/articles/2017/02/14/1487063956488.html,欢迎关注我的个人博客

     

     

     
    展开全文
  • BeanUtils.copyProperties map转对象也可,key与属性名相同即可
  • 需求:将对象属性值快速复制到另一个对象上,忽略空值属性和id 直接上代码:BeanUtils 工具类 import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import ...
  • Java对象间属性值复制-Spring的BeanUtil

    万次阅读 热门讨论 2017-08-30 08:51:58
    需求:两个对象中有相同类型相同名称的属性,把一个对象中的属性值复制到另一个对象。先把spring那5个核心的jar包导入到项目中 spring-core-3.2.0.RELEASE.jar spring-beans-3.2.0.RELEASE.jar spring-context-...
  • java 对象属性复制

    千次阅读 2019-04-16 23:29:54
    java 对象属性复制 将一个对象的属性值赋值给另一个对象, 属性名需要相同 import org.springframework.beans.BeanUtils; BeanUtils.copyProperties(源对象, 目标对象);
  • import org.springframework.beans.BeanUtils; BeanUtils.copyProperties(源对象, 目标对象);
  • JAVA对象属性复制

    万次阅读 2012-08-10 13:33:26
    编程过程中,有些时候某些不同的类有相同的字段,可能会遇到同时给他们赋值的情况...下面是一个简单的对象属性复制方法: 复制的对象必须同时拥有setter和getter方法...只有一个的时候会报异常,都没有的时候就不复制..
  • 开发环境 Spring 版本 4.3.6 ...该实体类有四个属性, userId,userName,departmentName,departmentId public class User { private String userId; private String userName; private Strin...
  • java 对象属性复制,将一个对象的属性值赋值给另一个对象, 属性名需要相同。 import org.springframework.beans.BeanUtils; BeanUtils.copyProperties(源对象, 目标对象); 欢迎大家积极留言交流学习心得,点赞的人最...
  • 对象属性值复制工具类 1.全复制 2.部分复制 3.部分不复制
  • java 复制非空对象属性值 public static void main(String[] args){ User u1 = new User(); u1.setName("AAA"); u2.setArea("中国东莞"); User u2 = new User(); u2.setName("BB"); Bea
  • 注意依赖,springframework下的复制顺序为 (目标对象,新对象) import org.springframework.beans.BeanUtils; public static void main(String[] args) { InterfaceCaseDO oldInterfaceCase = new InterfaceCaseDO...
  • Java基础-将Bean属性值放入Map中

    千次阅读 2014-11-02 15:52:58
    利用发射将Java对象的属性值以属性名称
  • 如果我们有两个不同的类对象,但他们具有相同的属性,我们怎么将一个对象的属性值复制给另外一个对象呢?我们可以利用反射完成这个需求:首先我们利用反射得到两个对象的所有属性,再通过循环得到源对象(被复制的...
  • java 将A对象的值copy到B对象(根据属性名设置属性值
  • 菜鸟程序员Chivalry 2017-05-19 11:32 ...少啰嗦,直接看需求代码: ...的话,也可以自己造轮子,全部setter一遍,但显然不好,小编这里只有26个属性,算是少的,如果更多的话,你就懵逼了。
  • 主要是把参数object中例如name和返回objct中那么属性值进行克隆并返回selectObject对象 /**更改查询的po的分页条数信息*/ public static T> T copyAttr(Object parameter,Object selectObj) { Field [] fields = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 213,885
精华内容 85,554
关键字:

java属性值复制

java 订阅