精华内容
下载资源
问答
  • 不同对象可以具有同名的属性
    千次阅读
    2017-06-07 18:41:58

    在处理业务逻辑时,偶尔会有这样的需求:对象A已经实例化,但是有一些格式上的不符合标准,对象B没有具体的属性值但是格式却符合标准。

    一般这样的情况会出现在DTO对象与VO对象之间。DTO需要实现序列化才可以传输。

    这时候就需要对象属性的拷贝:

    public static void copyProperties(Object source, Object target) throws BeansException {  
    		    Assert.notNull(source, "Source must not be null");  
    		    Assert.notNull(target, "Target must not be null");  
    		    Class<?> actualEditable = target.getClass();  
    		    PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);  //得到属性数组
    		    for (PropertyDescriptor targetPd : targetPds) {//通过循环对属性一一赋值
    				if (targetPd.getWriteMethod() != null) {//针对某属性,目标对象是否具有写方法(setter)
    					PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
    		        if (sourcePd != null && sourcePd.getReadMethod() != null) {//源对象是否具有读方法(getter)
    					try {
    		            Method readMethod = sourcePd.getReadMethod();  
    		            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {  
    		              readMethod.setAccessible(true);  //强制修改getter的修饰符为public
    		            }  
    		            Object value = readMethod.invoke(source);//获取属性值
    						// 这里判断以下value是否为空 当然这里也能进行一些特殊要求的处理 例如绑定时格式转换等等
    		            if (value != null) {  
    		              Method writeMethod = targetPd.getWriteMethod();  
    		              if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {  
    		                writeMethod.setAccessible(true);  //强制修改setter方法的修饰符为public
    		              }  
    		              writeMethod.invoke(target, value);//赋值
    					}
    		          } catch (Throwable ex) {  
    		            throw new FatalBeanException("Could not copy properties from source to target", ex);  
    		          }  
    		        }  
    		      }  
    		    }  
    		  } 
    顺便体会一下java反射机制的强大。

    更多相关内容
  • /** * ComUtil class * * @author xxxxx * @date 2020.03.10 22:38 */ public class ComUtil { /** * 用于将一个类中具有相同属性名和类型的值拷贝到另一个类中 * * @param source 被复制属性的类 * @param target ...

    该工具类中包括了怎么从泛型类型中通过反射获取泛型类型。

    import java.lang.reflect.Field;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * ComUtil class
     *
     * @author xxxxx
     * @date 2020.03.10 22:38
     */
    public class ComUtil {
    
        /**
         * 用于将一个类中具有相同属性名和类型的值拷贝到另一个类中
         *
         * @param source 被复制属性的类
         * @param target 需要获取属性的类
         * @throws Exception
         */
        public static void copyProperties(Object source, Object target) throws Exception {
            if (source == null || target == null) {
                throw new Exception("传入的 source 或 target 中有为 null 的对象");
            }
            // 获取 source 和 target 的属性列表
            Field[] sourFields = source.getClass().getDeclaredFields();
            Field[] tarFields = target.getClass().getDeclaredFields();
    
            // 将 source 的属性对象为 value,属性名为 key 封装为 map
            Map<String, Field> sourFieldMap = new HashMap<>(16);
            for (Field sourField : sourFields) {
                // 获取属性名
                String fieldName = sourField.getName();
                sourFieldMap.put(fieldName, sourField);
            }
    
            for (Field tarField : tarFields) {
                // 获取属性名
                String fieldName = tarField.getName();
                // 从 sourFieldMap 中通过 fieldName 取值,若能取出表示存在相同的属性名
                Field sourField = sourFieldMap.get(fieldName);
                if (sourField != null) {
                    // 获取 List 泛型类型
                    Class tarGenericClass = getGenericClass(tarField);
                    Class sourGenericClass = getGenericClass(sourField);
    
                    // 获取属性声明的类型 Class 对象
                    Class<?> sourType = sourField.getType();
                    Class<?> tarType = tarField.getType();
    
                    // 获取权限
                    sourField.setAccessible(true);
                    tarField.setAccessible(true);
    
                    // 若不是 List 或其父接口类型,为 null
                    if (tarGenericClass == null && sourGenericClass == null) {
                        // target 属性类型是 source 属性类型的子类或子接口
                        if (sourType.isAssignableFrom(tarType)) {
                            tarField.set(target, sourField.get(source));
                        }
                    } else if (tarGenericClass != null && sourGenericClass != null) {
                        // Iterable 是 List 最顶层接口,在 sourGenericClass 中判断是声明类型是 List 或其父接口
                        Iterable sourList = (Iterable) sourField.get(source);
                        if (sourList == null) {
                            continue;
                        }
                        // 该集合用于添加 target 拷贝的对象
                        List tarList = new ArrayList();
                        // 遍历 sourList,取出每个泛型对象
                        for (Object sourObj : sourList) {
                            // 创建 target List 集合泛型实例
                            Object tarObj = tarGenericClass.newInstance();
                            // 递归调用本方法,将相同属性名赋值
                            copyProperties(sourObj, tarObj);
                            // 将实例对象添加到集合中
                            tarList.add(tarObj);
                        }
                        // 将集合赋值给 target 同名的属性
                        tarField.set(target, tarList);
                    }
                }
            }
    
        }
    
        /**
         * 获取属性类型中的泛型类型,获取泛型的过程适用于其他类型,但是本方法仅适用于 List 集合,
         * 并且只有一个泛型的情况,若有需求后续增加功能。
         *
         * @param field
         * @return
         * @throws Exception
         */
        private static Class getGenericClass(Field field) throws Exception {
            // 获取属性声明的类型 Class 对象
            Class<?> type = field.getType();
            // 判断该 type 是否是 List 或其父接口
            if (type.isAssignableFrom(List.class)) {
    
                // 获取该属性声明的类型(Type 接口),getType():是获取属性声明的类型 Class 对象
                Type genericType = field.getGenericType();
                if (genericType == null) {
                    return null;
                }
                // 判断 geneicType 是否是参数化类型,即明确指定泛型的类型,如:java.util.List<java.lang.String>
                if (genericType instanceof ParameterizedType) {
    
                    //因为 genericType 是 ParameterizedType 的实例,故可以强转
                    ParameterizedType pt = (ParameterizedType) genericType;
    
                    // 获取泛型的类型数组
                    Type[] genericArgs = pt.getActualTypeArguments();
    
                    // 当泛型类型大于 1 个时,抛出异常
                    if (genericArgs.length > 1) {
                        throw new Exception(genericType + "  " + field.getName() + ": 泛型不只一个无法赋值");
                    }
    
                    // 当只有一个泛型类型时,获取泛型类型
                    return (Class) genericArgs[0];
                }
            }
            return null;
        }
    }
    
    展开全文
  • 主要介绍了使用BeanUtils.copyProperties进行对象之间的属性赋值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 1/如果当前为CDM的话,菜单Tools->Check Model ,然后取消勾选下面两个检查 2/如果当前为PDM的话,取消下面两个检查

    1/如果当前为CDM的话, 菜单Tools->Check Model ,然后取消勾选下面两个检查

    2/如果当前为PDM的话, 取消下面两个检查

    展开全文
  • 与上边正好相反,将source的属性复制到target(属性字段相同才会进行复制,否则不复制)*/ BeanUtils.copyProperties(studentVo, student); 注意:此种方法需要抛出异常 2:使用spring-beans5.0.8包中的BeanUtils类...

    1:使用commons-beanutils包中的BeanUtils类

    用法:引入依赖

    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.7.0</version>
    </dependency>
    
    import org.apache.commons.beanutils.BeanUtils;
    
    /*BeanUtils.copyProperties(target,source);
    与上边正好相反,将source的属性复制到target(属性字段相同才会进行复制,否则不复制)*/
    BeanUtils.copyProperties(studentVo, student);
    

    注意:此种方法需要抛出异常

    2:使用spring-beans5.0.8包中的BeanUtils类

    用法:引入依赖

    <dependency>
     	<groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.4.RELEASE</version>
    </dependency>
    
    import org.springframework.beans.BeanUtils;
    
    //BeanUtils.copyProperties(source, target);
    //将source的属性复制到target(属性字段相同才会进行复制,否则不复制)
    BeanUtils.copyProperties(student, studentVo);
    

    3:cglib提供的copy方式

    用法:引入依赖

    <dependency>
       <groupId>cglib</groupId>
       <artifactId>cglib</artifactId>
       <version>3.1</version>
    </dependency>
    
    import net.sf.cglib.beans.BeanCopier;
    
    //将student的属性复制到studentVo(属性字段相同才会进行复制,否则不复制)
    BeanCopier copier = BeanCopier.create(Student.class,StudentVo.class,false);
    copier.copy(student,studentVo,null);
    

    备注:三者的性能依次为 3 好于 2,2 好于 1

    还有多种复制方式,暂不作列举

    展开全文
  • import java.beans.BeanInfo; import java.beans.Introspector; import java.beans.PropertyDescriptor; public class CopyUtils { public static void Copy... // 获取属性 BeanInfo sourceBean = Introspec.
  • java中将两个不同类的对象中相同的属性的值进行传递 import org.apache.commons.beanutils.BeanUtils; StockInquiryDetailHistory stockInquiryDetailHistory = new StockInquiryDetailHistory(); // BeanUtils....
  • JS含有部分相同属性的两个对象快速赋值法

    千次阅读 热门讨论 2020-08-26 09:30:38
    obj = { age : 18, sex : m, status : children } obj1 = { age : '', sex : '', status : '' } Object.keys(obj1).forEach(key=>{obj1[key]=obj[key]}) ...对象中所有值赋为空:
  • Spring系列:对象属性拷贝方式总结

    千次阅读 2020-04-23 00:39:04
    userVOList:[UserVO(userId=1, userName=Van, age=18, sex=null), UserVO(userId=2, userName=VanVan, age=20, sex=null)] 通过如上方法,我们基本实现了集合的拷贝,但是从返回结果我们可以发现:属性不同的字段...
  • 类和对象、方法和属性

    千次阅读 多人点赞 2018-07-30 17:06:08
    2、类:具有相似属性和方法的对象的集合  是具有相同数据成员和函数成员的一组对象的集合,它为属于该类的全部对象提供了抽象的描述。 3、面向对象程序设计的特点:封装 继承 多态  封装:面向对象技术中的封装...
  • 转自:DlamLiu 的《java 复制一个类中的属性给另一个具有相同属性的类》 原址:https://blog.csdn.net/qq_31565213/article/details/78018866 import java.lang.reflect.Field; import java.lang.reflect.Method; ...
  • js中Object对象常用方法和属性

    千次阅读 2018-11-14 11:53:54
    1、属性 Object.prototype.writable:默认为false Object.prototype.enumerable:默认为false Object.prototype.configurable:默认为false Object.prototype.constructor:用于创建一个对象的原型。 2、常用方法 ...
  • 两个对象的相同属性赋值

    千次阅读 2019-07-08 15:58:29
    利用BeanUtils在对象间复制属性 commons-beanutils是jakarta commons子项目中的一个软件包,其主要目的是利用反射机制对JavaBean的属性进行处理。我们知道,一个JavaBean通常包含了大量的属性,很多情况下,对Java....
  • 最近实践一个DDD项目,在领域层与持久层之间,Domain Model与Entity Model之间有时候需要进行属性值得拷贝,而这些属性,尽管它所在的类名称不一样,但它们的属性名和属性类型差不多都是一样的。系统中有不少这样的...
  • 面向对象知识点.txt

    2019-12-01 20:48:30
    类由对象和方法组成 类是对象的模板/抽象,对象是类的实例。... * 在同一个方法中,不允许有同名局部变量 在不同的方法中,可以同名局部变量 在同一个类中,成员变量和局部变量同名时,局部变量具有更高的优先级
  • 这样的吧,这有一种专业说法,叫“父类引用指向子类对象”。 首先 new Son();是肯定动态创建了一个子类对象的 。 Father father 则是一个创建了一个父类引用对象。 Father father = new Son(); 就是将父类引用指向...
  • C++多继承同名函数

    千次阅读 2021-05-10 15:20:10
    成员名”方式可以唯一标识和访问派生类新增成员,基类的同名成员也可以使用基类名或作用域分辨符访问 #include<iostream> using namespace std; class BaseClass { public: void fn1() { cout <<
  • 2 document节点的属性 2.1 doctype,documentElement,defaultView,body,head,activeElement 2.1.1 doctype 2.1.2 documentElement 2.1.3 defaultView 2.1.4 body 2.1.5 head 2.1.6 activeEleme...
  • delete运算符,可以删除对象属性。它的操作数应当是一个属性访问表达式。delete只是断开属性和宿主对象的联系,而不会去操作属性中的属性: delete book.author;//book不再有属性author delete book["main...
  • 对象是JS的基本数据类型。对象是一种复合值,ta
  • 面向对象编程 常用术语/名词解释 抽象/实现 封装/接口 合成 派生/继承/继承结构 泛化/特化 多态 自省/反射 访问限制 私有属性和公有属性 私有方法的设置 类 创建类 声明与定义 类属性 类的数据属性 ...
  • JAVA SE学习笔记(四): 面向对象编程-a

    万次阅读 2020-02-08 23:58:17
    五、面向对象 1.面向对象与面向过程: 面向过程,强调的是功能... Java代码世界是由诸多个不同功能的类构成的,一个类class一般包含: ①属性-成员变量 ②行为-(成员)方法、函数 4.理解: 类 = 汽车设计图; ...
  • 属性对象具有的各种特征 每个对象的每个属性都有特定值;例如小红和小明的年龄,姓名不一样 方法:对象执行的操作 类:--------抽象 类是对象概括,是对象的分类 具有相同属性和方法的一组对象的集合 是概念...
  • 阅读这篇文章是因为在工作中,需要通过document.getElementsByID,获取foreach中每一条数据,然后改变其样式,但是发现只有第一条数据生效,其他数据属性都是null,通过分析之后给foreach中加入动态id,之后找到下面...
  • python中可以使用__定义私有属性,私有属性类外和子类都不能直接操作访问,但是实际开发中私有属性也不是一层不变的。所以要给私有属性提供外部能够操作的方法。 1.property属性的定义与使用 property的用法其实...
  • Scala的类、属性对象字段

    千次阅读 2018-06-12 16:43:11
    转载自:类、属性对象字段1 类(class)1.1 定义类 Scala是一种纯粹的面向对象编程语言,而又无缝地结合了命令式和函数式的编程风格。在面向对象的语言有两个重要的概念:类(class)和对象(object也被称为实例—...
  • 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联...
  • Java面向对象面试题总结

    万次阅读 多人点赞 2019-02-27 17:22:05
    答:(1)在类的定义中设置访问对象属性(数据成员)及方法(成员方法)的权限,限制本类对象及其他类的对象使用的范围。 (2)提供一个接口来描述其他对象的使用方法 (3)其他对象不能直接修改本对象所拥有的...
  • 其主要目的是利用反射机制对JavaBean的属性进行处理。我们知道,一个JavaBean通常包含了大量的属性,很多情况下,对JavaBean的处理导致大量get/set代码堆积,增加了代码长度和阅读代码的难度。 二、用法:  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,528
精华内容 33,811
关键字:

不同对象可以具有同名的属性