关于java:在Spring-Bean实例过程中如何使用反射和递归处理的Bean属性填充

作者：小傅哥
博客：https://bugstack.cn

积淀、分享、成长，让本人和别人都能有所播种！😄

[x] 第 1 章：开篇介绍，我要带你撸 Spring 啦！
[x] 第 2 章：小试牛刀，实现一个简略的 Bean 容器
[x] 第 3 章：初显身手，使用设计模式，实现 Bean 的定义、注册、获取
[x] 第 4 章：锋芒毕露，基于 Cglib 实现含构造函数的类实例化策略
[x] 第 5 章：一举成名，为 Bean 对象注入属性和依赖 Bean 的性能实现
[] 第 6 章：待归档 …

超卖、掉单、幂等，你的程序总是不抗揍！

想想，经营曾经对外宣传了七八天的流动，满心欢喜的等着最初一天页面上线对外了，忽然呈现了一堆异样、资损、闪退，而用户流量昙花一现，最初想死的心都有！

就编程开发来讲，丢三落四、乱码七糟，可能这就是大部分高级程序员日常开发的真实写照，在即便有测试人员验证的状况下，也会呈现带 Bug 上线的景象，只不过是过后没有发现而已！因为是人写代码，就肯定会有谬误，即便是老码农

就程序 Bug 来讲，会包含产品 PRD 流程上的 Bug、经营配置流动时候的 Bug、研发开发时性能实现的 Bug、测试验证时漏掉流程的 Bug、上线过程中运维服务相干配置的 Bug，而这些其实都能够通过制订的流程标准和肯定的研发教训积攒，缓缓尽可能减少。

而另外一类是沟通留下的 Bug，通常状况下业务提需要、产品定计划、研发做实现，最终还要有 UI、测试、经营、架构等等各个环节的人员参加到一个我的项目的承接、开发到上线运行，而在这一群人须要放弃一个对立的信息流传其实是很难的。比方在我的项目开发中期，经营给产品说了一个新增的需要，产品感觉性能也不大，随即找到对应的前端研发加个逻辑，但没想到可能也影响到了后端的开发和测试的用例。最初性能尽管是上线了，可并不在整个产研测的需要覆盖度范畴里，也就隐形的埋下了一个坑。

所以，如果你想让你的程序很抗揍，接的住农夫三拳，那么你要做的就不只是一个单纯的搬砖码农！

首先咱们回顾下这几章节都实现了什么，包含：实现一个容器、定义和注册 Bean、实例化 Bean，依照是否蕴含构造函数实现不同的实例化策略，那么在创建对象实例化这咱们还短少什么？其实还短少一个对于 类中是否有属性的问题，如果有类中蕴含属性那么在实例化的时候就须要把属性信息填充上，这样才是一个残缺的对象创立。

对于属性的填充不只是 int、Long、String，还包含还没有实例化的对象属性，都须要在 Bean 创立时进行填充操作。不过这里咱们临时不会思考 Bean 的循环依赖，否则会把整个性能实现撑大，这样新人学习时就把握不住了，待后续陆续先把外围性能实现后，再逐步完善

鉴于属性填充是在 Bean 应用 newInstance 或者 Cglib 创立后，开始补全属性信息，那么就能够在类 AbstractAutowireCapableBeanFactory 的 createBean 办法中增加补全属性办法。这部分大家在实习的过程中也能够对照 Spring 源码学习，这里的实现也是 Spring 的简化版，后续对照学习会更加易于了解

属性填充要在类实例化创立之后，也就是须要在 AbstractAutowireCapableBeanFactory 的 createBean 办法中增加 applyPropertyValues 操作。
因为咱们须要在创立 Bean 时候填充属性操作，那么就须要在 bean 定义 BeanDefinition 类中，增加 PropertyValues 信息。
另外是填充属性信息还包含了 Bean 的对象类型，也就是须要再定义一个 BeanReference，外面其实就是一个简略的 Bean 名称，在具体的实例化操作时进行递归创立和填充，与 Spring 源码实现一样。Spring 源码中 BeanReference 是一个接口

small-spring-step-04
└── src
    ├── main
    │   └── java
    │       └── cn.bugstack.springframework.beans
    │           ├── factory
    │           │   ├── factory
    │           │   │   ├── BeanDefinition.java
    │           │   │   ├── BeanReference.java
    │           │   │   └── SingletonBeanRegistry.java
    │           │   ├── support
    │           │   │   ├── AbstractAutowireCapableBeanFactory.java
    │           │   │   ├── AbstractBeanFactory.java
    │           │   │   ├── BeanDefinitionRegistry.java
    │           │   │   ├── CglibSubclassingInstantiationStrategy.java
    │           │   │   ├── DefaultListableBeanFactory.java
    │           │   │   ├── DefaultSingletonBeanRegistry.java
    │           │   │   ├── InstantiationStrategy.java
    │           │   │   └── SimpleInstantiationStrategy.java
    │           │   └── BeanFactory.java
    │           ├── BeansException.java
    │           ├── PropertyValue.java
    │           └── PropertyValues.java
    └── test
        └── java
            └── cn.bugstack.springframework.test
                ├── bean
                │   ├── UserDao.java
                │   └── UserService.java
                └── ApiTest.java

工程源码 ： 公众号「bugstack 虫洞栈」，回复：Spring 专栏，获取残缺源码

Spring Bean 容器类关系，如图 5-2

本章节中须要新减少 3 个类，BeanReference(类援用)、PropertyValue(属性值)、PropertyValues(属性汇合)，别离用于类和其余类型属性填充操作。
另外改变的类次要是 AbstractAutowireCapableBeanFactory，在 createBean 中补全属性填充局部。

cn.bugstack.springframework.beans.PropertyValue

public class PropertyValue {

    private final String name;

    private final Object value;

    public PropertyValue(String name, Object value) {
        this.name = name;
        this.value = value;
    }
    
    // ...get/set
}

cn.bugstack.springframework.beans.PropertyValues

public class PropertyValues {private final List<PropertyValue> propertyValueList = new ArrayList<>();

    public void addPropertyValue(PropertyValue pv) {this.propertyValueList.add(pv);
    }

    public PropertyValue[] getPropertyValues() {return this.propertyValueList.toArray(new PropertyValue[0]);
    }

    public PropertyValue getPropertyValue(String propertyName) {for (PropertyValue pv : this.propertyValueList) {if (pv.getName().equals(propertyName)) {return pv;}
        }
        return null;
    }

}

这两个类的作用就是创立出一个用于传递类中属性信息的类，因为属性可能会有很多，所以还须要定义一个汇合包装下。

cn.bugstack.springframework.beans.factory.config.BeanDefinition

public class BeanDefinition {

    private Class beanClass;

    private PropertyValues propertyValues;

    public BeanDefinition(Class beanClass) {
        this.beanClass = beanClass;
        this.propertyValues = new PropertyValues();}

    public BeanDefinition(Class beanClass, PropertyValues propertyValues) {
        this.beanClass = beanClass;
        this.propertyValues = propertyValues != null ? propertyValues : new PropertyValues();}
    
    // ...get/set
}

在 Bean 注册的过程中是须要传递 Bean 的信息，在几个后面章节的测试中都有所体现 new BeanDefinition(UserService.class, propertyValues);
所以为了把属性肯定交给 Bean 定义，所以这里填充了 PropertyValues 属性，同时把两个构造函数做了一些简略的优化，防止前面 for 循环时还得判断属性填充是否为空。

cn.bugstack.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
        Object bean = null;
        try {bean = createBeanInstance(beanDefinition, beanName, args);
            // 给 Bean 填充属性
            applyPropertyValues(beanName, bean, beanDefinition);
        } catch (Exception e) {throw new BeansException("Instantiation of bean failed", e);
        }

        addSingleton(beanName, bean);
        return bean;
    }

    protected Object createBeanInstance(BeanDefinition beanDefinition, String beanName, Object[] args) {
        Constructor constructorToUse = null;
        Class<?> beanClass = beanDefinition.getBeanClass();
        Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors();
        for (Constructor ctor : declaredConstructors) {if (null != args && ctor.getParameterTypes().length == args.length) {
                constructorToUse = ctor;
                break;
            }
        }
        return getInstantiationStrategy().instantiate(beanDefinition, beanName, constructorToUse, args);
    }

    /**
     * Bean 属性填充
     */
    protected void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
        try {PropertyValues propertyValues = beanDefinition.getPropertyValues();
            for (PropertyValue propertyValue : propertyValues.getPropertyValues()) {String name = propertyValue.getName();
                Object value = propertyValue.getValue();

                if (value instanceof BeanReference) {
                    // A 依赖 B，获取 B 的实例化
                    BeanReference beanReference = (BeanReference) value;
                    value = getBean(beanReference.getBeanName());
                }
                // 属性填充
                BeanUtil.setFieldValue(bean, name, value);
            }
        } catch (Exception e) {throw new BeansException("Error setting property values：" + beanName);
        }
    }

    public InstantiationStrategy getInstantiationStrategy() {return instantiationStrategy;}

    public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {this.instantiationStrategy = instantiationStrategy;}

}

这个类的内容略微有点长，次要包含三个办法：createBean、createBeanInstance、applyPropertyValues，这里咱们次要关注 createBean 的办法中调用的 applyPropertyValues 办法。
在 applyPropertyValues 中，通过获取 beanDefinition.getPropertyValues() 循环进行属性填充操作，如果遇到的是 BeanReference，那么就须要递归获取 Bean 实例，调用 getBean 办法。
当把依赖的 Bean 对象创立实现后，会递归回当初属性填充中。这里须要留神咱们并没有去解决循环依赖的问题，这部分内容较大，后续补充。BeanUtil.setFieldValue(bean, name, value) 是 hutool-all 工具类中的办法，你也能够本人实现

cn.bugstack.springframework.test.bean.UserDao

public class UserDao {private static Map<String, String> hashMap = new HashMap<>();

    static {hashMap.put("10001", "小傅哥");
        hashMap.put("10002", "八杯水");
        hashMap.put("10003", "阿毛");
    }

    public String queryUserName(String uId) {return hashMap.get(uId);
    }

}

cn.bugstack.springframework.test.bean.UserService

public class UserService {

    private String uId;

    private UserDao userDao;

    public void queryUserInfo() {System.out.println("查问用户信息：" + userDao.queryUserName(uId));
    }

    // ...get/set
}

Dao、Service，是咱们平时开发常常应用的场景。在 UserService 中注入 UserDao，这样就能体现出 Bean 属性的依赖了。

@Test
public void test_BeanFactory() {
    // 1. 初始化 BeanFactory
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();  

    // 2. UserDao 注册
    beanFactory.registerBeanDefinition("userDao", new BeanDefinition(UserDao.class));   

    // 3. UserService 设置属性[uId、userDao]
    PropertyValues propertyValues = new PropertyValues();
    propertyValues.addPropertyValue(new PropertyValue("uId", "10001"));
    propertyValues.addPropertyValue(new PropertyValue("userDao",new BeanReference("userDao")));  

    // 4. UserService 注入 bean
    BeanDefinition beanDefinition = new BeanDefinition(UserService.class, propertyValues);
    beanFactory.registerBeanDefinition("userService", beanDefinition);    

    // 5. UserService 获取 bean
    UserService userService = (UserService) beanFactory.getBean("userService");
    userService.queryUserInfo();}

与间接获取 Bean 对象不同，这次咱们还须要先把 userDao 注入到 Bean 容器中。beanFactory.registerBeanDefinition("userDao", new BeanDefinition(UserDao.class));
接下来就是属性填充的操作了，一种是一般属性 new PropertyValue("uId", "10001")，另外一种是对象属性 new PropertyValue("userDao",new BeanReference("userDao"))
接下来的操作就简略了，只不过是失常获取 userService 对象，调用办法即可。

查问用户信息：小傅哥

Process finished with exit code 0

从测试后果看咱们的属性填充曾经起作用了，因为只有属性填充后，能力调用到 Dao 办法，如：userDao.queryUserName(uId)
那么咱们在看看 Debug 调试的状况下，有没有进入到实现的 Bean 属性填充中，如下：
- 好，就是截图这里，咱们看到曾经开始进行属性填充操作了，当发现属性是 BeanReference 时，则须要获取创立 Bean 实例。

在本章节中咱们把 AbstractAutowireCapableBeanFactory 类中的创建对象性能又做了裁减，依赖于是否有构造函数的实例化策略实现后，开始补充 Bean 属性信息。当遇到 Bean 属性为 Bean 对象时，须要递归解决。最初在属性填充时须要用到反射操作，也能够应用一些工具类解决。
每一个章节的性能点咱们都在循序渐进的实现，这样能够让新人更好的承受对于 Spring 中的设计思路。尤其是在一些曾经开发好的类上，怎么裁减新的性能时候的设计更为重要。学习编程有的时候学习思路设计要比仅仅是做简略实现，更能晋升编程思维。
到这一章节对于 Bean 的创立操作就开发实现了，接下来须要整个框架的根底上实现资源属性的加载，就是咱们须要去动 Xml 配置了，让咱们这小框架越来越像 Spring。另外在框架实现的过程中所有的类名都会参考 Spring 源码，以及相应的设计实现步骤也是与 Spring 源码中对应，只不过会简化一些流程，但你能够拿雷同的类名，去搜到每一个性能在 Spring 源码中的实现。

《Spring 手撸专栏》第 1 章：开篇介绍，我要带你撸 Spring 啦！
小傅哥，一个有“副业”的码农！
你说，怎么把 Bean 塞到 Spring 容器？
大学毕业要写多少行代码，能力不必花钱培训就找到一份开发工作？
数学，离一个程序员有多近？

关于java:在Spring-Bean实例过程中如何使用反射和递归处理的Bean属性填充

《Spring 手撸专栏》目录

一、前言

二、指标

三、设计

四、实现

1. 工程构造

2. 定义属性

3. Bean 定义补全

4. Bean 属性填充

五、测试

1. 当时筹备

2. 测试用例

3. 测试后果

六、总结

七、系列举荐

Just My Socks（注册教程内含优惠码）

关于java:在Spring-Bean实例过程中如何使用反射和递归处理的Bean属性填充

《Spring 手撸专栏》目录

一、前言

二、指标

三、设计

四、实现

1. 工程构造

2. 定义属性

3. Bean 定义补全

4. Bean 属性填充

五、测试

1. 当时筹备

2. 测试用例

3. 测试后果

六、总结

七、系列举荐

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）