Spring IOC源码笔记-IOC核心组件

IOC容器

示例代码

UserService.java

package com.personal.service;

import com.personal.entity.User;

public class UserService {
    String getUserByUserName(String userName) {
    return userName
}

Main.java

package com.personal.source;

import com.personal.entity.User;
import com.personal.service.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

@SuppressWarnings("all")
public class Main {
    public static void main(String[] args) {
        ClassPathResource resource = new ClassPathResource("BeanFactory.xml");
        BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
        UserService userService = xmlBeanFactory.getBean("userService", UserService.class);
        String user = userService.getUserByUserName("xuyang");
        System.out.println(user);
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans
                            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.personal.service.impl.UserServiceImpl" />  
</beans>

代码分析

从main方法入口进行源代码分析:

ClassPathResource resource = new ClassPathResource("BeanFactory.xml");

加载类路径下的spring配置文件，并生成ClassPathResource对象在内存中的表示

该对象的继承结构为:

由此可见，该对象在spring内部标识一种资源。

BeanFactory xmlBeanFactory = new XmlBeanFactory(resource);

该行代码构造了XmlBeanFactory对象，该对象是一种BeanFactory，spring ioc最核心的其实就是一系列的BeanFactory的继承结构，其核心作用就是两种

第一：加载bean的配置文件，从而在内存中生成BeanDefinition对象

第二：根据第一步生成的BeanDefinition对象创建bean的实例

我们看下XmlBeanFactory的继承结构：

依次分析该结构中几个重要的spring内部组件

1：BeanFactory该接口是bean工厂的顶级接口，其主要方法为

//根据bean名称获取bean的实例
Object getBean(String name) throws BeansException;

//根据bean名称以及bean的class获取bean的实例
<T> T getBean(String name, Class<T> requiredType) throws BeansException;

//根据bean的class以及参数获取bean的实例
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

// bean工厂是否包含指定名称的bean
boolean containsBean(String name);

// 该bean在bean工厂是否是单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

 获取bean的别名
String[] getAliases(String name);

2：HierarchicalBeanFactory：

该接口表示的具有层次结构的bean工厂，其主要方法为BeanFactory getParentBeanFactory();获取父BeanFactory

3：ListableBeanFactory：

该接口为可列举的BeanFactory，可枚举出当前beanFactory中一些列的bean的属性，其主要方法如下:

//获取当前bean工厂中已加载的所有BeanDefinition的个数
int getBeanDefinitionCount();

//获取当前bean工厂中已加载的所有BeanDefinition的名称数组
String[] getBeanDefinitionNames();

//获取当前bean工厂中已加载的所有Class的名称数组
String[] getBeanNamesForType(Class<?> type);

//获取当前bean工厂中基于已加载的所有bean的注解Class来获取beanname名称数组
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

//获取当前bean工厂中基于已加载bean的注解
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;

4：BeanDefinitionRegistry：

该接口表示所有的BeanDefinition的注册中心，用于注册、移除BeanDefinition，其主要方法如下:

//注册bean的定义对象
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;

//移除bean的定义对象
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

//获取bean的定义对象
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

//在BeanDefinitionRegistry是否已经有BeanDefinition的名称已经被使用过
boolean isBeanNameInUse(String beanName);

5：ConfigurableBeanFactory可配置的bean工厂，用于设置bean的父子关系，以及设置bean的classLoader等等，其主要方法如下：

//设置父beanfactory
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

//设置bean的类加载器
void setBeanClassLoader(ClassLoader beanClassLoader);

//设置bean的临时类加载器
void setTempClassLoader(ClassLoader tempClassLoader);

//设置bean的表达式解析器
void setBeanExpressionResolver(BeanExpressionResolver resolver);

//获取bean的作用于
Scope getRegisteredScope(String scopeName);

//注册别名
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

//解析别名
void resolveAliases(StringValueResolver valueResolver);

//表示创建的bean是否是factoryBean(该FactoryBean是一个特殊的bean，它本身是一个bean同时他也可以生成其他bean)
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

//设置当前实例化的bean是处在循环创建当中，用于后续排除检查循环依赖的bean被创建多次
void setCurrentlyInCreation(String beanName, boolean inCreation);

//该bean在beanFactory中是否是循环创建
boolean isCurrentlyInCreation(String beanName);

//获取依赖的bean名称
String[] getDependenciesForBean(String beanName);

//销毁bean对象
void destroyBean(String beanName, Object beanInstance);

6：AutowireCapableBeanFactory具有自动装配能力以及创建能力的BeanFactory（自动装配可以有几种形式，属性已给出），其主要方法如下：

//不进行自动装配
int AUTOWIRE_NO = 0;

//通过名称进行自动装配
int AUTOWIRE_BY_NAME = 1;

//通过bean的class类型自动装配
int AUTOWIRE_BY_TYPE = 2;

//构造器自动装配
int AUTOWIRE_CONSTRUCTOR = 3;

//已取消使用
@Deprecated
int AUTOWIRE_AUTODETECT = 4;

//创建bean
<T> T createBean(Class<T> beanClass) throws BeansException;

//装配一个已存在的bean
void autowireBean(Object existingBean) throws BeansException;

//根据是否需要依赖检查以及装配模式决定创建并装配bean
Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

//自动装配bean的属性
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) throws BeansException;

//初始化bean
Object initializeBean(Object existingBean, String beanName) throws BeansException;

//申请BeanPostProcessors对象以便调用BeanPostProcessors的postProcessBeforeInitialization方法
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;

//依赖解析
Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName) throws BeansException;

7：SingletonBeanRegistry单例bean注册中心

//在bean注册中心将给定的现有对象注册为单例对象，使用给定的bean名称
void registerSingleton(String beanName, Object singletonObject);

//返回在给定名称下注册的(原始)单例对象
Object getSingleton(String beanName);

//检查此注册中心是否包含具有给定名称的单例实例
boolean containsSingleton(String beanName);

//返回在此注册中心注册的单例bean的名称
String[] getSingletonNames();

//返回在此注册中心注册的单例bean的数量
int getSingletonCount();

以上为spring中beanFactory体系中几个主要的内部核心接口，其他类以及抽象类都是对以上接口的方法实现，分析源码时具体问题具体分析。DefaultListableBeanFactory最底层实现类，因此它具有以上所有功能同时它也是spring容器bean工厂的最核心的类

转载于:https://my.oschina.net/u/2993045/blog/3017742