Spring中的Bean对象初始化详解

 更新时间:2023年12月01日 10:06:47   作者:军伟@  
这篇文章主要介绍了Spring中的Bean对象初始化详解,我们也可以根据Java语言的特性猜测到其很有可能是通过反射机制来完成Bean的初始化操作,接下来我们一步一步的剖析Spring对Bean的初始化操作,需要的朋友可以参考下

Bean对象初始化详解

即使我们在不了解Spring对bean的初始化机制,我们也可以根据Java语言的特性猜测到其很有可能是通过反射机制来完成Bean的初始化操作

接下来我们一步一步的剖析Spring对Bean的初始化操作。

首先Spring会通过调用 getBean(String name)来获取Bean,在获取bean的过程中完成的Bean的初始化操作。

AbstractBeanFactory类中:

@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

在doGetBean方法中会判断bean的类型单例、原型,如果是单例则需要判断是否已经初始化bean并添加到缓存中,如果是原型bean则需要重新初始化bean,由于Spring对beanName提供了别名机制,所有需要通过beanName获取最终的bean名称。

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
		//查找name是否有别名,获取最终的beanName
		final String beanName = transformedBeanName(name);
		Object bean;
		//如果bean是单例模式,首先尝试从缓存中获取
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			//会判断bean是否是FactoryBean,如果不是直接返回sharedInstance,否则调用sharedInstance.getObject()方法返回bean
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		else {
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			//判断容器是否有服容器,如果有则首先尝试从父容器中获取
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}
			try {
				//根据beanName获取bean的元数据
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						getBean(dep);
					}
				}
				// bean是单例
				if (mbd.isSingleton()) {
					//获取bean,首先会暴露一个ObjectFactory,通过调用getObject来调用createBean(beanName, mbd, args)获取bean
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
								//
								return createBean(beanName, mbd, args);
							}
							catch (BeansException ex) {
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					//会判断bean是否是FactoryBean,如果不是直接返回sharedInstance,否则调用sharedInstance.getObject()方法返回bean
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//bean是原型
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						//初始化bean
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				//bean是其他模式
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								beforePrototypeCreation(beanName);
								try {
									return createBean(beanName, mbd, args);
								}
								finally {
									afterPrototypeCreation(beanName);
								}
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}
		//省略代码..........
		return (T) bean;
	}

接下来我们看看在createBean(String beanName, RootBeanDefinition mbd, Object[] args)中进行的处理操作,在createBean中会通过BeanDefinition中获取类名resolvedClass(反射机制重要的一个参数),并且会调用resolveBeforeInstantiation在bean初始的过程中做一些预处理(简单来说就是BeanPostProcessor的实现类所做的处理操作

AbstractAutowireCapableBeanFactory:

@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;
		//获取类名,通过反射机制来实例化类
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			//设置类名
			mbdToUse.setBeanClass(resolvedClass);
		}
		// Prepare method overrides.
		try {
			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.
			//如果bean想要在初始化后使用之前做一些预处理操作
			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;
	}

doCreateBean中完成的处理操作就比较多了,简单来说调用了几个方法完成了bean的初始化操作:

createBeanInstance完成通过构造函数初始化bean的操作;

addSingletonFactory完成将初始化的bean提前暴露出去,这样就解决了单例bean非构造函数的循环引用问题;

populateBean完成bean的属性注入操作,通过set方法或者注解注入属性;

initializeBean完成了bean注入时设置的init-method方法的执行,同时在执行init-method之前会调用applyBeanPostProcessorsBeforeInitialization完成bean使用前的处理操作,调用applyBeanPostProcessorsAfterInitialization完成bean初始化后的操作;

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//初始化bean实例
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
		//将初始化的bean提前暴露出去,暴露一个ObjectFactory,这也是Spring解决单例bean非构造函数依赖的解决方法
		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);
				}
			});
		}
		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			//初始化bean的各种注入或者setXX参数
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				//调用注入类的init-method方法
				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);
			}
		}
		//
		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}
		return exposedObject;
	}

createBeanInstance中会通过bean的构造函数或者默认构造函数来完成bean的初始化工作。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		//省略代码.............
		if (resolved) {
			if (autowireNecessary) {
				//通过构造函数初始化
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				//使用默认构造函数初始化
				return instantiateBean(beanName, mbd);
			}
		}
		// Need to determine the constructor...
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}
		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}

instantiateBean中会调用bean初始策略InstantiationStrategy的实现类完成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初始化策InstantiationStrategy略初始化bean
				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);
		}
	}

调用InstantiationStrategy的instantiate方法完成初始化操作。

SimpleInstantiationStrategy(InstantiationStrategy实现类)

@Override
	public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
		// Don't override the class with CGLIB if no overrides.
		if (bd.getMethodOverrides().isEmpty()) {
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					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 {
							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			//最终在BeanUtils中完成bean的初始化操作
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// Must generate CGLIB subclass.
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

最终我们发现bean的初始化操作是在BeanUtils中完成的,通过反射机制完成Bean的初始化操作。

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			ReflectionUtils.makeAccessible(ctor);
			//通过反射机制初始化bean
			return ctor.newInstance(args);
		}
		catch (InstantiationException ex) {
			throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
		}
		catch (IllegalAccessException ex) {
			throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
		}
		catch (IllegalArgumentException ex) {
			throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
		}
		catch (InvocationTargetException ex) {
			throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
		}
	}

总结

简单来说Spring对bean的初始化操作就是根据反射机制通过构造函数进行初始化的。

接下来我们再用一篇介绍一下bean的属性注入相关的操作。

到此这篇关于Spring中的Bean对象初始化详解的文章就介绍到这了,更多相关Bean对象初始化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • Java之操作Redis案例讲解

    Java之操作Redis案例讲解

    这篇文章主要介绍了Java之操作Redis案例讲解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-08-08
  • 详解Mybatis(五)Mapper接口

    详解Mybatis(五)Mapper接口

    这篇文章主要介绍了Mybatis Mapper接口,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-04-04
  • Java实现AES加密和解密方式完整示例

    Java实现AES加密和解密方式完整示例

    这篇文章主要给大家介绍了关于Java实现AES加密和解密方式的相关资料,AES加密为最常见的对称加密算法,是一种区块加密标准,这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用,需要的朋友可以参考下
    2023-10-10
  • SpringBoot解决mysql连接8小时问题

    SpringBoot解决mysql连接8小时问题

    服务连接mysql数据库,8小时没有数据库的操作时候,数据库会主动断开连接释放资源,本文就详细的介绍一下解决方法,感兴趣的可以了解一下
    2023-08-08
  • 使用IDEA配置Tomcat和连接MySQL数据库(JDBC)详细步骤

    使用IDEA配置Tomcat和连接MySQL数据库(JDBC)详细步骤

    这篇文章主要介绍了使用IDEA配置Tomcat和连接MySQL数据库(JDBC)详细步骤,本文通过图文并茂的形式给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-12-12
  • java使用ArrayList遍历及效率比较实例分析

    java使用ArrayList遍历及效率比较实例分析

    这篇文章主要介绍了java使用ArrayList遍历及效率比较,实例分析了ArrayList遍历的方法与使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2015-07-07
  • Mybatis-Plus开发提速器mybatis-plus-generator-ui详解

    Mybatis-Plus开发提速器mybatis-plus-generator-ui详解

    这篇文章主要介绍了Mybatis-Plus开发提速器mybatis-plus-generator-ui,本文简要介绍一款基于Mybatis-Plus的代码自助生成器,文章通过实例集成的方式来详细讲解mybatis-plus-generator-ui,从相关概念到实际集成案例,以及具体的扩展开发介绍,需要的朋友可以参考下
    2022-11-11
  • java连接MySQL数据库的代码

    java连接MySQL数据库的代码

    这篇文章主要为大家详细介绍了java连接MySQL数据库的相关代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-10-10
  • MyBatis-Plus如何最优雅最简洁地完成数据库操作

    MyBatis-Plus如何最优雅最简洁地完成数据库操作

    Mybatis-Plus是一个 Mybatis 的增强工具,在 Mybatis 的基础上只做增强不做改变,为简化开发、提高效率而生,下面这篇文章主要给大家介绍了关于MyBatis-Plus如何最优雅最简洁地完成数据库操作的相关资料,需要的朋友可以参考下
    2022-03-03
  • java实现员工工资管理系统

    java实现员工工资管理系统

    这篇文章主要为大家详细介绍了java实现员工工资管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-02-02

最新评论