spring清除无效sse

文章目录

• 前言
• 一、Spring的Bean是什么？
• 二、Bean的生命周期

• 1.实例化
• 2.回调Aware接口
• 3.执行初始化

• 3.1 BeanPostProcessor的前置处理
• 3.2 初始化方法
• 3.3 BeanPostProcessor的后置处理

• 4.销毁

• 总结

---

前言

对于做java开发的程序员来说，spring技术栈已作为必须要掌握，熟知的内容，无论是在工作还是面试中，特别是去大厂进行面试时，更是必问的问题，本系列文章主要从源码级别来探秘spring的工作原理以及所使用的设计模式。

---

本篇文章主要探讨Spring的重要组件Bean，包含Bean的创建、使用以及销毁过程。

一、Spring的Bean是什么？

在Spring的官方介绍中，有这样一句话： “In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container.” 翻译过来就是：在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。 从这段介绍中可以提取出一下几点信息：

1、bean也是一种对象

2、bean被spring 的ioc容器管理

二、Bean的生命周期

本文的主要代码在以下这个类中 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

1.实例化

以下为实例化Bean对象时，所调用的方法

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		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 non-public access not allowed: " + beanClass.getName());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// Candidate constructors for autowiring?
		// 
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}

2.回调Aware接口

Spring中提供了Aware接口，用于在Bean的实例化过程中回调获取IOC容器各种属性。

private void invokeAwareMethods(final String beanName, final Object bean) {
		if (bean instanceof Aware) {
			// 设置BeanName
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			// 设置Bean的ClassLoader 类加载器
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			// 设置Bean工厂，通过BeanFactory可以获取所有的Bean
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}

3.执行初始化

3.1 BeanPostProcessor的前置处理

Spring的重要扩展点BeanPostProcessor ——Bean的后置处理器接口，后面会专门写文章来介绍这个接口。下面这个方法就是获取所有的BeanPostProcessor然后执行其postProcessBeforeInitialization 方法。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

3.2 初始化方法

下面为Bean创建过程中，执行的初始化方法的过程
从方法的执行中可以看出先判断bean是否实现了 InitializingBean 接口，然后再执行自定义的初始化方法。

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
		// 执行InitializingBean 的初始化方法afterPropertiesSet
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}
		// 自定义的Bean初始化方法
		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

3.3 BeanPostProcessor的后置处理

AOP发生在该阶段，后续会详细介绍。

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

4.销毁

实现了DisposableBean接口获取自定义的destory方法，在Bean销毁时会调用该方法。

总结

上述的过程可以总结为以下的一张图：

Spring的Bean的生命周期大概可以总结为以上的过程，希望大家在阅读的过程中，可以提出批评指正。

---

一个苟且偷生的混子