* populates the bean instance, applies post-processors, etc. * @see #doCreateBean */ protected Object createBean (String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace( "Creating instance of bean '" + beanName + "'" ); } RootBeanDefinition mbdToUse = mbd; // 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. /** * 1. 解析到 BeanDefinition 的 Class */ Class<?> resolvedClass = resolveBeanClass(mbd, beanName); /** * 2. 创建BeanDefinition 复制一份 RootBeanDefinition */ if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null ) { mbdToUse = new RootBeanDefinition (mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { /** * 3. 准备和验证 lookup-method 和 replace-method; * 注意: 这里只是标记, 真正处理是在实例化时, 选择策略生成一个CgLib的代理对象 { @link org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy} * 关于它们的作用见笔记 [[Spring lookup-method 和 replace-method.md]] */ mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException (mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed" , ex); } try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. /** * 4. 给 BeanPostProcessors 一个返回(用户自定义, 如果有AOP, 则会 用户代理 再 Spring代理)代理实例的机会; * 调用 InstantiationAwareBeanPostProcessor 的 * { @link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation(java.lang.Class, java.lang.String)} * 和 * { @link InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation(java.lang.Class, java.lang.String)} * 可以自定义创建 bean动态代理实例返回 (AOP相关) * * 见笔记: * [[BeanPostProcessor接口.md]] * [[Spring 中的AOP]] * * 注意, 这里的逻辑: * 如果其 InstantiationAwareBeanPostProcessor 返回不为null, 则直接使用这个bean实例返回了, 不走 doCreateBean等下面的流程 * (注意的注意! 如果有用户自定义的拦截创建, 甚至优先Spring的AOP代理创建) */ Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null ) { return bean; } } catch (Throwable ex) { throw new BeanCreationException (mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed" , ex); } try { /** * 继续 */ Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace( "Finished creating instance of bean '" + beanName + "'" ); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already, // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } catch (Throwable ex) { throw new BeanCreationException (
* at this point, e.g. checking { @code postProcessBeforeInstantiation} callbacks. * <p>Differentiates between default bean instantiation, use of a * factory method, and autowiring a constructor. * * 真正的 在JVM层 创建Bean实例 * * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a new instance of the bean * @throws BeanCreationException if the bean could not be created * @see #instantiateBean * @see #instantiateUsingFactoryMethod * @see #autowireConstructor * */ protected Object doCreateBean (String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null ; if (mbd.isSingleton()) { instanceWrapper = this .factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null ) { /** * 1. 真正在jvm层面实例化对象; * 1.1 如果该 BeanDefinition 有配置 instanceSupplier属性(java.util.function.Supplier), * 将使用其Supplier#get方法的返回, 作为实例对象 * 1.2 如果该 BeanDefinition 有配置 factory-method 将使用该方法返回的, 作为实例对象 * 这里这里包括'静态工厂'和'实例工厂'的处理(通过bd的factoryBeanName 进行判断, 如果存在则是'实例工厂') * 1.3 使用反射实例化, 根据策略实例化Bean对象 { @link org.springframework.beans.factory.support.SimpleInstantiationStrategy} * - 使用有参构造函数注入,创建 (new) * - 使用无参构造函数创建 (new) * - 工厂方法实例化 ('静态工厂' '实例工厂' ) * `<bean factory-bean="bookFactoryBean" factory-method="getBook()"/>` * 静态工厂: factory-bean 若是 全限定类名 则使用 BookFactoryBean::getBook 的静态方法返回的对象 * 实例工厂: factory-bean 若是 bean 名 则使用该实例方法返回的对象 * * { @link AbstractAutowireCapableBeanFactory#createBeanInstance(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])} * 2. 用BeanWrapper 包装原始bean (装饰模式) * 初始化 BeanWrapper * 2.1 给 BeanWrapper 设置了, ConversionService * 2.2 给 BeanWrapper 注册了, 当前 bean factory (propertyEditorRegistrars)中的全部 PropertyEditor * { @link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition)} * */ instanceWrapper = createBeanInstance(beanName, mbd, args); } /** * 获取 BeanWrapper中的原始 Bean 实例 */ Object bean = instanceWrapper.getWrappedInstance(); /** * 获取 Bean Class类型 */ Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { /** * 3. 处理 MergedBeanDefinitionPostProcessor 的接口回调 * 调用 添加在 context 中 BeanPostProcessor 的 MergedBeanDefinitionPostProcessor 的接口回调 * 解析到诸如` @Autowired`之类的注解 (Metadata)元信息,合并到BeanDefinition中 * * 注意在当前步骤中,只是解析,并注册(修改)到 BeanDefinition 中, 并没有调用; * * 例如: * 1. 处理 ` @Autowired` ` @Value`, ` @Inject` * 对应处理类是 `org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor` * 这个 真正处理是在填充属性时, [[回调所有 InstantiationAwareBeanPostProcessor#postProcessProperties 方法]] { @link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, org.springframework.beans.BeanWrapper)} * 负责查找相应的注解方法信息, 封装为 Metadata 元数据(使用集合存起来), 再将这些 Metadata 元数据, 注册(修改)到 BeanDefinition 中 * * 2. 处理 ` @Resource` * 对应处理类 `org.springframework.context.annotation.CommonAnnotationBeanPostProcessor` * * 3. 处理 `init-method`, ` @PostConstruct`, ` @PreDestroy` * 对应处理类 `org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor` * */ applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException (mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed" , ex); } mbd.markAsPostProcessed(); } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. /** * 判断当前: 是否单例 && 是否允许循环依赖 && 是否正在创建过程中 *(循环依赖AOP) */ boolean earlySingletonExposure = (mbd.isSingleton() && this .allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace( "Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references" ); } /** * 放到三级缓存(三级缓存 存放Lambda) * <!> 循环依赖 AOP :这里其实就是会调用到 AutoProxyCreator 在其进行判断是否需要, 最终会调用到 createProxy 进行动态代理对象创建 * { @link org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference(java.lang.Object, java.lang.String)} * */ addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { /** * 2.填充Bean属性 * 如果是AOP, pointcut, advice相关的, synthetic 会配置为 true * 1. 调用 BeanPostProcessor 的子接口 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation * (作用是 在实例化之后，属性填充之前执行操作, 可以拦截属性填充操作) */ populateBean(beanName, mbd, instanceWrapper); /** * 3.初始化Bean对象 * 1.先调用这三个 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware * 这三个是在创建BeanFactory 时忽略的三个 Aware 接口 * 2. 调用所有 BeanPostProcessors#postProcessBeforeInitialization (作用: 在Bean初始化之前调用) * 3. 调用 init-method 方法 * 4. 调用所有 BeanPostProcessors#postProcessAfterInitialization (作用: 在Bean初始化之后调用) */ exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) { throw bce; } else { throw new BeanCreationException (mbd.getResourceDescription(), beanName, ex.getMessage(), ex); } } if (earlySingletonExposure) { /** * 循环依赖AOP 相关 (循环依赖AOP) * ======================= */ /** * 再从缓存中拿一次获取并替换,是因为有可能是被代理(earlySingletonReference) */ Object earlySingletonReference = getSingleton(beanName, false ); if (earlySingletonReference != null ) { /** * (循环依赖AOP) * 注意: 这个bean是原始实例, 再从缓存中拿一次,是因为有可能是被代理(earlySingletonReference) */ if (exposedObject == bean) { // 不一致就是被代理了 exposedObject = earlySingletonReference; } else if (! this .allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet <>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException (beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example." ); } } } } // Register bean as disposable. try { /** * 注册 bean销毁的工作(如果需要) * 1. org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor#postProcessBeforeDestruction(Object,String) BPP接口 * 2. org.springframework.beans.factory.DisposableBean 接口 * 3. 自定义 destroy方法 * 在容器关闭时会调用会按这个顺序调用 */ registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException ( mbd.getResourceDescription(), beanName, "Invalid destruction signature" , ex); } * * Create a new instance for the specified bean, using an appropriate instantiation strategy: * factory method, constructor autowiring, or simple instantiation. * @param beanName the name of the bean * @param mbd the bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a BeanWrapper for the new instance * @see #obtainFromSupplier * @see #instantiateUsingFactoryMethod * @see #autowireConstructor * @see #instantiateBean * */ protected BeanWrapper createBeanInstance (String beanName, RootBeanDefinition mbd, Object[] args) { // Make sure bean class is actually resolved at this point. // 确保Class 是可以实例化的 Class<?> beanClass = resolveBeanClass(mbd, beanName); /** * 验证一下构造方法 访问修饰符 */ if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException (mbd.getResourceDescription(), beanName, "Bean class isn't public, and nonpublic access not allowed: " + beanClass.getName()); } /** * 如果该 BeanDefinition 有配置 instanceSupplier属性(java.util.function.Supplier), * 将使用其Supplier#get方法的返回, 作为实例对象 */ Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null ) { return obtainFromSupplier(instanceSupplier, beanName, mbd); } /** * 如果该 BeanDefinition 有配置 factory-method 将使用该方法的返回 作为实例对象 * 这里这里包括'静态工厂'和'实例工厂'的处理(通过bd的factoryBeanName 进行判断, 如果存在则是'实例工厂') * * 静态工厂(注意 工厂方法是static方法) * <bean id="user" class="org.yang.User" factory-method="createUser"/> * * 实例工厂(注意 工厂对象是一个实例, 使用该实例方法返回的) * <bean id="userFactory" class="org.yang.UserFactory"/> * <! -- factory-bean 指向实例工厂 Bean --> * <bean id="user" class="org.yang.User" factory-bean="userFactory" factory-method="createUser"/> * */ if (mbd.getFactoryMethodName() != null ) { return instantiateUsingFactoryMethod(beanName, mbd, args); } /** * ======================= * in short : 下面主要逻辑就是 找到一个合适的构造函数和注入方式, 然后存起来, 通过反射实例化 * 如果下次还需要就直接根据情况直接执行(仅原型Bean才有重复创建的情况) */ // Shortcut when re-creating the same bean... /** * 是否已经解析/创建过了 */ boolean resolved = false ; /** * 是否需要自动注入 */ boolean autowireNecessary = false ; if (args == null ) { synchronized (mbd.constructorArgumentLock) { /** * 类似一个缓存机制, 后面在 { @link org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)} * 解析过程中会给它赋值存起来; 下面就根据解析的情况执行 */ if (mbd.resolvedConstructorOrFactoryMethod != null ) { resolved = true ; autowireNecessary = mbd.constructorArgumentsResolved; } } } /** * 已经解析过了, 根据解析的情况, 执行 */ if (resolved) { if (autowireNecessary) { /** * 使用有参构造函数注入,创建 (new) */ return autowireConstructor(beanName, mbd, null , null ); } else { /** * 使用无参构造函数注入,创建 (new) */ return instantiateBean(beanName, mbd); } } /** * 创建Bean * ============================= */ // Candidate constructors for autowiring? /** * 从 BeanPostProcessors 里面推断构造方法 * SmartInstantiationAwareBeanPostProcessor 接口可以对 '构造方法注入的选择' 进行调整(推荐?) * { @link org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors(java.lang.Class, java.lang.String)} * */ Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); /** * 自动转配的方式, 有五种 (见 { @link org.springframework.beans.factory.config.AutowireCapableBeanFactory}的几个常量): * 1. AUTOWIRE_NO = 0; 未指定, 不注入 * 2. AUTOWIRE_BY_NAME = 1; byName * 3. AUTOWIRE_BY_TYPE = 2; byType * 4. AUTOWIRE_CONSTRUCTOR = 3; by构造 * 5. AUTOWIRE_AUTODETECT = 4;(将弃用) * */ if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { /** * 使用有参构造函数注入,创建 */ return autowireConstructor(beanName, mbd, ctors, args); } // Preferred constructors for default construction? /** * 没有找到合适的构造函数, 如果mbd有配置 首选的构造函数, 就用它 */ ctors = mbd.getPreferredConstructors(); if (ctors != null ) { return autowireConstructor(beanName, mbd, ctors, null ); } // No special handling: simply use no-arg constructor. /** * 使用无参构造函数注入,创建
if (mbd.hasPropertyValues()) { throw new BeanCreationException ( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance" ); } else { // Skip property population phase for null instance. return ; } } if (bw.getWrappedClass().isRecord()) { if (mbd.hasPropertyValues()) { throw new BeanCreationException ( mbd.getResourceDescription(), beanName, "Cannot apply property values to a record" ); } else { // Skip property population phase for records since they are immutable. return ; } } // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the // state of the bean before properties are set. This can be used, for example, // to support styles of field injection. /** * 如果是AOP, pointcut, advice相关的, synthetic 会配置为 true * 1. 调用 BeanPostProcessor 的子接口 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation * (作用是 在实例化之后，属性填充之前执行操作, 可以拦截属性填充操作) */ if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { //postProcessAfterInstantiation 返回 false , 拦截属性填充; return ; } } } /** * 包含一个或多个{ @link PropertyValue}对象的Holder，通常针对特定目标bean的一次更新 * 可以理解为: 该bean所有属性的描述 */ PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null ); /** * 获取自动注入的方式 */ int resolvedAutowireMode = mbd.getResolvedAutowireMode(); if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { /** * 2. 处理注解的 byName 或者 byType 注入的属性 * (有注解才会走这个分支) * =============================== */ MutablePropertyValues newPvs = new MutablePropertyValues (pvs); // Add property values based on autowire by name if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { /** * 通过名称注入 */ autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { /** * 通过类型注入 wsbbt.com， */ autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; yousLab.com， } /** * 3. 回调所有 InstantiationAwareBeanPostProcessor#postProcessProperties 方法 * 比如, ` @Autowired` 的处理对应实现类: { @link org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor} * (作用是: 在工厂将属性值应用到给定bean之前，对它们进行处理) * 注意这里也只是解析, 并没有设置进去, 实际赋值方法见下: { @link AbstractAutowireCapableBeanFactory#applyPropertyValues(java.lang.String, org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.BeanWrapper, org.springframework.beans.PropertyValues)} * */ if (hasInstantiationAwareBeanPostProcessors()) { if (pvs == null ) { pvs = mbd.getPropertyValues(); } for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null ) { return ; } pvs = pvsToUse; } } boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); if (needsDepCheck) { PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); checkDependencies(beanName, mbd, filteredPds, pvs); } /** * 4. 解析BeanDefinition的描述值, 反射调用 赋值 bean 属性 (将解析到的 pvs 赋值到 bw) */ if (pvs != null ) { applyPropertyValues(beanName, mbd, bw, pvs);
* <p>Called from { @link #createBean} for traditionally defined beans, * and from { @link #initializeBean} for existing bean instances. * @param beanName the bean name in the factory (for debugging purposes) * @param bean the new bean instance we may need to initialize * @param mbd the bean definition that the bean was created with * (can also be { @code null}, if given an existing bean instance) * @return the initialized bean instance (potentially wrapped) * @see BeanNameAware * @see BeanClassLoaderAware * @see BeanFactoryAware * @see #applyBeanPostProcessorsBeforeInitialization * @see #invokeInitMethods qzsxy.com，xyzdh.cn， * @see #applyBeanPostProcessorsAfterInitialization */ protected Object initializeBean (String beanName, Object bean, RootBeanDefinition mbd) { /** * 先调用这三个 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware * 这三个是在创建 BeanFactory 时忽略的三个 Aware 接口 winered.cn， * { @link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#AbstractAutowireCapableBeanFactory() } * */ invokeAwareMethods(beanName, bean); Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { /** * 调用所有 BeanPostProcessors#postProcessBeforeInitialization * (作用 在Bean初始化之前调用) njyf.com.cn， * 比如 Spring 中Aware属性的设置, 是通过这种方式扩展的 * - org.springframework.context.support.ApplicationContextAwareProcessor * 对应调用 ApplicationContextAware, EnvironmentAware, ApplicationEventPublisherAware 等Aware方法 * */ wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { /** * 调用 init-method 方法 accfj.cn，qssfzm.com， */ invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException ( (mbd != null ? mbd.getResourceDescription() : null ), beanName, ex.getMessage(), ex); } if (mbd == null || !mbd.isSynthetic()) { /** * 调用所有 BeanPostProcessors#postProcessAfterInitialization * (作用 在Bean初始化之后调用) * * - AspectJAwareAdvisorAutoProxyCreator.class * org.springframework.aop.config.internalAutoProxyCreator 对应的类有根据情况有三个可能 * InfrastructureAdvisorAutoProxyCreator.class, * AspectJAwareAdvisorAutoProxyCreator.class, * AnnotationAwareAspectJAutoProxyCreator.class
如果 beanFactory 上下文中不包含 "默认的变量解析器 (类似 PropertySourcesPlaceholderConfigurer) 解析类似 ' ${}' 这样的变量 " 则使用环境对象(ConfigurableEnvironment)中的 ConfigurablePropertyResolver实现来作为 StringValueResolver 添加进去 3. 冻结配置, 此后就不再允许更改 beanDefinition 了 4. 实例化所有剩余的 (非lazy-init) 单例 Bean 5. 处理 FactoryBean 类型的bean { DefaultListableBeanFactory#preInstantiateSingletons()} 如果该bean是 FactoryBean, 则在 bean name 前面加一个 '&' 前缀, 先获取/实例化 FactoryBean 本身; (注意一下 FactoryBean 生成对象是不遵循 Spring 的bean生命周期的) 这有两个对象, 如何获取? getBean(beanName) : 1. 传入 FactoryBean 的 name 返回的是其 getObject 的目标对象实例; 2. 如果想获取 FactoryBean 本身实例, 则前面需要加一个 '&' 前缀; 6. 尝试从当前容器 一 二 三级缓存获取 { AbstractBeanFactory#doGetBean( String , Class, Object [], boolean)} 7. 处理 AOP 代理对象生成 { AbstractAutowireCapableBeanFactory#createBean( String , RootBeanDefinition, Object [])} 8. 在JVM层面实例化对象 { AbstractAutowireCapableBeanFactory#doCreateBean( String , RootBeanDefinition, Object [])} 1. 真正在jvm层面实例化对象; 1. 如果该 BeanDefinition 有配置 instanceSupplier属性(java.util.function.Supplier),bakmk.com，zgongfu.cn 将使用其Supplier# get 方法的返回, 作为实例对象 2. 如果该 BeanDefinition 有配置 factory -method 将使用该方法返回的, 作为实例对象 这里这里包括 '静态工厂' 和 '实例工厂' 的处理(通过bd的factoryBeanName 进行判断, 如果存在则是 '实例工厂' ) 3. 使用反射实例化, 根据策略实例化Bean对象 { org.springframework.beans. factory .support.SimpleInstantiationStrategy} - 使用有参构造函数注入,创建 ( new ) - 使用无参构造函数创建 ( new ) - 工厂方法实例化 ( '静态工厂' '实例工厂' ) `<bean factory -bean= "bookFactoryBean" factory -method= "getBook()" />` 静态工厂: factory -bean 若是 全限定类名 则使用 BookFactoryBean::getBook 的静态方法返回的对象 实例工厂: factory -bean 若是 bean 名 则使用该实例方法返回的对象 2. 用BeanWrapper 包装原始bean (装饰模式) 3. 初始化 BeanWrapper 1. 给 BeanWrapper 设置了, ConversionService 2. 给 BeanWrapper 注册了, 当前 bean factory (propertyEditorRegistrars)中的全部 PropertyEditor zjtgjx.net， 3. 处理 MergedBeanDefinitionPostProcessor 的接口回调 { AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors(RootBeanDefinition, Class, String )} 调用 添加在 context 中 BeanPostProcessor 的 MergedBeanDefinitionPostProcessor 的接口回调 解析到诸如` `之类的注解 (Metadata)元信息,合并到BeanDefinition中 4. 填充Bean属性 { AbstractAutowireCapableBeanFactory#populateBean( String , RootBeanDefinition, BeanWrapper)} 1. 如果是AOP, pointcut, advice相关的, synthetic 会配置为 true 调用 BeanPostProcessor 的子接口 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation (作用是 在实例化之后，属性填充之前执行操作, 可以拦截属性填充操作) 2. 处理注解的 byName 或者 byType 注入的属性 3. 回调所有 InstantiationAwareBeanPostProcessor#postProcessProperties 方法 比如, ` ` 的处理对应实现类: { bakmk.com,org.springframework.beans. factory .annotation.AutowiredAnnotationBeanPostProcessor} (作用是: 在工厂将属性值应用到给定bean之前，对它们进行处理) 注意这里也只是解析, 并没有设置进去, 实际赋值方法见: { AbstractAutowireCapableBeanFactory#applyPropertyValues(java.lang. String , org.springframework.beans. factory .config.BeanDefinition, org.springframework.beans.BeanWrapper, org.springframework.beans.PropertyValues)} 5. 初始化Bean对象 { AbstractAutowireCapableBeanFactory#initializeBean( String , Object , RootBeanDefinition)} 1. 先调用这三个 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware { AbstractAutowireCapableBeanFactory#invokeAwareMethods( String , Object )} 这三个是在创建BeanFactory 时忽略的三个 Aware 接口 2. 调用所有 BeanPostProcessors#postProcessBeforeInitialization (作用: 在Bean初始化之前调用) { AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization( Object , String )} 3. 调用 init-method 方法 { AbstractAutowireCapableBeanFactory#invokeInitMethods( String , Object , RootBeanDefinition)} 4. 调用所有 BeanPostProcessors#postProcessAfterInitialization accfj.cn,(作用: 在Bean初始化之后调用) { AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization( Object , String )} 6. 注册 bean销毁的工作(如果需要){ AbstractBeanFactory#registerDisposableBeanIfNecessary( String , Object , RootBeanDefinition)} 1. org.springframework.beans. factory .config.DestructionAwareBeanPostProcessor#postProcessBeforeDestruction( Object , String ) BPP接口 2. org.springframework.beans. factory .DisposableBean 接口
public class WebConfigBeans { qyae.cn, private RequestMappingHandlerAdapter handlerAdapter; public void initEditableValidation () { //获得 RequestMappingHandler 中的 ConfigurableWebBindingInitializer ConfigurableWebBindingInitializer initializer = (ConfigurableWebBindingInitializer)handlerAdapter.getWebBindingInitializer(); if (initializer.getConversionService()!= null ){murnis.cn, GenericConversionService genericConversionService=(GenericConversionService)initializer.getConversionService(); //添加自定义转换器
来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/70048956/viewspace-3109296/ ，如需转载，请注明出处，否则将追究法律责任。
