关于Spring Bean实例过程中使用反射和递归处理的Bean属性填充问题

一、前言

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

想想，运营已经对外宣传了七八天的活动，满心欢喜的等着最后一天页面上线对外了，突然出现了一堆异常、资损、闪退，而用户流量稍纵即逝，最后想死的心都有！

就编程开发来讲，丢三落四、乱码七糟，可能这就是大部分初级程序员日常开发的真实写照，在即使有测试人员验证的情况下，也会出现带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 是一个接口

四、实现

1. 工程结构

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

工程源码：

《spring 手撸专栏》学习源码介绍
专栏地址：

源码地址：

spring bean 容器类关系，如图 5-2

• 本章节中需要新增加3个类，beanreference(类引用)、propertyvalue(属性值)、propertyvalues(属性集合)，分别用于类和其他类型属性填充操作。
• 另外改动的类主要是 abstractautowirecapablebeanfactory，在 createbean 中补全属性填充部分。

2. 定义属性

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;
    }

}

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

3. bean定义补全

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 循环时还得判断属性填充是否为空。

4. bean 属性填充

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 工具类中的方法，你也可以自己实现

五、测试

1. 事先准备

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属性的依赖了。

2. 测试用例

@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 对象，调用方法即可。

3. 测试结果

查询用户信息：小傅哥

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 bean实例过程中使用反射和递归处理的bean属性填充问题的详细内容，更多关于spring bean bean属性填充的资料请关注其它相关文章！