一鸣惊人,为Bean对象注入属性和依赖Bean的功能实现

开发 前端
鉴于属性填充是在 Bean 使用 newInstance 或者 Cglib 创建后,开始补全属性信息,那么就可以在类 AbstractAutowireCapableBeanFactory 的 createBean 方法中添加补全属性方法。

[[403395]]

本文转载自微信公众号「bugstack虫洞栈」,作者小傅哥。转载本文请联系bugstack虫洞栈公众号。

目录

  • 一、前言
  • 二、目标
  • 三、设计
  • 四、实现
    • 1. 工程结构
    • 2. 定义属性
    • 3. Bean定义补全
    • 4. Bean 属性填充
  • 五、测试
    • 1. 事先准备
    • 2. 测试用例
    • 3. 测试结果
  • 六、总结
  • 七、系列推荐

一、前言

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

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

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

  1. small-spring-step-04 
  2. └── src 
  3.     ├── main 
  4.     │   └── java 
  5.     │       └── cn.bugstack.springframework.beans 
  6.     │           ├── factory 
  7.     │           │   ├── factory 
  8.     │           │   │   ├── BeanDefinition.java 
  9.     │           │   │   ├── BeanReference.java 
  10.     │           │   │   └── SingletonBeanRegistry.java 
  11.     │           │   ├── support 
  12.     │           │   │   ├── AbstractAutowireCapableBeanFactory.java 
  13.     │           │   │   ├── AbstractBeanFactory.java 
  14.     │           │   │   ├── BeanDefinitionRegistry.java 
  15.     │           │   │   ├── CglibSubclassingInstantiationStrategy.java 
  16.     │           │   │   ├── DefaultListableBeanFactory.java 
  17.     │           │   │   ├── DefaultSingletonBeanRegistry.java 
  18.     │           │   │   ├── InstantiationStrategy.java 
  19.     │           │   │   └── SimpleInstantiationStrategy.java 
  20.     │           │   └── BeanFactory.java 
  21.     │           ├── BeansException.java 
  22.     │           ├── PropertyValue.java 
  23.     │           └── PropertyValues.java 
  24.     └── test 
  25.         └── java 
  26.             └── cn.bugstack.springframework.test 
  27.                 ├── bean 
  28.                 │   ├── UserDao.java 
  29.                 │   └── UserService.java 
  30.                 └── ApiTest.java 

工程源码:公众号「bugstack虫洞栈」,回复:Spring 专栏,获取完整源码

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

图 5-2

  • 本章节中需要新增加3个类,BeanReference(类引用)、PropertyValue(属性值)、PropertyValues(属性集合),分别用于类和其他类型属性填充操作。
  • 另外改动的类主要是 AbstractAutowireCapableBeanFactory,在 createBean 中补全属性填充部分。

2. 定义属性

cn.bugstack.springframework.beans.PropertyValue

  1. public class PropertyValue { 
  2.  
  3.     private final String name
  4.  
  5.     private final Object value; 
  6.  
  7.     public PropertyValue(String name, Object value) { 
  8.         this.name = name
  9.         this.value = value; 
  10.     } 
  11.      
  12.     // ...get/set 

cn.bugstack.springframework.beans.PropertyValues

  1. public class PropertyValues { 
  2.  
  3.     private final List<PropertyValue> propertyValueList = new ArrayList<>(); 
  4.  
  5.     public void addPropertyValue(PropertyValue pv) { 
  6.         this.propertyValueList.add(pv); 
  7.     } 
  8.  
  9.     public PropertyValue[] getPropertyValues() { 
  10.         return this.propertyValueList.toArray(new PropertyValue[0]); 
  11.     } 
  12.  
  13.     public PropertyValue getPropertyValue(String propertyName) { 
  14.         for (PropertyValue pv : this.propertyValueList) { 
  15.             if (pv.getName().equals(propertyName)) { 
  16.                 return pv; 
  17.             } 
  18.         } 
  19.         return null
  20.     } 
  21.  

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

3. Bean定义补全

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

  1. public class BeanDefinition { 
  2.  
  3.     private Class beanClass; 
  4.  
  5.     private PropertyValues propertyValues; 
  6.  
  7.     public BeanDefinition(Class beanClass) { 
  8.         this.beanClass = beanClass; 
  9.         this.propertyValues = new PropertyValues(); 
  10.     } 
  11.  
  12.     public BeanDefinition(Class beanClass, PropertyValues propertyValues) { 
  13.         this.beanClass = beanClass; 
  14.         this.propertyValues = propertyValues != null ? propertyValues : new PropertyValues(); 
  15.     } 
  16.      
  17.     // ...get/set 
  • 在 Bean 注册的过程中是需要传递 Bean 的信息,在几个前面章节的测试中都有所体现 new BeanDefinition(UserService.class, propertyValues);
  • 所以为了把属性一定交给 Bean 定义,所以这里填充了 PropertyValues 属性,同时把两个构造函数做了一些简单的优化,避免后面 for 循环时还得判断属性填充是否为空。

4. Bean 属性填充

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

  1. public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory { 
  2.  
  3.     private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy(); 
  4.  
  5.     @Override 
  6.     protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException { 
  7.         Object bean = null
  8.         try { 
  9.             bean = createBeanInstance(beanDefinition, beanName, args); 
  10.             // 给 Bean 填充属性 
  11.             applyPropertyValues(beanName, bean, beanDefinition); 
  12.         } catch (Exception e) { 
  13.             throw new BeansException("Instantiation of bean failed", e); 
  14.         } 
  15.  
  16.         addSingleton(beanName, bean); 
  17.         return bean; 
  18.     } 
  19.  
  20.     protected Object createBeanInstance(BeanDefinition beanDefinition, String beanName, Object[] args) { 
  21.         Constructor constructorToUse = null
  22.         Class<?> beanClass = beanDefinition.getBeanClass(); 
  23.         Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors(); 
  24.         for (Constructor ctor : declaredConstructors) { 
  25.             if (null != args && ctor.getParameterTypes().length == args.length) { 
  26.                 constructorToUse = ctor; 
  27.                 break; 
  28.             } 
  29.         } 
  30.         return getInstantiationStrategy().instantiate(beanDefinition, beanName, constructorToUse, args); 
  31.     } 
  32.  
  33.     /** 
  34.      * Bean 属性填充 
  35.      */ 
  36.     protected void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) { 
  37.         try { 
  38.             PropertyValues propertyValues = beanDefinition.getPropertyValues(); 
  39.             for (PropertyValue propertyValue : propertyValues.getPropertyValues()) { 
  40.  
  41.                 String name = propertyValue.getName(); 
  42.                 Object value = propertyValue.getValue(); 
  43.  
  44.                 if (value instanceof BeanReference) { 
  45.                     // A 依赖 B,获取 B 的实例化 
  46.                     BeanReference beanReference = (BeanReference) value; 
  47.                     value = getBean(beanReference.getBeanName()); 
  48.                 } 
  49.                 // 属性填充 
  50.                 BeanUtil.setFieldValue(bean, name, value); 
  51.             } 
  52.         } catch (Exception e) { 
  53.             throw new BeansException("Error setting property values:" + beanName); 
  54.         } 
  55.     } 
  56.  
  57.     public InstantiationStrategy getInstantiationStrategy() { 
  58.         return instantiationStrategy; 
  59.     } 
  60.  
  61.     public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) { 
  62.         this.instantiationStrategy = instantiationStrategy; 
  63.     } 
  64.  

这个类的内容稍微有点长,主要包括三个方法: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

  1. public class UserDao { 
  2.  
  3.     private static Map<String, String> hashMap = new HashMap<>(); 
  4.  
  5.     static { 
  6.         hashMap.put("10001""小傅哥"); 
  7.         hashMap.put("10002""八杯水"); 
  8.         hashMap.put("10003""阿毛"); 
  9.     } 
  10.  
  11.     public String queryUserName(String uId) { 
  12.         return hashMap.get(uId); 
  13.     } 
  14.  

cn.bugstack.springframework.test.bean.UserService

  1. public class UserService { 
  2.  
  3.     private String uId; 
  4.  
  5.     private UserDao userDao; 
  6.  
  7.     public void queryUserInfo() { 
  8.         System.out.println("查询用户信息:" + userDao.queryUserName(uId)); 
  9.     } 
  10.  
  11.     // ...get/set 

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

2. 测试用例

  1. @Test 
  2. public void test_BeanFactory() { 
  3.     // 1.初始化 BeanFactory 
  4.     DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();   
  5.  
  6.     // 2. UserDao 注册 
  7.     beanFactory.registerBeanDefinition("userDao", new BeanDefinition(UserDao.class));    
  8.  
  9.     // 3. UserService 设置属性[uId、userDao] 
  10.     PropertyValues propertyValues = new PropertyValues(); 
  11.     propertyValues.addPropertyValue(new PropertyValue("uId""10001")); 
  12.     propertyValues.addPropertyValue(new PropertyValue("userDao",new BeanReference("userDao")));   
  13.  
  14.     // 4. UserService 注入bean 
  15.     BeanDefinition beanDefinition = new BeanDefinition(UserService.class, propertyValues); 
  16.     beanFactory.registerBeanDefinition("userService", beanDefinition);     
  17.  
  18.     // 5. UserService 获取bean 
  19.     UserService userService = (UserService) beanFactory.getBean("userService"); 
  20.     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 源码中的实现。

 

责任编辑:武晓燕 来源: bugstack虫洞栈
相关推荐

2023-06-27 08:58:13

quarkusBean

2023-07-11 09:14:12

Beanquarkus

2011-05-04 13:58:56

奔图激光打印机

2023-06-29 08:32:41

Bean作用域

2019-06-11 18:35:18

戴尔

2011-05-26 13:46:09

2021-08-04 11:39:17

Bean对象配置

2015-12-22 17:48:59

2023-10-07 08:35:07

依赖注入Spring

2023-03-08 09:59:39

SpringBean注入

2023-01-30 22:10:12

BeanSpring容器

2021-05-06 07:58:57

Spring BeanIOCAOP

2021-07-01 10:45:18

Bean对象作用域

2024-03-18 00:00:00

SpringBean设计

2021-03-08 08:40:25

Spring Bean 创建单例对象

2022-03-16 11:11:37

SpringBean项目

2011-04-02 15:25:41

Spring

2023-03-27 21:54:48

方式OptionalAutowird

2012-03-20 10:09:27

JavaBean

2011-06-15 12:36:58

JSPBEAN
点赞
收藏

51CTO技术栈公众号