Spring - IOC源码分析(一)

关注

原创 2022-07-14 11:44:10 829 阅读 AI 写同款· GEO 优化 ›

Spring IoC 源码分析 (基于注解) 一一、 IoC 理论 IoC 全称为 Inversion of Control，翻译为 “控制反转”，它还有一个别名为 DI（Dependency Injection）,即依赖注入。二、IoC方式 Spring为IoC提供了2种方式，一种是基于xml，另一种是基于注解。标签来定义bean，进行管理。 @Bean注解来定义bean，进行管理。本次文章我们就来分析下基于注解的IoC原理，在看文章之前我们可以带一些疑问，这样有助于我们更好的理解。 @Bean是干什么用的？ @Controller、@Se 阅读详情

SpringIOC的核心思想

IOC的思想最核心的地方在于，资源不由使用资源的双方管理，而由不使用资源的第三方管理，这可以带来很多好处，第一，资源集中管理，实现资源的可配置和易管理。第二，降低了使用资源双方的依赖程度，也就是我们说的耦合度。

Spring IOC容器的加载过程

public class MainStat {

	public static void main(String[] args) {
		ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
		UserServiceImpl bean = context.getBean(UserServiceImpl.class);
		bean.sayHi();

		Car car = context.getBean(Car.class);
		car.say();
	}

}

MainConfig配置类

@Configuration
@ComponentScan("com.spring.ioc.service")
public class MainConfig {
}

MainConfig配置类主要是用于扫描整个包
在这里插入图片描述

UserServiceImpl 类

@Service
public class UserServiceImpl {

	public void sayHi(){
		System.out.println("234879872384sdfsdf！");
	}
}

1、实例化容器：AnnotationConfigApplicationContext

从这里出发：

ApplicationContext context = new AnnotationConfigApplicationContext(MainStat.class);

AnnotationConfigApplicationContext的结构关系

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		/**
		 * 这个this()方法是调用该类的父类GenericApplicationContext的构造器，主要作用是实现了三点
		 * ①实例化一个bean工厂，在父类GenericApplicationContext中实例化的
		 * ②获取bean定义的读取器reader,这个里面注册了很多后置处理器，尤其是ConfigurationClassPostProcessor处理器，该处理器主要解析配置类
		 * ③ scanner的用处不是很大，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
		 * 
		 *
		 * 	 （1）DefaultListableBeanFactory
		 * 			* 注册bean定义
		 * 			* 实现BeanFactory接口、实现了BeanDefinitionRegistry(注册bean定义)
		 */
		this();
		/**
		 * 注册我们的配置类
		 */
		register(componentClasses);

		/**
		 * 刷新
		 */
		refresh();
	}

this()方法对应的构造器结构：

/**
	 * Create a new AnnotationConfigApplicationContext that needs to be populated
	 * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
	 *
	 * 该构造器的作用：
	 * 1、实例化了一个bean工厂
	 * 2、注册了很多处理器(bean定义)
	 * 3、scanner的用处不是很大，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
	 */
	public AnnotationConfigApplicationContext() {
		/**
		 * 创建一个读取注解的Bean定义读取器reader
		 * 完成了spring内部BeanDefinition的注册（主要是后置处理器）
		 */
		this.reader = new AnnotatedBeanDefinitionReader(this);

		/**
		 * 创建BeanDefinition扫描器
		 * 可以用来扫描包或者类
		 *
		 * spring默认的扫描包不是这个scanner对象
		 * 而是自己new的一个ClassPathBeanDefinitionScanner
		 * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext
		 * 对象的scan方法
		 *
		 */
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

我们先来为构造方法做一个简单的说明：
1、scanner的用处不是很大，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
2、这个配置类有两种情况，一种是传统意义上的带上@Configuration注解的配置类，还有一种是没有带上@Configuration，但是带有@Component，@Import，@ImportResouce，@Service，
@ComponentScan等注解的配置类，在Spring内部把前者称为Full配置类，把后者称之为Lite配置类。在本源码分析中，有些地方也把Lite配置类称为普通Bean。使用断点调试，通过this()调用此类无参的构造方法，代码到下面：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements Annotatio
nConfigRegistry {

 //注解bean定义读取器，主要作用是用来读取被注解的了bean
 private final AnnotatedBeanDefinitionReader reader;

 //扫描器，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
 private final ClassPathBeanDefinitionScanner scanner;

 /**
 * Create a new AnnotationConfigApplicationContext that needs to be populated
 * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
 */
public AnnotationConfigApplicationContext() {
 //会隐式调用父类的构造方法，初始化DefaultListableBeanFactory

 //初始化一个Bean读取器
 this.reader = new AnnotatedBeanDefinitionReader(this);

 //初始化一个扫描器，它仅仅是在我们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
 this.scanner = new ClassPathBeanDefinitionScanner(this);
 }
 }

首先无参构造方法中就是对读取器reader和扫描器scanner进行了实例化，reader的类型是AnnotatedBeanDefinitionReader，可以看出它是一个 “打了注解的Bean定义读取器”，scanner的类型是ClassPathBeanDefinitionScanner，它仅仅是在外面手动调用.scan方法，或者调用参数为String的构造方法，传入需要扫描的包名才会用到，像这样方式传入的配置类是不会用到这个scanner对象的。AnnotationConfigApplicationContext类是有继承关系的，会隐式调用父类的构造方法
下面代码：

2、实例化工厂：DefaultListableBeanFactory

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

	private final DefaultListableBeanFactory beanFactory;

	@Nullable
	private ResourceLoader resourceLoader;

	private boolean customClassLoader = false;

	private final AtomicBoolean refreshed = new AtomicBoolean();


	/**
	 * Create a new GenericApplicationContext.
	 * @see #registerBeanDefinition
	 * @see #refresh
	 *
	 * 实例化一个bean工厂
	 */
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

DefaultListableBeanFactory的关系图
在这里插入图片描述
DefaultListableBeanFactory是相当重要的，从字面意思就可以看出它是一个Bean的工厂，什么是Bean的工厂？当然就是用来生产和获得Bean的

3、实例化BeanDefinition读取器：AnnotatedBeanDefinitionReader：

其主要做了2件事
1.注册内置BeanPostProcessor
2.注册相关的BeanDefinition
在这里插入图片描述

让我们把目光回到AnnotationConfigApplicationContext的无参构造方法，让我们看看Spring在初始化AnnotatedBeanDefinitionReader的时候做了什么：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

这里的BeanDefinitionRegistry当然就是AnnotationConfigApplicationContext的实例了，这里又直接调用了此类其他的构造方法。

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

让我们把目光移动到这个方法的最后一行，进入registerAnnotationConfigProcessors方法

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

这又是一个门面方法，再点进去，这个方法的返回值Set，但是上游方法并没有去接收这个返回值，所以这个方法的返回值也不是很重要了，当然方法内部给这个返回值赋值也不重要了。由于这个方法内容比较多，这里就把最核心的贴出来，这个方法的核心就是注册Spring内置的多个Bean。

/**
		 * 为我们容器中注册了解析配置类的后置处理器
		 * 	这个internalConfigurationAnnotationProcessor类中，
		 * 	会解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解
		 * 	主要负责处理配置类
		 */
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

1、判断容器中是否已经存在了ConfigurationClassPostProcessor Bean
2、如果不存在（当然这里肯定是不存在的），就通过RootBeanDefinition的构造方法获得ConfigurationClassPostProcessor的BeanDefinition，RootBeanDefinition是BeanDefinition的子类。
3、执行registerPostProcessor方法，registerPostProcessor方法内部就是注册Bean，当然这里注册其他Bean也是一样的流程。

BeanDefinition是什么？
BeanDefinition联系图
1、向上
在这里插入图片描述

BeanMetadataElement接口：BeanDefinition元数据，返回该Bean的来源
AttributeAccessor接口：提供对BeanDefinition属性操作能力

2、向下
在这里插入图片描述
它是用来描述Bean的，里面存放着关于Bean的一系列信息，比如Bean的作用域，Bean所对应的Class，是否懒加载，是否Primary等等，这个BeanDefinition也相当重要，我们以后会常常和它打交道。

registerPostProcessor方法：

private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(beanName, definition);
		return new BeanDefinitionHolder(definition, beanName);
	}

这方法为BeanDefinition设置了一个Role，ROLE_INFRASTRUCTURE代表这是spring内部的，并非用户定义的，然后又调用了registerBeanDefinition方法，再点进去，Oh No，你会发现它是一个接口，没办法直接点进去了，首先要知道registry实现类是什么，那么它的实现是什么呢？答案是DefaultListableBeanFactory：

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
 throws BeanDefinitionStoreException {
 this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
 }

这又是一个门面方法，再点进去，核心在于下面两行代码

 //beanDefinitionMap是Map<String, BeanDefinition>，
 //这里就是把beanName作为key，ScopedProxyMode作为value，推到map里面
 this.beanDefinitionMap.put(beanName, beanDefinition);

 //beanDefinitionNames就是一个List<String>,这里就是把beanName放到List中去
 this.beanDefinitionNames.add(beanName);

beanDefinitionMap:

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

beanDefinitionNames:

private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

在这里插入图片描述

从这里可以看出DefaultListableBeanFactory就是我们所说的容器了，里面放着beanDefinitionMap，beanDefinitionNames，beanDefinitionMap是一个hashMap，beanName作为Key,beanDefinition作为Value，beanDefinitionNames是一个集合，里面存放了beanName

DefaultListableBeanFactory中的beanDefinitionMap，beanDefinitionNames也是相当重要的，以后会经常看到它，最好看到它，第一时间就可以反应出它里面放了什么数据

这里仅仅是注册，可以简单的理解为把一些原料放入工厂，工厂还没有真正的去生产
上面已经介绍过，这里会一连串注册好几个Bean，在这其中最重要的一个Bean（没有之一）就是BeanDefinitionRegistryPostProcessor Bean

ConfigurationClassPostProcessor实现BeanDefinitionRegistryPostProcessor接口，BeanDefinitionRegistryPostProcessor接口又扩展了BeanFactoryPostProcessor接口，BeanFactoryPostProcessor是Spring的扩展点之一，ConfigurationClassPostProcessor是Spring极为重要的一个类，必须牢牢的记住上面所说的这个类和它的继承关系
在这里插入图片描述
除了注册了ConfigurationClassPostProcessor，还注册了其他Bean，其他Bean也都实现了其他接口，比如BeanPostProcessor等.
BeanPostProcessor接口也是Spring的扩展点之一
至此，实例化AnnotatedBeanDefinitionReader reader分析完毕