【spring】创建Bean的方法：createBean源码分析

最新推荐文章于 2024-04-08 07:53:04 发布
最新推荐文章于 2024-04-08 07:53:04 发布
阅读量532 收藏 1
点赞数
分类专栏： spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35436158/article/details/123080133
版权

createBean简单介绍

  • 本文源码基于spring-framework-5.3.10。
  • 这个方法有Bean的一大半生命周期

createBean的核心流程

  • 实例化前：InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
  • 实例化：推断构造方法
  • 后置处理合并后的BeanDefinition：MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
  • 实例化后：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
  • 属性赋值，自动注入（@Autowired、@Resource、@Value）：InstantiationAwareBeanPostProcessor.postProcessProperties()
  • 回调：Aware对象
  • 初始化前：BeanPostProcessor.postProcessBeforeInitialization()
  • 初始化
  • 初始化后：BeanPostProcessor.postProcessAfterInitialization()

源码分析

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

	// 日志打印
	if (logger.isTraceEnabled()) {
		logger.trace("Creating instance of bean '" + beanName + "'");
	}
	// 使用的BeanDefinition
	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.
	// 马上就要实例化Bean了，确保beanClass被加载了
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	// Bean被加载，并且当前BeanDefinition的beanClass属性不是class类型，并且对应的BeanNam不是Null
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		// 重新定义一个BeanDefinition。这里之前的BeanClass属性是字符串！
		mbdToUse = new RootBeanDefinition(mbd);
		// 把上面实例化的Bean设置进去
		mbdToUse.setBeanClass(resolvedClass);
	}

	// Prepare method overrides.
	// 这里主要处理@Lookup注解，进行方法的替代！
	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.
		// 实例化前
		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 {
		// spring本身的实例化
		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(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

确保Bean被加载的方法：resolveBeanClass源码分析

protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
		throws CannotLoadBeanClassException {

	try {
		// 校验当前BeanDefinition的beanClass属性是Bean的名字还是Bean的class信息：如果beanClass被加载了（beanClass的类型是class），直接返回
		if (mbd.hasBeanClass()) {
			return mbd.getBeanClass();
		}

		// 如果beanClass没有被加载，进行Bean的加载
		if (System.getSecurityManager() != null) {
			return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
					() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
		}
		else {
			return doResolveBeanClass(mbd, typesToMatch);
		}
	}
	catch (PrivilegedActionException pae) {
		ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
		throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
	}
	catch (ClassNotFoundException ex) {
		throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
	}
	catch (LinkageError err) {
		throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
	}
}

真正的创建方法:doResolveBeanClass源码分析

private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
		throws ClassNotFoundException {
	// 得到当前Bean的类加载器
	ClassLoader beanClassLoader = getBeanClassLoader();
	// 定义一个动态的类加载器。有临时类加载器用临时类加载器，没有临时类加载器用现在这个
	ClassLoader dynamicLoader = beanClassLoader;
	// 表示RootBeanDefinition的配置的bean类名需要重新被dynameicLoader加载的标记，默认不需要
	boolean freshResolve = false;

	// 进行类型匹配
	if (!ObjectUtils.isEmpty(typesToMatch)) {
		// When just doing type checks (i.e. not creating an actual instance yet),
		// use the specified temporary class loader (e.g. in a weaving scenario).
		// 一个临时的类加载器，用于类型的匹配校验
		ClassLoader tempClassLoader = getTempClassLoader();
		// 解析的值不一样，走下面的逻辑
		if (tempClassLoader != null) {
			// 吧当前的类加载器赋值给动态类加载器
			dynamicLoader = tempClassLoader;
			// 标记当前的RootBeanDefinition需要被dynamicLoader解析
			freshResolve = true;
			// 他是spring自定义的DecoratingClassLoader类加载器
			if (tempClassLoader instanceof DecoratingClassLoader) {
				// 类加载器强转
				DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
				// 类型匹配！
				for (Class<?> typeToMatch : typesToMatch) {
					dcl.excludeClass(typeToMatch.getName());
				}
			}
		}
	}

	// 获取className：beanClass是名称直接返回，是class返回class对应的Name
	String className = mbd.getBeanClassName();
	if (className != null) {
		// 解析Spring表达式，有可能直接返回了一个Class对象
		Object evaluated = evaluateBeanDefinitionString(className, mbd);
		// 表达式解析的类型不一致
		if (!className.equals(evaluated)) {
			// A dynamically resolved expression, supported as of 4.2...
			// 4.2支持动态的类型。能得到class类型直接返回
			if (evaluated instanceof Class) {
				return (Class<?>) evaluated;
			}
			// 得到的是字符串
			else if (evaluated instanceof String) {
				// BeanName赋值
				className = (String) evaluated;
				// 标记当前的RootBeanDefinition需要被dynamicLoader解析
				freshResolve = true;
			}
			else {
				// 除了class类型和字符串，其他的直接抛异常
				throw new IllegalStateException("Invalid class name expression result: " + evaluated);
			}
		}
		// 类没有被加载的时候，进行加载
		if (freshResolve) {
			// When resolving against a temporary class loader, exit early in order
			// to avoid storing the resolved Class in the bean definition.
			// 类加载器不能为空！
			if (dynamicLoader != null) {
				try {
					// 返回用dynamicLoader具体的类加载器加载类，得到class对象
					return dynamicLoader.loadClass(className);
				}
				catch (ClassNotFoundException ex) {
					if (logger.isTraceEnabled()) {
						logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
					}
				}
			}
			// 加载数组，String，基本类型
			return ClassUtils.forName(className, dynamicLoader);
		}
	}

	// Resolve regularly, caching the result in the BeanDefinition...
	// 定期解析，将结果缓存在BeanDefinition中。可以通过AbstractBeanDefinition#getBeanClass来获取缓存
	return mbd.resolveBeanClass(beanClassLoader);
}

创建Bean使用的类加载器信息

/**
 * 获取类加载器信息的方法
 */
public ClassLoader getBeanClassLoader() {
	return this.beanClassLoader;
}

// 使用的类加载器信息
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

/**
 * 初始化类加载器的方法
 */
public static ClassLoader getDefaultClassLoader() {
	ClassLoader cl = null;

	// 优先获取线程中的类加载器。通过Thread.currentThread().setContextClassLoader(cl)进行设置
	try {
		cl = Thread.currentThread().getContextClassLoader();
	}
	catch (Throwable ex) {
		// Cannot access thread context ClassLoader - falling back...
	}

	// 线程中类加载器为null的情况下，获取加载ClassUtils类的类加载器
	if (cl == null) {
		// No thread context class loader -> use class loader of this class.
		// 使用和ClassUtils相同的类加载器。简单理解就是和spring-core包放的位置有关系
		cl = ClassUtils.class.getClassLoader();
		if (cl == null) {
			// getClassLoader() returning null indicates the bootstrap ClassLoader
			// 加入ClassUtils是被Bootstrap类加载器加载的，则获取系统类加载器。（jre/lib目录下）
			try {
				cl = ClassLoader.getSystemClassLoader();
			}
			catch (Throwable ex) {
				// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
			}
		}
	}
	return cl;
}

实例化前:resolveBeforeInstantiation源码分析

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	// 如果当前还没有进行实例化钱的操作
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// Make sure bean class is actually resolved at this point.
		// synthetic表示合成，如果某些Bean式合成的，那么则不会经过BeanPostProcessor的处理。并且他有实例化前的实现：。并且把所有的InstantiationAwareBeanPostProcessor、SmartInstantiationAwareBeanPostProcessor、DestructionAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor加入到BeanPostProcessorCache，判断加入后有没有InstantiationAwareBeanPostProcessor。
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 得到class类型
			Class<?> targetType = determineTargetType(beanName, mbd);
			// 得到的class类型不为null
			if (targetType != null) {
				// 循环调用每个postProcessBeforeInstantiation方法，直到有返回值（自己去实例化），或者执行完返回null（让spring去实例化）
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				// 如果其中一个有返回值，循环调用每个postProcessAfterInitialization方法，直到有一个返回值为null（没有实例化成功）。否则返回具体的值（自己实例化成功）。这里主要是为了Bean的AOP
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		// bean有值说明实例化成功，下次的这个判断不会进来，否则会继续执行
		mbd.beforeInstantiationResolved = (bean != null);
	}
	// 返回当前的处理过的Bean
	return bean;
}

spring本身的实例化方法

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

	// 实例化bean
	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	// 这个Bean是单例的
	if (mbd.isSingleton()) {
		// 有可能在本Bean创建之前，就有其他Bean把当前Bean给创建出来了（比如依赖注入过程中）。factoryBean需要重新创建
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 创建Bean实例：推断构造方法，@Bean的处理
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 得到Bean对象
	Object bean = instanceWrapper.getWrappedInstance();
	// 得到Bean的类型
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 后置处理合并后的BeanDefinition（MergedBeanDefinitionPostProcessor）：比如可以进行初始化方法的设置，比如添加属性值。spring友谊个默认的实现去寻找注入点。
	// Allow post-processors to modify the merged bean definition.
	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;
		}
	}

	// 为了解决循环依赖提前缓存单例创建工厂
	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	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");
		}
		// 循环依赖-添加到三级缓存
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		// 属性填充
		populateBean(beanName, mbd, instanceWrapper);  //getBean()

		// 初始化:包括三个回调以及初始化前中后
		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);
		}
	}

	// 第二次处理循环依赖问题
	if (earlySingletonExposure) {
		// 从一级、二级缓存中获取Bean
		Object earlySingletonReference = getSingleton(beanName, false);
		// 获取到了
		if (earlySingletonReference != null) {
			// 是当前Bean，放入二级缓存
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				// beanName被哪些bean依赖了，现在发现beanName所对应的bean对象发生了改变，那么则会报错
				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.
	// 处理Bean销毁前要执行的方法
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

属性填充：populateBean源码分析

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	// Bean不存在的时候，直接返回或者抛异常
	if (bw == null) {
		// 有依赖的属性，抛异常
		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;
		}
	}

	// 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.
	// 实例化后，属性设置之前。循环调用每个实现postProcessAfterInstantiation的方法
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
				return;
			}
		}
	}

	// 得到所有的属性值
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	// 依赖注入的逻辑
	int resolvedAutowireMode = mbd.getResolvedAutowireMode();
	// 这个判断是spring自带的依赖注入逻辑。可以在@Bean上配置autowire属性配置ByName或者ByType（已过期）
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		// MutablePropertyValues是PropertyValues具体的实现类
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		// Add property values based on autowire by name if applicable.
		// ByName找的是set方法，比如setXxxxx就会找xxxx，setName就会找Name
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		// Add property values based on autowire by type if applicable.
		// ByType找的是set方法，从Bean中找到当前类型的入参，进行传入
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}

	// 获取是否有实现InstantiationAwareBeanPostProcessor的方法，这里主要使用postProcessProperties方法。
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// 获取是否需要进行依赖注入
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	PropertyDescriptor[] filteredPds = null;
	if (hasInstAwareBpps) {
		// 属性为空，获取需要注入的信息
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			// 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值。真正的处理@Autowired、@Resource、@Value注解
			// AutowiredAnnotationBeanPostProcessor内部并不会处理pvs。直接返回自己设置的PropertyValues对象（可以在实例化前设置）。
			PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
			// 这里的含义是程序员自己已经给属性赋值了，就不需要Spring给他赋值。这里是程序员没有赋值，所以需要Spring进行赋值
			if (pvsToUse == null) {
				// 第一次进来一般为空
				if (filteredPds == null) {
					filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
				}
				// 和postProcessProperties类似，但是已经过期了
				pvsToUse = bp.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);
	}

	// 如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终将是PropertyValues中的值，覆盖@Autowired
	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

初始化逻辑：initializeBean源码分析

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	// 这里主要进行了三个Aware回调
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;

	// 初始化前：主要的实现有初始化方法@postconstruct，很多的Aware回调都在初始化前
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	// 初始化：
	try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}

	// 初始化后：aop
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

private void invokeAwareMethods(String beanName, Object bean) {
	// 实现了Aware以及其子类
	if (bean instanceof Aware) {
		// BeanNameAware回调
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		// BeanClassLoaderAware回调
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		// BeanFactoryAware回调
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

结束语

  • 获取更多本文的前置知识文章，以及新的有价值的文章，让我们一起成为架构师！
  • 关注公众号，可以让你对MySQL、并发编程、spring源码有深入的了解！
  • 关注公众号，后续持续高效的学习JVM！
  • 这个公众号，无广告！！！每日更新！！！
    作者公众号.jpg
程序java圈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Bean生命周期源码篇
qq_43649937的博客
04-26 1741
这里先对AOP进行简单的介绍AOP （AspectOrient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
03-Spring之Bean生命周期源码解析上
future-wy
09-09 283
Spring核心IOC（对象创建）、AOP，而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。 Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的 Bean生命周期流程图 Bean的生成过程 1. 生成BeanDefinition Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathS.
Spring Bean的生命周期——Create Bean源码解析
只会写bug的靓仔的博客
04-05 1472
if (!try {在Bean实例化后、属性填充前，执行Bean定义的后处理器。
Spring Bean的生命周期源码详解 - 【Spring底层原理】
最新发布
2401_84166896的博客
04-08 918
单例池就是已经实例化好的对象我就放进去，我要用的时候直接从池子里面拿，不用再实例化一遍，这时候从单例池中get，所有的对象第一次实例化都要过来这里，第一次单例池里面肯定是没有的。其实这里有个比较重要的知识点，解决循环依赖的三级缓存，这里提一下，后面会专门出文章讲解循环依赖，有疑惑的伙伴可以跳过，只要知道可以用来创建bean就可以了。在doCreateBean这个方法中，完成了bean的实例化，属性注入和初始化，bean的实例化就是在createBeanInstance方法执行的。
【Spring】Spring之Bean生命周期源码解析
持续学习，坚持原创，分享技术笔记及经验。
07-28 629
Spring之Bean生命周期源码解析
Spring之Bean生命周期源码解析
su1177的博客
04-26 669
实例化自动注入Aware对象初始化。
Spring Bean实例化实现过程解析
08-25
例如，在 com.itheima.instance.static_factory 包中，我们定义了一个静态工厂类 MyBean2Factory，该类提供了一个静态方法 createBean，该方法用于创建 Bean2 实例。 然后，在 beans2.xml 文件中，我们定义了一个 ...
Spring bean对象实例化实现过程图解
08-18
Spring Bean 对象实例化实现过程图解...Spring Bean 对象实例化实现过程图解是一个复杂的过程，需要了解 BeanDefinitionRegistryPostProcessor 接口、BeanPostProcessor 的注册、getSingleton 方法、createBean 方法和 ...
spring学习源码笔记
11-21
在`instantiateBean(...)`方法中，Spring会根据实例化策略（如无参构造函数、工厂方法等）来创建bean实例，并在适当的时候应用`BeanPostProcessor`。 通过深入理解Spring的源码，我们可以更好地掌握其内部工作原理...
Spring 源码（14）Spring Bean 的创建过程（5）.doc
07-13
首先，我们回顾一下Spring Bean的创建流程：`getBean` -> `doGetBean` -> `createBean` -> `doCreateBean`。在`doCreateBean`阶段，Spring会使用反射来创建Bean实例。反射创建Bean的一个关键点是确定适当的构造函数...
图解Spring源码之循环依赖
01-20
文章目录准备工作关闭循环依赖开始调试AbstractBeanFactory#doGetBeangetSingleton(String beanName, ObjectFactory singletonFactory)AbstractAutowireCapableBeanFactory#createBean(beanName, mbd, args)...
二、Spring源码分析——BeanFactory
08-11
NULL 博文链接：https://ylxy3058.iteye.com/blog/2223489
【源码解析】Spring Bean生命周期源码解析
秋装什么的博客
05-29 663
【源码解析】Spring Bean生命周期源码解析
Spring之bean生命周期源码解析
2201_75955594的博客
12-21 279
Spring源码解析之getBean()方法底层实现
spring bean的生命周期源码解析
北诗
04-09 608
源码分析Spring IOC与Bean的生命周期什么是Ioc(控制反转)/DI(依赖注入)？Bean的生命周期源码分析 说在前面：spring的源码极其庞大，虽然这里我们只讨论bean的生命周期，所谓生命周期就是一个普通对象走完了spring为它设置好的“陷阱”，其实就是一系列函数改变这个对象，函数一环扣一环，希望大家耐心看第一次看可能会有些吃力，所以跟着debug会比较好，我这里只讲关于IOC和...
五、SpringBoot对静态资源的映射规则
weixin_38780073的博客
01-20 193
1.所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找资源； ​ webjars：以jar包的方式引入静态资源； webjars官网 访问地址：http://localhost:8080/webjars/jquery/3.3.1/dist/jquery.js 2."/**" 访问当前项目的任何资源，都去静态资源的文件夹...
Spring Bean生命周期源码解析
zhao6406879的博客
05-07 329
介绍 目前大部分的 Java 互联网项目，都是用 Spring作为基础框架，管理bean，融合其他框架。Spring Bean生命周期和我们日常开发密不可分，我们虽然可能不太了解原理，但每天都会用，且作为面试的重点、重灾区，让我们一探究竟。 我们众知的Spring Bean生命周期包含实例化、填充属性、初始化，这也是狭义上的Bean生命周期。 由于Spring Bean生命周期源内容较多，本文以较粗的粒度剖析源码，从spring启动到bean创建完成的过程，其他细节内容后期专门讲解。 源码解析 容器启动与包
Spring doCreateBean 方法解析
技术人员
10-11 698
大纲理解 先通过反射创建实例 再给属性赋值 调用相关初始化方法 首先看下doGetBean的方法 /** * 返回一个Bean * * Return an instance, which may be shared or independent, of the specified bean. * @param name the name of the bean to retrieve
Spring bean生命周期 源码分析一下
05-23
下面我们来分析一下Spring源码中bean的生命周期实现过程。 首先，Spring使用BeanFactory在需要时创建bean实例。BeanFactory是一个接口，它定义了获取和管理bean的方法。在使用Spring时，通常使用其子接口...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值