Spring核心源码学习

浅浅的花香味﹌ 2024-04-18 15:28 63阅读 0赞

我们学习spring源码最好的方式就是阅读较早的版本，早期版本代码结构简单，模块较少，使得初学者能将更多的精力放在spring的核心原理上。本文使用的源码为0.9.1版本。源码下载地址：

[git@gitee.com][git_gitee.com]:limengg/spring-0.9.1-annotated.git

下载完成后，使用开发工具导入项目，就可以进行代码的跟着调试了。

代码结构如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29RaW5nVGlhbjEyMzQ1Ng_size_16_color_FFFFFF_t_70][]

源码中带有测试用例：Test。在Test的useFactoryTest方法中，展示了加载一个bean的加载、获取和使用的过程。

Test类测试代码：

String file = "/Users/limeng/code/SRC_CODE/spring-0.9.1-annotated/src/test/resources/pets.xml";
    
    XmlBeanFactory fac = new XmlBeanFactory(file, null);
    
    // Find bean isabelle
    
    Owner isabelle = (Owner)fac.getBean("isabelle");
    
    System.out.println("Found bean: " + isabelle.getName() + " with pets: ");
    
    ListIterator iter = isabelle.getPets().listIterator();
    
    while (iter.hasNext()) {
    
        IPet pet = (IPet) iter.next();
    
        ISpecies sp = pet.getSpecies();
    
        System.out.println(pet.getName() + " of species " + sp.getName());
    
    }

我们把断点打在创建XmlBeanFactory这一行。

XmlBeanFactory fac = new XmlBeanFactory(file, null);

XmlBeanFactory的构造有两个参数，第一个为bean定义的xml文件路径，第二个参数为要加载的bean的父BeanFactory。启动测试类后，进入XmlBeanFactory构造函数。构造函数如下：

public XmlBeanFactory(String filename, BeanFactory parentBeanFactory) throws BeansException {
    
       super(parentBeanFactory);
    
       loadBeanDefinitions(filename);
    
    }

构造方法中一共做了两件事。首先调用父类构造函数，调用路径为 XmlBeanFactory -> ListableBeanFactoryImpl -> AbstractBeanFactory.

最终，AbstractBeanFactory将传入的父BeanFactory进行保存。

然后来到构建BeanFactory初始化代码的第二行：加载bean的定义。将断点打在这一行，并调试进入loadBeanDefinitions方法实现。

loadBeanDefinitions中，构造DocumentBuilder解析xml inputstream得到Document对象。Document中持有解析xml中定义的全部标签及属性。代码如下：

public void loadBeanDefinitions(InputStream is) throws BeansException {
    
       if (is == null)
    
          throw new BeanDefinitionStoreException("InputStream cannot be null: expected an XML file", null);
    
       try {
    
          logger.info("Loading XmlBeanFactory from InputStream [" + is + "]");
    
          // 单例模式获取Document构建工程
    
          DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    
          logger.debug("Using JAXP implementation [" + factory + "]");
    
          // 是否开启xml的语法校验，校验是否符合DTD或W3C规范
    
          factory.setValidating(true);
    
          // 使用Document构建工厂生产一个Document构建器
    
          DocumentBuilder db = factory.newDocumentBuilder();
    
          // 设置构建器的异常处理器
    
          db.setErrorHandler(new BeansErrorHandler());
    
          // 设置bean解析器，bean解析器中加载了bean的常用标签属性
    
          db.setEntityResolver(this.entityResolver != null ? this.entityResolver : new BeansDtdResolver());
    
          // 解析xml输入流，得到Document对象
    
          Document doc = db.parse(is);
    
          // 加载Document对象的bean内容
    
          loadBeanDefinitions(doc);
    
       }
      // catch … finally {//...}
    }

拿到含有bean定义信息的Document对象后，逐个加载bean的属性，包含id、class、name、init-method、parent属性，使用这些属性构造一个RootBeanDefinition返回。使用RootBeanDefinition和bean id调用父类ListableBeanFactoryImpl的registerBeanDefinition对bean进行注册。

private void loadBeanDefinition(Element el) throws BeansException {
    
       // The DTD guarantees an id attribute is present
    
       // bean ID
    
       String id = el.getAttribute(ID_ATTRIBUTE);
    
       // Create BeanDefinition now: we'll build up PropertyValues later
    
       AbstractBeanDefinition beanDefinition;
    
       // 获取bean定义本身的属性信息（非bean的属性）
    
       PropertyValues pvs = getPropertyValueSubElements(el);
    
       // 解析bean定义的属性信息，如class、name、parent
    
       beanDefinition = parseBeanDefinition(el, id, pvs);
    
       // 将定义信息注册到spring(存入名为beanDefinitionMap的Map中)
    
       registerBeanDefinition(id, beanDefinition);
    
       String name = el.getAttribute(NAME_ATTRIBUTE);
    
       // 如果同时指定了id和name，将name注册到aliasMap中，提供可以通过name查找bean的功能
    
       if (name != null && !"".equals(name)) {
    
          // Automatically create this alias. Used for
    
          // names that aren't legal in id attributes
    
          registerAlias(id, name);
       }
    }

到这里，BeanFactory加载Bean定义信息的过程已经完成。可以看到，加载bean并没有初始化将bean实例化，仅仅是解析xml获得bean定义属性，然后将定义的属性信息保存。

2.初始化bean

真正的bean的实例化是在getBean，也就是获取bean的时候进行的。我们试着验证这个想法。

执行完测试用例的第一行代码加载Bean后，接下来获取bean。将断点打在getBean方法上，开始对getBean的跟踪。

factory.getBean("beanName")

跟踪代码执行过程，首先来到AbstractBeanFactory的getBeanInternal方法。方法中首先获取前面加载的bean定义信息，然后判断是否是单例模式的bean，如果不是，则新建一个bean返回。否则，获取一个shared bean。

AbstractBeanFactory中getBeanInternal的实现：

try {
    
       AbstractBeanDefinition bd = getBeanDefinition(transformedBeanName(name));// 获取加载的bean定义
    
       if (bd.isSingleton()) { //单例从缓存中获取 
    
          // check for bean instance created in the current call,
    
          // to be able to resolve circular references
    
          if (newlyCreatedBeans != null && newlyCreatedBeans.containsKey(name)) {
    
             return newlyCreatedBeans.get(name);
    
          }
    
          return getSharedInstance(name, newlyCreatedBeans);
    
       }
    
       else {//非单例新建bean
    
          return createBean(name, newlyCreatedBeans);
    
       }
    }

getSharedInstance为spring bean的核心重点内容，先上代码。

private final synchronized Object getSharedInstance(String pname, Map newlyCreatedBeans) throws BeansException {
    
       // Get rid of the dereference prefix if there is one
    
       // pname为bean的名称，这行代码有两个作用：1.得到FactoryBean的name；2.根据bean name获取bean id
    
       String name = transformedBeanName(pname);
    
       // 使用前面获得的bean id获取缓存的bean实例
    
       Object beanInstance = this.sharedInstanceCache.get(name);
    
       if (beanInstance == null) {// 第一次肯定是null
    
          logger.info("Creating shared instance of singleton bean '" + name + "'");
    
          // 新建bean的实例
    
          beanInstance = createBean(name, newlyCreatedBeans);
    
          // 缓存到sharedInstanceCache
    
          this.sharedInstanceCache.put(name, beanInstance);
    
       }
    
       else {
    
          if (logger.isDebugEnabled())
    
             logger.debug("Returning cached instance of singleton bean '" + name + "'");
    
       }
    
       // Don't let calling code try to dereference the
    
       // bean factory if the bean isn't a factory
    
       // 如果bean name仍然含有Factory Bean专有的&符号，则报错
    
       if (isFactoryDereference(pname) && !(beanInstance instanceof FactoryBean)) {
    
          throw new BeanIsNotAFactoryException(name, beanInstance);
    
       }
    
       // Now we have the beanInstance, which may be a normal bean
    
       // or a FactoryBean. If it's a FactoryBean, we use it to
    
       // create a bean instance, unless the caller actually wants
    
       // a reference to the factory.
    
       // FactoryBean 类型的bean 特殊处理,使用此FactoryBean构建目标bean
    
       if (beanInstance instanceof FactoryBean) {
    
          if (!isFactoryDereference(pname)) {
    
             // Configure and return new bean instance from factory
    
             FactoryBean factory = (FactoryBean) beanInstance;
    
             logger.debug("Bean with name '" + name + "' is a factory bean");
    
             // 通过FactoryBean生产bean
    
             beanInstance = factory.getObject();
    
             // Set pass-through properties
    
             if (factory.getPropertyValues() != null) {
    
                logger.debug("Applying pass-through properties to bean with name '" + name + "'");
                new BeanWrapperImpl(beanInstance).setPropertyValues(factory.getPropertyValues());
    
             }
             // Initialization is really up to factory
             //invokeInitializerIfNecessary(beanInstance);
          }
          else {
    
             // The user wants the factory itself
             logger.debug("Calling code asked for BeanFactory instance for name '" + name + "'");
    
          }
       }  // if we're dealing with a factory bean
    
       return beanInstance;
    }

其中，首先根据bean name获取bean的id，根据bean id从spring的sharedInstanceCache获取缓存的bean。如果是第一次加载这个bean，Map缓存中肯定是没有这个bean实例的，需要新建一个bean的实例，然后放入sharedInstanceCache 中，这个map就是spring管理bean的缓存map。

进入createBean()方法。代码如下：

private Object createBean(String name, Map newlyCreatedBeans) throws BeansException {
    
       // 获取bean定义
    
       RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(name);
    
       logger.debug("Creating instance of bean '" + name + "' with merged definition [" + mergedBeanDefinition + "]");
    
       // 将目标bean进行包装，方便设置属性值
    
       BeanWrapper instanceWrapper = new BeanWrapperImpl(mergedBeanDefinition.getBeanClass());
    
       Object bean = instanceWrapper.getWrappedInstance();
    
    
    
       // Cache new instance to be able resolve circular references, but ignore
    
       // FactoryBean instances as they can't create objects if not initialized
    
       // 提前曝光，解决单例模式下的bean的循环引用依赖问题
    
       if (!(bean instanceof FactoryBean)) {
    
          if (newlyCreatedBeans == null) {
    
             newlyCreatedBeans = new HashMap();
    
          }
    
          newlyCreatedBeans.put(name, bean);
    
       }
    
       // 获取bean定义中属性值
    
       PropertyValues pvs = mergedBeanDefinition.getPropertyValues();
    
    /*  设置bean实例的属性值，这里使用了前面为了解决循环引用的map。
    
       原理为：如果当然bean的定义中（A），含有其他bean的引用(B)，则查询newlyCreatedBeans这个map。
    
       如果map中已经含有这个引用(B)的bean，直接取出使用。
    
       这样一来，B不会因为A的实例化而造成重复加载。
    
    */
    
       applyPropertyValues(instanceWrapper, pvs, name, newlyCreatedBeans);
    
       // 调用注册的一些监听函数，如初始化、aware接口
    
       callLifecycleMethodsIfNecessary(bean, name, mergedBeanDefinition, instanceWrapper);
    
       return bean;
    
    }

createBean()方法实现根据name获取bean定义，将bean定义包装一层获得实例bean，包装是为了后面设置bean的属性值。随后，spring使用了提前曝光的方法，解决bean循环依赖的问题，原理为：

如果当然bean的定义中（A），含有其他bean的引用(B)，则查询newlyCreatedBeans这个map。

如果map中已经含有这个引用(B)的bean，直接取出使用。

这样一来，B不会因为A的实例化而造成重复加载。

接下来，就是设置bean的属性值和调用一些在bean初始化时的监听函数。最后返回实例化的bean。

至此，bean的获取完成，接下来就是bean的使用和销毁。这里就不展开了，需要学习者亲自跟着调试代码以加深理解。

[git_gitee.com]: mailto:git@gitee.com
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29RaW5nVGlhbjEyMzQ1Ng_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5094ec9dce5f4368bd61c606bd8d8eb5.png