常见场景
我们如果有两个具有很多相同属性名的JavaBean对象a和b，想把a中的属性赋值到b，例如
- 接口中将接收到的前端请求参数XxxReqVo,我们想把这个入参转化为XxxQuery对象作为数据库的查询条件对象
传统做法是手动set，即
XxxQuery xxxQuery = new XxxQuery();
xxxQuery .setAxx(xxxReqVo.getAxx());
xxxQuery .setBxx(xxxReqVo.getBxx());
xxxQuery .setCxx(xxxReqVo.getCxx());
如果有几十个需要赋值的的字段呢？那就很头疼了org.springframework.beans.BeanUtils，它提供了对java反射和自省API的包装。它里面还有很多工具类，这里我们介绍一下该类下面的copyProperties方法,该工具方法可以帮我们大大简化这一步
应用案例
案例一(两个无关的类做属性拷贝)
@Data
public class User {
private String id;
private String name;
private String age;
private String account;
private String password;
}
@Data
public class Person {
private String id;
private String name;
private String age;
private String sex;
}
public class Test {
public static void main(String[] args) {
User user = new User();
user.setId("1");
user.setAge("2");
user.setName("wzh");
user.setAccount("wangzh");
user.setPassword("1111");
Person person = new Person();
BeanUtils.copyProperties(user,person);
}
}
结果
Person(id=1, name=wzh, age=2, sex=null)
通过上述测试我们就可以总结出相关结论，基本用法为
BeanUtils.copyProperties(source,target);
相当于把源对象source的属性值赋给目标对象target中与源对象source的中有着同属性名的属性，如上述案例中Person作为目标对象与源对象User中有着共同的同名属性id,name,age,所以person中的这三个字段被赋值成功，赋值的数据来源正是user对象，sex这个字段是Person类所特有的，所以不会被赋值，同时还要特别注意赋值操作相关类的属性一定要有对应的setter/getter，即
- 源对象source的属性拷贝值赋给目标对象target的过程中,属性名和属性类型都相同的属性才能被成功拷贝赋值，例如id,name,age这三个目标对象的属性被赋值成功，目标对象中的sex属性，由于源对象中没有同名的属性所以没法被赋值成功。
- 做赋值的属性一定要有对应的setter/getter才能成功赋值
案例二(父子类之间做赋值)
这里难度升级一下，我们不仅仅要演示父子类之间做赋值，还要加一个特征，即在父类Person具有String类型的age属性的基础上，子类中定义一个Integer类型的属性
父类Person
@Data
public class Person {
private String id;
private String name;
private String age;
private String sex;
public void test(Object obj) {
System.out.println("test");
}
@Override
public String toString() {
return "Person{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age='" + age + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
子类User，类内含有测试用的main方法
import org.springframework.beans.BeanUtils;
public class User extends Person{
private Integer age;
private String account;
private String password;
public <T> T getAge(Boolean isSon) {
if(isSon == true) {
return (T) this.age;
}
return (T) super.getAge();
}
//重载：方法名相同，但返回值数目/类型/不同类型返回值的顺序非一致，
// setAge方法满足重载条件，getAge则无法满足重载条件
public void setAge(String age) {
super.setAge(age);
}
public void setAge(Integer age) {
this.age = age;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public static void main(String[] args) {
User user = new User();
user.setId("1");
// 设置父类的age属性值
user.setAge("23");
// 设置子类的age属性值
user.setAge(2);
user.setName("wzh");
user.setAccount("wangzihan06");
user.setPassword("123456");
// 获取子类的age属性，子类的age属性是Interger类型，需要用Interger接收
Integer age1 = user.getAge(true);
System.out.println(age1);
// 获取父类的age属性，子类的age属性是String类型，需要用String接收
String age2 = user.getAge(false);
System.out.println(age2);
Person person = new Person();
// 把子类对象user的属性值赋值给person,即把user对象中存储的Person父类相
// 关的属性值赋给父类对象person
BeanUtils.copyProperties(user,person);
System.out.println("person:" +person.toString());
// 反向赋值，即把person的name设置为null后赋值给user，那么user对象属性中继承自父类的这个
// 属性name也会被重新赋值为空，但它自己所特有的属性比如account、password不会受影响
person.setName(null);
BeanUtils.copyProperties(person,user);
System.out.println("user:" +user.toString());
}
@Override
public String toString() {
return "User{" +
"age(User)=" + age +
", age(Person)=" + super.getAge() +
", account='" + account + '\'' +
", password='" + password + '\'' +
", name(Person)='" + super.getName() + '\'' +
'}';
}
}
如上，我们创建的user对象，我们给这个对象的全部属性做赋值，注意这里user对象的全部属性 = user对象自己特有的属性(age(Interger类型),account,password) + 继承自父类Parent中的属性(id,name,age(String类型),sex)
我们把子类对象user的属性值赋值给person,即把user对象中存储的Person父类相关的属性值赋给父类对象person
Person person = new Person();//
BeanUtils.copyProperties(user,person);
结果
person:Person{id='1', name='wzh', age='23', sex='null'}
反向赋值，即把person的name设置为null后赋值给user，那么user对象属性中继承自父类的这个属性name被赋值为null，但它自己所特有的属性比如account、password不会受影响
person.setName(null);
BeanUtils.copyProperties(person,user);
情况三（带有POJO/Collection类型的属性）
Life类，表示是否存活
@Data
@AllArgsConstructor
public class Life {
private String status; //取值dead是死亡，取值alived是存活
}
分别给User类和Person类装配这个life属性，而后测试代码如下
Life life = new Life("living");
person.setLife(life);
BeanUtils.copyProperties(person,user);
System.out.println("person life:" + person.getLife() + ","
+ "user life:" + user.getLife());
最终打印
person life:Life(status=living),user life:null
由此再次证明一个观点
BeanUtils.copyProperties(source,target);
如果source是父类，target是子类，那么最终只会把父类中的属性值同步给子类中继承自父类的属性，子类所独有的属性不会受到影响
去掉这两个类的继承关系，重新演示
User user = new User();
Person person = new Person();
Life personLife = new Life("person living");
Life userLeft = new Life("son living");
person.setLife(personLife);
user.setLife(userLeft);
BeanUtils.copyProperties(person,user);
System.out.println("person life:" + person.getLife() + ","
+ "user life:" + user.getLife() );
System.out.println(person.getLife() == user.getLife());
打印
person life:Life(status=living),user life:Life(status=living)
true
赋值成功，而且同时可以看出BeanUtils.copyProperties中引用类型的属性间的拷贝方式是浅拷贝，浅拷贝即仅仅是把源对象person中life属性的引用赋值给目标对象user的life属性，而且就算目标对象user本身就具有life属性值，也会在copyProperties的过程中被源对象person中life对象覆盖它原本的life对象这个属性
情况四（两个带有泛型属性的类做属性拷贝）
@Data
public class Person<T> {
private String id;
private String name;
private String age;
private String sex;
private List<T> list;
}
package com.example.demo2.test.gneric;
import com.example.demo2.mode.Life;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import java.util.ArrayList;
import java.util.List;
@Data
@Slf4j
public class User<T> {
private Life life;
private String account;
private String password;
private List<T> list;
public static void main(String[] args) {
User user = new User();
Person person = new Person();
List<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
List<String> list2 = new ArrayList<String>();
list2.add("A");
list2.add("B");
list2.add("C");
user.setList(list1);
person.setList(list2);
BeanUtils.copyProperties(user,person);
log.info("user:{}",user);
log.info("person:{}",person);
// 结果为true，可见赋值的时候直接是把list1的引用直接赋值给了list2
log.info("isEqual:{}",person.getList() == user.getList());
// list2没有变化，可见我们没法直接对list列表间做赋值
BeanUtils.copyProperties(list1,list2);
log.info("list2:{}",list2);
}
}
情况分析
泛型集合的作用是在编译期，过了编译期，泛型的影响会通过泛型擦除机制被立马被擦除掉，在程序运行期间即不再有实际意义，而我们分析源码可在，属性拷贝是利用的反射机制，即在程序运行期间通过getter/setter来做属性拷贝的，所以泛型对属性拷贝没有影响
结果分析
list属性被成功拷贝，同时我们发现person.getList和user.getList()完全是同一个list对象，可见赋值的时候直接是把list1的引用直接赋值给了list2，尝试把list1赋值给list2，最终结果list2没有变化，可见我们没法直接直接对list列表间做赋值
14:28:43.065 [main] INFO com.example.demo2.test.gneric.User - user:User(life=null, account=null, password=null, list=[1, 2, 3])
14:28:43.073 [main] INFO com.example.demo2.test.gneric.User - person:Person(id=null, name=null, age=null, sex=null, list=[1, 2, 3])
14:28:43.073 [main] INFO com.example.demo2.test.gneric.User - isEqual:true
14:28:43.105 [main] INFO com.example.demo2.test.gneric.User - list2:[A, B, C, D]
