Spring IOC流程
-
ApplicationContext 和BeanFactory。
BeanFactory是Spring Bean工厂的顶级接口，提供的功能单一，每次getBean的时候会去创建对象。ApplicationContext 继承BeanFactory，提供了很多扩展功能，容器在启动的时候会创建所有非懒加载的bean，使用getBean去获取对象的时候会直接从容器中获取。
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {// 这里由于他有父类,先调用父类的构造方法// 在自己构造方法中开始一个读取器和扫描器this();register(componentClasses);refresh();}
-
refresh() 刷新（创建）Spring容器
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 准备工作包括设置启动时间,是否激活标识位，初始化属性源配置prepareRefresh();// 获取新的 beanFactory ,销毁原有 beanFactory 、为每个 bean 生成 BeanDefinitionConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 接口,添加bean,添加bean后置处理器prepareBeanFactory(beanFactory);try {// 模板方法，此时，所有的beanDefinition已经加载，但是还没有实例化。 // 允许在子类中对beanFactory进行扩展处理。 // 比如添加ware相关接口自动装配设置，添加后置处理器等， // 是子类扩展prepareBeanFactory(beanFactory)的方法postProcessBeanFactory(beanFactory);// 实例化并调用所有注册的beanFactory后置处理器 // （实现接口BeanFactoryPostProcessor的bean，在beanFactory标准初始化之后执行）。invokeBeanFactoryPostProcessors(beanFactory);// 执行自定义的ProcessBeanFactoryregisterBeanPostProcessors(beanFactory);// 初始化国际化工具类MessageSourceinitMessageSource();// 初始化事件广播器initApplicationEventMulticaster();// 模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。onRefresh();// 注册监听器，广播early application eventsregisterListeners();// 实例化所有剩余的（非懒加载）单例 // 比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类，在这个时候都会被初始化。 // 实例化的过程各种BeanPostProcessor开始起作用。finishBeanFactoryInitialization(beanFactory);// refresh做完之后需要做的其他事情finishRefresh();}catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);}destroyBeans();cancelRefresh(ex);throw ex;}finally {resetCommonCaches();}}} -
prepareRefresh()
protected void prepareRefresh() {// 记录Spring启动时间this.startupDate = System.currentTimeMillis();// 容器关闭标记this.closed.set(false);// 容器存活标记this.active.set(true);if (logger.isDebugEnabled()) {if (logger.isTraceEnabled()) {logger.trace("Refreshing " + this);}else {logger.debug("Refreshing " + getDisplayName());}}initPropertySources();getEnvironment().validateRequiredProperties();if (this.earlyApplicationListeners == null) {this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);}else {this.applicationListeners.clear();this.applicationListeners.addAll(this.earlyApplicationLiss = new LinkedHashSet<>();} -
obtainFreshBeanFactory()
-
prepareBeanFactory
为bean添加后置处理器
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// Tell the internal bean factory to use the context's class loader etc.beanFactory.setBeanClassLoader(getClassLoader());beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));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);// BeanFactory interface not registered as resolvable type in a plain factory.// MessageSource registered (and found for autowiring) as a bean.beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);// Register early post-processor for detecting inner beans as ApplicationListeners.beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));// Detect a LoadTimeWeaver and prepare for weaving, if found.if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));// Set a temporary ClassLoader for type matching.beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// Register default environment beans.if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());}if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());}if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());}} -
postProcessBeanFactory
postProcessBeanFactory为钩子方法。
-
invokeBeanFactoryPostProcessors
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// getBeanFactoryPostProcessors() 获取Spring自定义的，这个list是在AnnotationConfigApplicationContext被定义的// 自定义的需要调用AnnotationConfigApplicationContext.addBeanFactoryPostProcesor()PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}}在invokeBeanDefinitionRegistryPostProcessors方法中开始扫描包。将需要实例化的bean封装成BeanDefinitionHolder。
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {// app提供的beanList<BeanDefinitionHolder> configCandidates = new ArrayList<>();// 获取容器中注册的所有bean名字String[] candidateNames = registry.getBeanDefinitionNames();for (String beanName : candidateNames) {BeanDefinition beanDef = registry.getBeanDefinition(beanName);if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {if (logger.isDebugEnabled()) {logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);}}// 判断是否是Configuration类，@Component、@ComponentScan、@Import、@ImportResourceelse if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));}}if (configCandidates.isEmpty()) {return;}// 根据@Order注解排序，确定加载bean的顺序configCandidates.sort((bd1, bd2) -> {int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());return Integer.compare(i1, i2);});SingletonBeanRegistry sbr = null;if (registry instanceof SingletonBeanRegistry) {sbr = (SingletonBeanRegistry) registry;if (!this.localBeanNameGeneratorSet) {BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);if (generator != null) {this.componentScanBeanNameGenerator = generator;this.importBeanNameGenerator = generator;}}}if (this.environment == null) {this.environment = new StandardEnvironment();}// 实例化 ConfigurationClassParser 为了解析各个配置类ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment,this.resourceLoader, this.componentScanBeanNameGenerator, registry);Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());do {parser.parse(candidates);parser.validate();Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());configClasses.removeAll(alreadyParsed);if (this.reader == null) {this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment,this.importBeanNameGenerator, parser.getImportRegistry());}this.reader.loadBeanDefinitions(configClasses);alreadyParsed.addAll(configClasses);candidates.clear();if (registry.getBeanDefinitionCount() > candidateNames.length) {String[] newCandidateNames = registry.getBeanDefinitionNames();Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));Set<String> alreadyParsedClasses = new HashSet<>();for (ConfigurationClass configurationClass : alreadyParsed) {alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());}for (String candidateName : newCandidateNames) {if (!oldCandidateNames.contains(candidateName)) {BeanDefinition bd = registry.getBeanDefinition(candidateName);if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&!alreadyParsedClasses.contains(bd.getBeanClassName())) {candidates.add(new BeanDefinitionHolder(bd, candidateName));}}}candidateNames = newCandidateNames;}}while (!candidates.isEmpty());if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());}if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();}}-
finishBeanFactoryInitialization
在**beanFactory.preInstantiateSingletons()**方法里面实例化bean。
public void preInstantiateSingletons() throws BeansException {ListbeanNames = new ArrayList<>(this.beanDefinitionNames);// 遍历所有beanfor (String beanName : beanNames) {// 根据bean的名字获取一个BeanDefinitionRootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);// 实例化不是抽象的懒加载的单例 Beanif (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {// 如果是Bean继承FactoryBeanObject 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 )((SmartFactoryBean) factory)::isEagerInit,getAccessControlContext());}else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}}else {getBean(beanName);}}}// Trigger post-initialization callback for all applicable beans...for (String beanName : beanNames) {Object singletonInstance = getSingleton(beanName);if (singletonInstance instanceof SmartInitializingSingleton) {final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction 在getBean() - doGetBean()中获得bean，Spring会先去容器中查询有没有bean，有则直接返回bean，没有才开始创建。getSingleton()方法去容器赵bean。Spring也是在这里开始解决循环依赖了。earlySingletonObjects是已经实例化完成的bean，可以直接使用，Spring也是先在earlySingletonObjects中获取，如果获取不到则取earlySingletonObjects中获取，earlySingletonObjects中的bean并没有完全完成依赖注入，这个时候如何有一个bean需要注入这个没有没有完成DI的bean，允许早期引用当前创建的对象。最后再去singletonFactories中获取，这个Map中存放的是需要创建Bean的ObjectFactory，通过ObjectFactory可以创建所需要的bean。
/** Cache of singleton objects: bean name to bean instance. */private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** Cache of singleton factories: bean name to ObjectFactory. */private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);/** Cache of early singleton objects: bean name to bean instance. */private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);protected Object getSingleton(String beanName, boolean allowEarlyReference) {// 在已经注册的单例 Bean 查找Object singletonObject = this.singletonObjects.get(beanName);// 检查这个bean是不是null，并且这个bean不在正在创建中的bean的map缓存if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {// 从已经缓存了的单利对象集合中获取beanName对应的BeansingletonObject = this.earlySingletonObjects.get(beanName);// 如果不存在，并且允许早期引用当前创建的对象if (singletonObject == null && allowEarlyReference) {// 根据beanName获取在可以在调用时返回单例Object实例）的工厂。ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);// 如果返回的工厂不为空就把对应的beanName放到earlySingletonObjects中，并移除singletonFactories中的值if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;}
在populateBean（）将 Bean 实例对象封装,并将 Bean 定义中配置的属性值赋给对象
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {...// 获取容器在解析 Bean 定义时为 BeanDefinition设置属性的值PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);// 处理依赖注入,首先处理 autowiring 自动装配注入if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {MutablePropertyValues newPvs = new MutablePropertyValues(pvs);// Add property values based on autowire by name if applicable.// 根据 Bean 名称进行 autowiring 自动装配处理if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {autowireByName(beanName, mbd, bw, newPvs);}// Add property values based on autowire by type if applicable.// 根据 Bean 类型装配if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {autowireByType(beanName, mbd, bw, newPvs);}pvs = newPvs;}// 处理 autowiring 的属性进行注入boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);PropertyDescriptor[] filteredPds = null;if (hasInstAwareBpps) {if (pvs == null) {pvs = mbd.getPropertyValues();}for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {return;}}pvs = pvsToUse;}}}if (needsDepCheck) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}checkDependencies(beanName, mbd, filteredPds, pvs);}if (pvs != null) {applyPropertyValues(beanName, mbd, bw, pvs);}}根据名字开始注入
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {if (containsBean(propertyName)) {// 根据bean名字去又调用getBean去获取或者创建beanObject bean = getBean(propertyName);pvs.add(propertyName, bean);registerDependentBean(propertyName, beanName);if (logger.isTraceEnabled()) {logger.trace("Added autowiring by name from bean name '" + beanName +"' via property '" + propertyName + "' to bean named '" + propertyName + "'");}}...}}根据类型进行注入
protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {// 获取用户自定义的类型转换TypeConverter converter = getCustomTypeConverter();if (converter == null) {converter = bw;}// 存放解析的要注入的属性Set autowiredBeanNames = new LinkedHashSet<>(4);String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {try {// 获取指定属性名称的属性描述器PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);// Don't try autowiring by type for type Object: never makes sense,// even if it technically is a unsatisfied, non-simple property.// Object类型的属性不能进行装配if (Object.class != pd.getPropertyType()) {// 获取属性的赋值方法MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);// Do not allow eager init for type matching in case of a prioritized post-processor.// 检查指定类型是否可以被转换为目标的类型boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());// 创建一个要被注入的依赖描述DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);// 根据容器的 Bean 定义解析依赖关系,返回所有要被注入的 Bean 对象Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);if (autowiredArgument != null) {// 将属性赋值为所引用的对象pvs.add(propertyName, autowiredArgument);}for (String autowiredBeanName : autowiredBeanNames) {// 为指定名称属性注册依赖 Bean 名称,进行属性的依赖注入registerDependentBean(autowiredBeanName, beanName);if (logger.isTraceEnabled()) {logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +propertyName + "' to bean named '" + autowiredBeanName + "'");}}// 释放自己自动注入的属性autowiredBeanNames.clear();}}catch (BeansException ex) {}}} - invokeAwareMethods
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！