1. 什么是JavaBean

JavaBean都有如下几个特征：

属性是私有的；
有无参的public构造方法；
对私有属性提供public的getXxx方法和setXxx方法；

符合这些特征的类，被称为JavaBean；而JDK提供了一套API用来访问某个属性的getter/setter方法，这些API存放在java.beans中，这就是内省。

1.1 反射和内省的区别

反射：是在运行中，对任意一个类，能够获取到这个类所有的属性和方法；
内省：对javaBean属性、方法的处理方式；

反射可以操作各种类的属性，而内省只是通过反射来操作JavaBean的属性；
内省设置属性值会调用setter方法，而反射可以直接调用Field；
反射看到.class的所有，看到的是客观事实，而内省更像是主观的判断，比如看到getName()内省就会认为这个类有name字段，但实际上不一定有name。

通过内省可以获取到bean的getter和setter。

2. 核心方法

核心类是 Introspector【因锤斯柏克特】，它提供的一系列的getBeanInfo 方法，可以拿到一个JavaBean的所有核心信息。
通过BeanInfo的getPropertyDescriptors和getMethodDescription方法可以拿到JavaBean的字段信息列表和getter和setter的方法列表。

2.1 简单版使用

1. JavaBean类

@Data
public class UserPO {
    private String id;
    private String name;
    private Integer age;
    private String sex;
    private List sports;
}

2. 测试方法

 //测试方法
    public static void main(String[] args) throws Exception{
        //属性复制
        UserPO userPO = new UserPO();
        userPO.setId("0001");
        userPO.setName("tom");
        userPO.setAge(20);
        userPO.setSex("男");
        List sports = new ArrayList();
        sports.add("足球");
        sports.add("篮球");
        sports.add("皮球");
        userPO.setSports(sports);

        //获取bean的信息
//        BeanInfo info = Introspector.getBeanInfo(userPO.getClass());
        //在Object类时候停止检索，可以选择在任意一个父类停止。
        BeanInfo beanInfo = Introspector.getBeanInfo(userPO.getClass(), Object.class);

        //获取属性描述符
        System.out.println("获取属性描述符");
        PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor prop:descriptors) {
            System.out.println(prop.getName());
        }
        //获取方法描述符
        System.out.println("获取方法描述符");
        MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
        for (MethodDescriptor methodDescriptor:methodDescriptors){
            System.out.println(methodDescriptor.getName());
        }
    }

2.1 执行结果

获取属性描述符
age
id
name
sex
sports
获取方法描述符
getName
setId
setSex
getSex
setAge
setName
getAge
getSports
getId
setSports

3. 获取JavaBean的值

 //测试方法
    public static void main(String[] args) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
        //属性复制

        UserPO userPO = new UserPO();
        userPO.setId("0001");
        userPO.setName("tom");
        userPO.setAge(20);
        userPO.setSex("男");
        List sports = new ArrayList();
        sports.add("足球");
        sports.add("篮球");
        sports.add("皮球");
        userPO.setSports(sports);

        //获取bean的信息
//        BeanInfo info = Introspector.getBeanInfo(userPO.getClass());
        //在Object类时候停止检索，可以选择在任意一个父类停止。
        BeanInfo beanInfo = Introspector.getBeanInfo(userPO.getClass(), Object.class);
//
        //获取属性描述符
        PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor prop:descriptors) {
            System.out.println(prop.getName()+"="+prop.getReadMethod().invoke(userPO));
        }
        PropertyDescriptor age = new PropertyDescriptor("age", UserPO.class);
        System.out.println("内省获取的age为："+age.getReadMethod().invoke(userPO));

        //修改属性的值
        age.getWriteMethod().invoke(userPO,30);
        System.out.println("内省修改的age为："+userPO.getAge());

    }

3.1 执行结果

age=20
id=0001
name=tom
sex=男
sports=[足球, 篮球, 皮球]
内省获取的age为：20
内省修改的age为：30

2.2 优化版使用（推荐）

Spring优化了内省的使用，内部维护缓存对象对内省对象来进行缓存。

    public static void main(String[] args) {
        UserModel userModel = new UserModel();
        userModel.setUserId(100L);
        userModel.setName("tom");
        //核心方法
        BeanWrapper wrappedSource = new BeanWrapperImpl(userModel);
        Object name = wrappedSource.getPropertyValue("name");
        System.out.println("读取的值：" + name);
    }

3. 项目实战

3.1 实现浅拷贝

需要注意的是，在不同的jar包中，用法是不一样的。
1. package org.springframework.beans;

BeanUtils.copyProperties(A,B);
是A中的值赋值给B

2. package org.apache.commons.beanutils;

BeanUtils.copyProperties(A,B);
是B中的值赋值给A

1. userVo源码

@Data
public class UserVO {
    private String name;
    private List sports;
    private String name1;
}

2. 测试代码

  //测试方法
    public static void main(String[] args) throws Exception {
  
        UserPO userPO = new UserPO();
        userPO.setId("0001");
        userPO.setName("tom");
        userPO.setAge(20);
        userPO.setSex("男");
        List sports = new ArrayList();
        sports.add("足球");
        sports.add("篮球");
        sports.add("皮球");
        userPO.setSports(sports);

        UserVO userVO = new UserVO();

        BeanUtils.copyProperties(userPO,userVO);

        //设置目标对象的特殊值
        userVO.setName1("XXX");
        System.out.println("目标对象的值："+userVO);

        //修改源对象的List属性
        userPO.getSports().add("网球");
        System.out.println("源对象的sports属性正在被修改...");
        //查看目标对象是否修改
        System.out.println("目标对象的值是否被修改"+userVO.getSports());
    }

3. 测试结果

目标对象的值：UserVO{name='tom', sports=[足球, 篮球, 皮球], name1='XXX'}
源对象的sports属性正在被修改...
目标对象的值是否被修改[足球, 篮球, 皮球, 网球]

正如我们上面看到，内省进行属性的拷贝时，本质上是浅复制，即：改变源对象中属性对象的值时，会影响目标对象的值。

3.2 业务代码

一个人，可能有父亲，有祖父，有增祖父....
他的儿子是要继承他所有的关系的，便可以使用内省来解决。

//level就是它上面有几层继承关系
for (int i = 1; i < level; i++) {  
    String format = String.format("parent%sId", i);  
    PropertyDescriptor parentInfo = new PropertyDescriptor(format, People.class);  
    //读取字段  
    String parentId = (String) parentInfo.getReadMethod().invoke(parentPeople);  
    //写入字段  
    parentInfo.getWriteMethod().invoke(people, parentId);  
}  
//写入上一级中  
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(String.format("parent%sId", level), People.class);  
propertyDescriptor.getWriteMethod().invoke(people, parentPeople.getCustomerId());

java内省（Introspector）