30个类手写Spring核心原理之依赖注入功能

开发 前端
在GPApplicationContext中设计两个Map:factoryBeanObjectCache保存单例对象的缓存,factoryBeanInstanceCache保存GPBeanWrapper的缓存,变量命名也和原生Spring一致,这两个对象的设计其实就是注册式单例模式的经典应用。

[[440478]]

在之前的源码分析中我们已经了解到,依赖注入(DI)的入口是getBean()方法,前面的IoC手写部分基本流程已通。先在GPApplicationContext中定义好IoC容器,然后将GPBeanWrapper对象保存到Map中。在GPApplicationContext中设计两个Map:factoryBeanObjectCache保存单例对象的缓存,factoryBeanInstanceCache保存GPBeanWrapper的缓存,变量命名也和原生Spring一致,这两个对象的设计其实就是注册式单例模式的经典应用。

  1. public class GPApplicationContext extends GPDefaultListableBeanFactory implements GPBeanFactory { 
  2.  
  3.     private String [] configLocations; 
  4.  
  5.     private GPBeanDefinitionReader reader; 
  6.  
  7.     //用来保证注册式单例的容器 
  8.     private Map<String,Object> factoryBeanObjectCache = new HashMap<String, Object>(); 
  9.  
  10.     //用来存储所有的被代理过的对象 
  11.     private Map<String,GPBeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<String, GPBeanWrapper>(); 
  12.  
  13.     ... 
  14.  

1 从getBean()方法开始

下面我们从完善getBean()方法开始:

  1.     @Override 
  2.     public Object getBean(String beanName) { 
  3.  
  4.         GPBeanDefinition beanDefinition = super.beanDefinitionMap.get(beanName); 
  5.  
  6.         try{ 
  7.  
  8.             //生成通知事件 
  9.             GPBeanPostProcessor beanPostProcessor = new GPBeanPostProcessor(); 
  10.  
  11.             Object instance = instantiateBean(beanDefinition); 
  12.             if(null == instance){ return  null;} 
  13.  
  14.             //在实例初始化以前调用一次 
  15.             beanPostProcessor.postProcessBeforeInitialization(instance,beanName); 
  16.  
  17.             GPBeanWrapper beanWrapper = new GPBeanWrapper(instance); 
  18.  
  19.             this.factoryBeanInstanceCache.put(beanName,beanWrapper); 
  20.  
  21.             //在实例初始化以后调用一次 
  22.             beanPostProcessor.postProcessAfterInitialization(instance,beanName); 
  23.  
  24.             populateBean(beanName,instance); 
  25.  
  26.             //通过这样调用,相当于给我们自己留有了可操作的空间 
  27.             return this.factoryBeanInstanceCache.get(beanName).getWrappedInstance(); 
  28.         }catch (Exception e){ 
  29. //            e.printStackTrace(); 
  30.             return null
  31.         } 
  32.     } 

2 instantiateBean()方法反射创建实例

  1. //传一个BeanDefinition,就返回一个实例Bean 
  2. private Object instantiateBean(GPBeanDefinition beanDefinition){ 
  3.     Object instance = null
  4.     String className = beanDefinition.getBeanClassName(); 
  5.     try{ 
  6.  
  7.         //因为根据Class才能确定一个类是否有实例 
  8.         if(this.factoryBeanObjectCache.containsKey(className)){ 
  9.             instance = this.factoryBeanObjectCache.get(className); 
  10.         }else
  11.             Class<?> clazz = Class.forName(className); 
  12.             instance = clazz.newInstance(); 
  13.  
  14.             this.factoryBeanObjectCache.put(beanDefinition.getFactoryBeanName(),instance); 
  15.         } 
  16.  
  17.         return instance; 
  18.     }catch (Exception e){ 
  19.         e.printStackTrace(); 
  20.     } 
  21.  
  22.     return null

3 populateBean()方法完成依赖注入

  1.     private void populateBean(String beanName,Object instance){ 
  2.  
  3.         Class clazz = instance.getClass(); 
  4.  
  5.         if(!(clazz.isAnnotationPresent(GPController.class) || 
  6.                 clazz.isAnnotationPresent(GPService.class))){ 
  7.             return
  8.         } 
  9.  
  10.         Field [] fields = clazz.getDeclaredFields(); 
  11.  
  12.         for (Field field : fields) { 
  13.             if (!field.isAnnotationPresent(GPAutowired.class)){ continue; } 
  14.  
  15.             GPAutowired autowired = field.getAnnotation(GPAutowired.class); 
  16.  
  17.             String autowiredBeanName = autowired.value().trim(); 
  18.  
  19.             if("".equals(autowiredBeanName)){ 
  20.                 autowiredBeanName = field.getType().getName(); 
  21.             } 
  22.  
  23.             field.setAccessible(true); 
  24.  
  25.             try { 
  26.  
  27.                 field.set(instance,this.factoryBeanInstanceCache.get(autowiredBeanName). getWrappedInstance()); 
  28.  
  29.             } catch (IllegalAccessException e) { 
  30. //                e.printStackTrace(); 
  31.             } 
  32.  
  33.         } 
  34.  
  35.     } 

4 GPBeanPostProcessor后置处理器

原生Spring中的BeanPostProcessor是为对象初始化事件设置的一种回调机制。这个Mini版本中只做说明,不做具体实现,感兴趣的“小伙伴”可以继续深入研究Spring源码。

  1. package com.tom.spring.formework.beans.config; 
  2.  
  3. public class GPBeanPostProcessor { 
  4.  
  5.     //为在Bean的初始化之前提供回调入口 
  6.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws Exception { 
  7.         return bean; 
  8.     } 
  9.  
  10.     //为在Bean的初始化之后提供回调入口 
  11.     public Object postProcessAfterInitialization(Object bean, String beanName) throws Exception { 
  12.         return bean; 
  13.     } 

至此,DI部分就手写完成了,也就是说完成了Spring的核心部分。“小伙伴们”是不是发现其实还是很简单的?

 

责任编辑:姜华 来源: Tom弹架构
相关推荐

2021-12-27 08:27:17

SpringMVC面试

2021-12-14 07:43:52

Spring核心原理环境准备

2020-11-02 09:35:04

ReactHook

2020-12-03 08:14:45

Axios核心Promise

2011-05-31 10:00:21

Android Spring 依赖注入

2022-04-30 08:50:11

控制反转Spring依赖注入

2021-07-29 06:55:03

Spring@AutowriedbyType注入

2022-01-05 08:53:13

Spring原理分析MVC

2016-03-21 17:08:54

Java Spring注解区别

2023-02-23 08:15:33

Spring异常处理机制

2021-02-28 20:41:18

Vue注入Angular

2009-09-08 15:22:20

Spring依赖注入

2020-08-06 00:14:16

Spring IoC依赖注入开发

2023-10-07 08:35:07

依赖注入Spring

2020-05-21 13:25:43

Spring组件架构

2011-03-01 13:45:41

Spring3Annotation

2021-08-10 18:36:02

Express原理面试

2020-11-24 07:48:32

React

2020-10-20 09:12:57

axios核心原理

2023-07-11 09:14:12

Beanquarkus
点赞
收藏

51CTO技术栈公众号