Spring原理(一)--IOC原理

1 环境搭建

1 pom:
  <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>5.2.6.RELEASE</version>
   </dependency>
2 Appconfig:
 @ComponentScan("com.spring")
 @Configuration
 public class Appconfig {
 }
3 test.java:
   AnnotationConfigApplicationContext ac=new AnnotationConfigApplicationContext(Appconfig.class);
    UserService bean = (UserService) ac.getBean("userServiceImpl");
    System.out.println(bean);

2 原理

2.1整体流程

通过注解或者xml文件定义的每个类，通过BeanDefinitionReader读取后把元数据存放在一个spring创建的BeanDefinition的子类对象中(例如new AnnotationBeanDefinition)，把多个beanDefinition对象和对应的BeanName存放在一个beanDefinitionMap中(还会维护一个beanDefinitionNames的list存放所有的beanName)。然后通过BeanFactory从map中拿beanDefinition对象进行验证，创建bean对象(主要步骤:实例化->填充属性(注入)->初始化->代理 aop->put singletonObjects),最后把bean放在单例池map中(原型对象不会在容器初始化时创建，而是在getbean的时候创建)。

2.2 具体流程

从以下创建容器的代码开始分析ioc的具体实现原理

AnnotationConfigApplicationContext ac = new 
AnnotationConfigApplicationContext(Appconfig.class);

1 进入到new AnnotationConfigApplicationContext(Appconfig.class);
先执行父类GenericApplicationContext的构造方法创建beanFactory

	public GenericApplicationContext() {
	//创建beanFactory
		this.beanFactory = new DefaultListableBeanFactory();
	}

2 然后调用自己的构造方法this();

	public AnnotationConfigApplicationContext() {
	/**
	 1 创建一个读取注解bean定义的读取器AnnotatedBeanDefinitionReader
	 2 在此处会注册5个beanDefinition，其中一个是ConfigurationClassPostProcessor，
	是spring内部的BeanFactoryPostProcessor后置处理器，
	在后面用来解析配置类beanDefinition（就是Appconfig）
	**/
	    this.reader = new AnnotatedBeanDefinitionReader(this);
	/**
    创建一个用来扫描包的scanner(注意实际上扫描包的工作不是这个scanner做的
    而是spring自己new的一个ClassPathBeanDefinitionScanner，
    这里的scanner是为了程序员在外部调用AnnotationConfigApplicationContext.scan()方法)
    **/
	    this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

2.1 AnnotatedBeanDefinitionReader构造方法:

	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);
		//在此处添加的5个beanDefinition，
		//具体是里面的registerAnnotationConfigProcessors方法，
		//可以自己点进去看一下(里面会执行多个beanDefs.add方法进行添加)
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

3 接下来调用自己构造方法中的register(componentClasses)和spring核心方法refresh()

	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
	    //这里调用的就是上一步的构造方法，创建reader和scanner
		this();
		//将传过来的参数注册，可以注册一个单独的bean也可以注册一个配置类，
		//这里就是Appconfig.class，
		//将Appconfig.class封装成beanDefinition对象后put进beanDefinitionMap中
		register(componentClasses);
		//调用spring核心方法
		refresh();
	}

3.1 register()方法的核心是调用AnnotatedBeanDefinitionReader的doRegisterBean()方法，里面会new一个AnnotatedGenericBeanDefinition对象，然后经过一些判断，调用BeanDefinitionReaderUtils.registerBeanDefinition将创建的beanDefinition放入beanDefinitionMap中，此时beanDefinitionMap中共有6个beanDefinition。

	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {
        //new AnnotatedGenericBeanDefinition对象
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setInstanceSupplier(supplier);
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		//设置beanDefinition是否单例
		abd.setScope(scopeMetadata.getScopeName());
		//生成bean的名字
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}
        //将beanDefinition和beanName封装到一起
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//将beanDefinitionput进将beanDefinitionMap
		//内部最终调用this.beanDefinitionMap.put(beanName, beanDefinition);
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

4 refresh()核心方法

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			//准备工作,设置一些时间，属性
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//得到beanFactory对象工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			//准备工作包括添加一个类加载器、设置bean的解析器，用来解析bean的表达式、
			//添加一个BeanPostProcessor后置处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//空方法，留做扩展
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				//实例化和执行BeanFactoryPostProcessor(包括自定义的和spring内部定义的)；
				//完成扫描注解类(执行完成后所有beanDefinition都已经放入map中)
				invokeBeanFactoryPostProcessors(beanFactory);
                实例化和注册BeanPostProcessor
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
                //完成一些国际化信息
				// Initialize message source for this context.
				initMessageSource();
                //初始化广播器，发布一些事件
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
               //空方法，做扩展
				// Initialize other special beans in specific context subclasses.
				onRefresh();
                //注册监听器到广播器里
				// Check for listener beans and register them.
				registerListeners();
                 //完成所有非懒加载单例对象的实例化功能，通过反射实现，再进行bean的属性注入和初始化
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

5 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory():
这一步是用来获取beanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		//调用GenericApplicationContext的getBeanFactory()方法获取beanFactory
		return getBeanFactory();
	}

6 prepareBeanFactory(beanFactory)：
做一些准备工作，包括添加一个类加载器、设置bean的解析器，用来解析bean的表达式、添加一个BeanPostProcessor后置处理器 (ApplicationContextAwareProcessor还没用到)，是一个list，在bean的实例化过程中可以链式执行，插手bean的实例化过程、忽略一些自动注入的对象等

		// Tell the internal bean factory to use the context's class loader etc.
		//添加一个类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		//设置bean的解析器，用来解析bean的表达式
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		//添加一个BeanPostProcessor后置处理器(还没用到)，
		//是一个list，在bean的实例化过程中可以链式执行，插手bean的实例化过程。
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		//忽略一些自动注入的对象
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		//.....

6 postProcessBeanFactory(beanFactory);
空方法，留给扩展
7 invokeBeanFactoryPostProcessors(beanFactory)：
实例化和执行BeanFactoryPostProcessor(包括自定义的和spring内部定义的)

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	/**
     getBeanFactoryPostProcessors()是获得程序员在外部手动调用  
	AnnotationConfigApplicationContext.addBeanFactoryPostProcessor()给spring添加的  
	BeanFactoryPostProcessor
	这行代码是处理手动添加的和spring内部的BeanFactoryPostProcessor,
	若没有自己手动给spring添加的，这里就是执行，上面刚开始给spring添加的ConfigurationClassPostProcessor
	用来解析配置类appconfig，将包下配置的所有注解类封装成beanDefinition放入beanDefinitionMap中
	
	invokeBeanFactoryPostProcessors的invokeBeanDefinitionRegistryPostProcessors
	方法会调用ConfigurationClassPostProcessor#processConfigBeanDefinitions的parser.parse(candidates);进行具体的解析
	**/

		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
	
//.....
	}

8 finishBeanFactoryInitialization(beanFactory);
完成所有非懒加载单例对象的实例化功能，通过反射实现，再进行bean的属性注入和初始化

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		//.....
		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
        //.....
		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		//....

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

8.1 beanFactory.preInstantiateSingletons();方法进行创建单例bean

	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		//得到维护beanDefinitionName的list(刚开始有讲到spring不仅会维护beanDefinitionMap，
		//还会维护一个beanDefinitionNames的list存放所有的beanName，也就是map中的key，方便来遍历map)
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
		//从beanDefinitionMap中根据key拿到value，就是beanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//拿到beanDefinition后进行一些验证，是不是抽象、单例、懒加载，是不是FactoryBean
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
						//通过验证调用getBean(beanName)，实际完成bean的创建
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
	

	}

8.2 上一个方法中的getBean(beanName)中调用doGetBean方法

	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //判断beanName是否合法
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		//判断bean是否已被创建成功
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
		  //.........
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.

			// Check if bean definition exists in this factory.
			}
			
             //.......进行一系列的验证
                
				// Create bean instance.
				if (mbd.isSingleton()) {
				//验证通过进入getSingleton方法
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
				}
				//...............
		
		return (T) bean;
	}

8.3 上一个方法中的getSingleton方法

	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
		//还会判断再单例池中有没有这个bean
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
			//......
               //判断当前bean是否在排除bean集合之内，若不在将beanName放入一个set中
               //(singletonsCurrentlyInCreation)，表示当前bean正在被创建
				beforeSingletonCreation(beanName);
	       //......
				try {
				//会调用createBean(beanName, mbd, args)，
				//这就是上个一方法中getSingleton Lambda表达式体中的createBean方法;
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
				
				}
				//......
				if (newSingleton) {
				    //将创建好的bean放入单例池
					addSingleton(beanName, singletonObject);
				}

		
			}
			return singletonObject;
		}
	}

8.5 createBean(beanName, mbd, args)方法

@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

	  //.......

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		//得到类对象
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
          //.................
		try {
		//进行具体的创建
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        //.......
			return beanInstance;
		}
	}

8.5 上个方法中的doCreateBean方法:

//完成创建，仅仅是通过反射进行实例化
instanceWrapper = createBeanInstance(beanName, mbd, args);
//判断bean是否单例、是否支持循环依赖、是否正在创建
earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
//判断通过执行addSingletonFactory方法
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
//........
//完成属性注入
populateBean(beanName, mbd, instanceWrapper);
//完成初始化和aop(applyBeanPostProcessorsAfterInitialization方法完成)
exposedObject = initializeBean(beanName, exposedObject, mbd);

8.6 上个方法中的addSingletonFactory方法:

    //放入三级缓存,完成循环依赖的关键,
	this.singletonFactories.put(beanName, singletonFactory);
	//从二级缓存remove掉
	this.earlySingletonObjects.remove(beanName);

8.7最后调用addSingleton(beanName, singletonObject);将返回的singletonObject放入单例池

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
		    //放入单例池(一级缓存)
			this.singletonObjects.put(beanName, singletonObject);
			//从三级缓存remove掉
			this.singletonFactories.remove(beanName);
			//从二级缓存remove掉
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

//未完待续，关于循环依赖和aop的实现请看本人下一边文章