【七】Spring源码分析之实例化Bean----AbstractAutowireCapableBeanFactory的createBean方法

一、简介

所有 Bean 实例的创建都会委托给该方法实现。

该方法其实只是做一些检查和验证工作,真正的初始化工作是由doCreateBean()实现

二、源码分析

AbstractAutowireCapableBeanFactory类的createBean方法

源码:

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		//解析bean的类型
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		//处理override method方法
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			//bean的后置处理器,如果有,这里会返回代理的实例。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);
		}

        //创建bean的实例
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}

 做了4件事:

1.resolveBeanClass方法(),解析bean的类型

2.处理override method方法。 lookup-methodreplace-method 配置,Spring统称为override method。

lookup-method可以是XML配置 ,也可以是@lookup注解,通俗的解释@lookup的使用场景是单例A中依赖注入B,这个B要是个多例,每次在A中注入的B都不是同一个B。

relace-method是方法替换

3.resolveBeforeInstantiation()方法,bean的实例化后前置处理器,如果有,这里会返回代理的实例。AOP的实现基础就是基于这里来实现的

bean的生命周期的中实现了InstantiationAwareBeanPostProcessor会在这里调用实现的postProcessBeforeInstantiation

4.创建bean的实例,交给doCreateBean()方法实现

三、创建bean的实例doCreateBean方法

源码:

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		//bean实例包装类,用于操作bean的属性
		BeanWrapper instanceWrapper = null;

        //如果是单例的话,则先把工厂bean缓存中的同名bean清除
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {

            //实际创建的交给createBeanInstance来完成,
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

        //获取BeanWrapper中封装的Object对象,其实就是bean对象的实例
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

        //获取BeanWrapper中封装的bean的Class
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;

		// 使用合并BeanDefinition的后处理器
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {

                    //bean 的生命周期之一。如果实现了MergedBeanDefinitionPostProcessor会在这里调用postProcessMergedBeanDefinition方
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		//如果RootBeanDefinition是单例的,并且开启了自动尝试解析bean之间的循环引用,并且当前bean正在创建中,则将其加入单例工厂缓存singletonFactories中,是个MAP
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		// 对已有的bean的实例初始化  一般情况下依赖注入就在这里发生
		Object exposedObject = bean;
		try {

            //填充bean的属性
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {

                //初始化bean的实例,应用工厂回调以及init方法和bean后处理器
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

        // 如果需要提前暴露该bean
		if (earlySingletonExposure) {

            // 从BeanFactory的单例缓存中获取bean的实例
			Object earlySingletonReference = getSingleton(beanName, false);

            // 如果bean工厂的 单例缓存中获取不到
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<String>(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 " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		//注册bean的销毁逻辑
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

做了7件事:

1.创建bean的实例,createBeanInstance()方法,这里得到的bean的实例还未被填充相关的属性

2.applyMergedBeanDefinitionPostProcessors()方法,如果BeanPostProcessors后置处理器实现了MergedBeanDefinitionPostProcessor接口会在这里调用后置处理器的postProcessMergedBeanDefinition方法

3. 处理是否提前暴露bean的引用(如果RootBeanDefinition是单例的,并且开启了自动尝试解析bean之间的循环引用,并且当前bean正在创建中),如果提前暴露bean的引用则将其加入单例工厂缓存singletonFactories中,加入到registeredSingletons

4:填充bean实例的属性populateBean()方法

5:初始化bean,initializeBean()方法,(初始方法前操作,调用初始化方法,执行初始化后的方法)

初始化bean的实例,应用工厂回调以及init方法和bean后处理器

6. 如果需要提前暴露,处理循环依赖

7:注册bean的销毁逻辑,registerDisposableBeanIfNecessary()方法

3.1 createBeanInstance()方法

源码:

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		// 确保 bean class 已经解析过了.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

        //如果bean的类修饰符不是public则报错
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

        // 如果beanDefinition中有工厂方法的名字
		if (mbd.getFactoryMethodName() != null)  {
            // 使用工厂方法来进行bean的实例化
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// 重新创建相同的bean时快捷方式...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {

                // 如果beanDefinition中已经解析了构造函数或工厂方法
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}

        // 如果已经解析了
		if (resolved) {
            // 如果需要自动注入
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// 需要确定构造函数,然后使用构造函数进行bean实例化
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// 没有特殊的处理,简单使用无参数构造函数。(默认构造函数)
		return instantiateBean(beanName, mbd);
	}

做了6件事:

1.resolveBeanClass方法,如果没有解析Bean的类型,则解析。

2.不是public则抛出异常

3.如果beanDefinition中有工厂方法名字,则调用instantiateUsingFactoryMethod(beanName, mbd, args)进行实例化,并返回

4.如果已经解析过构造器或工厂方法(说明这个bean是重新创建):是autowireNecessary就调用autowireConstructor(beanName, mbd, null, null)进行实例化,不是,就调用instantiateBean(beanName, mbd)进行实例化,并返回

5.由BeanPostProcessors后置处理器决定使用哪个构造器,调用autowireConstructor(beanName, mbd, ctors, args)进行实例化,并返回

6.如果前面的实例化方式都不符合,则调用instantiateBean(beanName, mbd)方法,使用无参构造器进行实例化,并返回。

3.1.1 instantiateUsingFactoryMethod方法

源码:

	protected BeanWrapper instantiateUsingFactoryMethod(
			String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {

		return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
	}

做了2件事:

1.实例化ConstructorResolver类。ConstructorResolver 是构造方法或者工厂类初始化 bean 的委托类。

2.调用 ConstructorResolver类的instantiateUsingFactoryMethod方法,使用工厂方法的方式来实例化bean。

这个方法也真的很恶心!spring不同部分的源码,代码质量和可读性真的差别很大!

总结一下,这个 instantiateUsingFactoryMehtod方法里面就是做了几件事 :

    2.1 得到FactoryBean的实例,得到FactoryBean的类,确定使用什么工厂方法,确定方法入参

    2.2 调用this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse)方法来实例化bean。

3.1.2 autowireConstructor方法

源码:

指定构造器来实例化是用该方法,autowrieNecessary也是调用该方法只是这个时候入参不用传构造器和args。

	protected BeanWrapper autowireConstructor(
			String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {

		return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
	}

做了2件事:

1.实例化ConstructorResolver

2.调用 ConstructorResolver的autowrieConstructor方法进行实例化。autowrieConstructor方法里面最终还是用的beanInstance = this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, constructorToUse, argsToUse);方法来得到bean的实例

3.1.3 instantiateBean方法

用无参构造方法注入来创建bean的实例

源码:

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			final BeanFactory parent = this;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
					@Override
					public Object run() {
						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
					}
				}, getAccessControlContext());
			}
			else {

                // 获取创建bean实例的策略,调用策略的instantiate方法进行实例化。
                // 默认的实例化策略是cglib。
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}

做了3件事:

1.获取创建bean实例的策略,默认的实例化策略是cglib。

2.调用策略的instantiate方法创建bean的实例。

3.把实例包装成BeanWrapper并且初始化一下beanWrapper的值,返回。

3.1.3.1 SimpleInstantiationStrategy类的instantiate方法

源码:

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
		// Don't override the class with CGLIB if no overrides.

        // 如果MethodOverrides为空
		if (bd.getMethodOverrides().isEmpty()) {

			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {

                // 获取bd.resolvedConstructorOrFactoryMethod已解析的构造器或工厂方法
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;

                //如果为空
				if (constructorToUse == null) {

                    // 从beanDefition中得到bean的类
					final Class<?> clazz = bd.getBeanClass();

                    // 如果是接口,则抛出异常
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
								@Override
								public Constructor<?> run() throws Exception {
									return clazz.getDeclaredConstructor((Class[]) null);
								}
							});
						}
						else {

                            // 通过bean的类clazz来得到声明的构造函数
							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
						}

                        // 并赋值回给bd.resolvedConstructorOrFactoryMethod
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}

            // 调用BeanUtils.instantiateClass(constructorToUse)方法进行实例化。
			return BeanUtils.instantiateClass(constructorToUse);
		}

        // 如果MethodOverrides不为空
		else {
			// Must generate CGLIB subclass.
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

 做了2件事:

1.如果MethodOverrides不为空,直接调用instantiateWithMethodInjection(bd,beanName,owner)方法,这会生成CGLIB的子类

2.如果MethodOverrides为空:获取bd.resolvedConstructorOrFactoryMethod已解析的构造器或工厂方法,如果为空则通过bean的类clazz来得到声明的构造函数,并赋值回给bd.resolvedConstructorOrFactoryMethod,调用BeanUtils.instantiateClass(constructorToUse)方法进行实例化。

3.2 applyMergedBeanDefinitionPostProcessors()方法

源码:

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

做了2件事:

1.得到之前注册的BeanPostProcessors后置处理器。debug出来这里有有3个

ApplicationContextAwareProcessor
ApplicationListenerDetector 
WebApplicationContextServletContextAwareProcessor

2.遍历后置处理器,找出实现了 MergedBeanDefinitionPostProcessor接口的后置处理器,执行该后置处理器的postProcessMergedBeanDefinition方法

3.4 populateBean()方法 

填充属性,把bean定义的属性填充到刚生成的bean实例中,依赖注入就发生在这里

源码:

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {

        //获取到BeanDefinition中设置的property值,封装成PropertyValues
		PropertyValues pvs = mbd.getPropertyValues();

		if (bw == null) {
			if (!pvs.isEmpty()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		boolean continueWithPropertyPopulation = true;

        // 如果BeanWrapper不为空, beandefinition不是合成Synthetic的并且有InstantiationAware后置处理器

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {

            //遍历beanPostProcessor
			for (BeanPostProcessor bp : getBeanPostProcessors()) {

                //如果该beanPostProcessor实现了InstantiationAwareBeanPostProcessor接口
				if (bp instanceof InstantiationAwareBeanPostProcessor) {

					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

 // 调用InstantiationAwareBeanPostProcessor  Bean的后置处理器,在Bean注入属性前改变BeanDefinition的信息,且可跳过后面的属性填充
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

        // 如果上面设置 continueWithPropertyPopulation = false,表明用户可能已经自己填充了
      bean 的属性,不需要 Spring 填充。直接返回
		if (!continueWithPropertyPopulation) {
			return;
		}

        // 这里取得在BeanDefinition中设置的property值,这些property来自对BeanDefinition的解析
32     // 用于在配置文件中通过<property>配置的属性并且显示在配置文件中配置了autowireMode属性
        //处理autowire的注入,根据bean的名称、类型来注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// Add property values based on autowire by name if applicable.
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// Add property values based on autowire by type if applicable.
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}

			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

		if (hasInstAwareBpps || needsDepCheck) {
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

                   //@Autowire @Resource @Value @Inject 等注解的依赖注入过程
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

        // 注入配置文件中<property>配置的属性
		applyPropertyValues(beanName, mbd, bw, pvs);
	}

 做了6件事:

1.如果传进来的BeanWrapper为空,RootBeanDefinition中的propertyValus也是空,直接返回。BeanWrapper为空,propertyValus不为空,抛出异常。

2.如果BeanWrapper不为空, beandefinition不是合成Synthetic的并且有InstantiationAware后置处理器,遍历beanPostProcessor,如果该beanPostProcessor实现了InstantiationAwareBeanPostProcessor接口,调用该后置处理器的postProcessAfterInstantiation方法

3.处理autowire的注入,根据bean的名称、类型来注入。这里取得在BeanDefinition中设置的property值,这些property来自对BeanDefinition的解析。用于在配置文件中通过<property>配置的属性并且显示在配置文件中配置了autowireMode属性

4.如果beanPostProcessor实现了InstantiationAwareBeanPostProcessor接口,调用所有InstantiationAwareBeanPostProcessor类postProcessPropertyValues方法。

这是@Autowire @Resource @Value @Inject 等注解的依赖注入过程

实际执行依赖注入逻辑的是AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues

5.如果bean需要进行依赖检查,则检测依赖。

6.applyPropertyValues方法,使用propertyValue,注入配置文件中<property>配置的属性

3.5 initializeBean()方法

初始化bean的实例,应用工厂回调以及init方法bean后处理器

源码:

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					invokeAwareMethods(beanName, bean);
					return null;
				}
			}, getAccessControlContext());
		}
		else {
        
            // 对bean设置:Aware、BeanClassLoaderAware、BeanFactoryAware
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {

            // 使用bean初始化前的后置处理器BeanPostProcessors
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {

            // 使用初始化方法(用户自定义的 init 方法)
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}

		if (mbd == null || !mbd.isSynthetic()) {

            // 使用bean初始化后的后置处理器BeanPostProcessors
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

做了4件事

1.  invokeAwareMethods方法,首先判读该bean是否实现了Aware接口,根据实现的Aware接口类型的不同(BeanNameAware、BeanClassLoaderAware、BeanFactoryAware)调用相应的方法设置进相应的参数(BeanName、BeanClassLoader、AbstractAutowireCapableBeanFactory)

2.   使用bean初始化前的后置处理器BeanPostProcessorpostProcessBeforeInitialization方法

3.  使用初始化方法

设置Bean的初始化方法有两种方法,一种是在xml或者@Bean指定init-method方法。另一种是让bean实现InitializingBean接口重写afterPropertiesSet()方法。

而这个里面的执行顺序是:先执行afterPropertiesSet()方法,再进行init-method

4.  使用bean初始化后的后置处理器BeanPostProcessorpostProcessAfterInitialization方法

  • 1
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring bean的生命周期可以分为以下阶段: 1. 实例化:通过反射或工厂方法创建对象实例。 2. 属性注入:将对象的属性值设置到bean实例中。 3. Aware回调:调用实现了Aware接口的回调方法,例如BeanNameAware、BeanFactoryAware等。 4. 初始化前回调:调用实现了InitializingBean接口或使用@Bean(initMethod="methodName")指定的初始化方法。 5. 初始化后回调:调用实现了BeanPostProcessor接口的postProcessBeforeInitialization和postProcessAfterInitialization方法。 6. 销毁前回调:调用实现了DisposableBean接口或使用@Bean(destroyMethod="methodName")指定的销毁方法。 7. 销毁后回调:调用实现了BeanPostProcessor接口的postProcessBeforeDestruction方法。 下面我们来分析一下Spring源码bean的生命周期实现过程。 首先,Spring使用BeanFactory在需要时创建bean实例。BeanFactory是一个接口,它定义了获取和管理bean的方法。在使用Spring时,通常使用其子接口ApplicationContext。 BeanFactory的实现类DefaultListableBeanFactory中,当调用getBean方法时,会根据传入的bean名称从缓存中获取bean实例,如果缓存中没有,则会调用createBean方法创建一个新的实例。 createBean方法中,首先会进行实例化,即通过反射或工厂方法创建对象实例。然后,会进行属性注入,将对象的属性值设置到bean实例中。 接下来,会调用实现了Aware接口的回调方法,例如BeanNameAware、BeanFactoryAware等。然后,会调用实现了InitializingBean接口或使用@Bean(initMethod="methodName")指定的初始化方法。 在调用初始化方法之前,会先调用实现了BeanPostProcessor接口的postProcessBeforeInitialization方法。在调用初始化方法之后,会调用实现了BeanPostProcessor接口的postProcessAfterInitialization方法。 在bean被销毁之前,会调用实现了DisposableBean接口或使用@Bean(destroyMethod="methodName")指定的销毁方法。在销毁方法之前,会先调用实现了BeanPostProcessor接口的postProcessBeforeDestruction方法。最后,销毁bean实例。 总结一下,Spring bean的生命周期主要是通过BeanFactory中的createBean方法实现的,包括实例化、属性注入、Aware回调、初始化前后回调、销毁前后回调等过程。其中,BeanPostProcessor接口的实现类可以在bean的初始化前后进行拦截和处理。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值