前言
Spring Framework 已是公认的 Java 标配开发框架了，甚至还有人说 Java 编程就是面向 Spring 编程的，可见 Spring 在整个 Java 体系中的重要地位。
Spring 中蕴含了泛滥的性能和相干模块，比方 spring-core、spring-beans、spring-aop、spring-context、spring-expression、spring-test 等，本文先从面试中必问的问题登程，来帮你更好的学习 Spring 框架。
Spring Bean 的作用域有哪些？它的注册形式有几种？
典型答复
在 Spring 容器中治理一个或多个 Bean，这些 Bean 的定义示意为 BeanDefinition 对象，这些对象蕴含以下重要信息：
- Bean 的理论实现类
- Bean 的作用范畴
- Bean 的援用或者依赖项
Bean 的注册形式有三种：
- XML 配置文件的注册形式
- Java 注解的注册形式
- Java API 的注册形式
1. XML 配置文件注册形式
<bean id="person" class="org.springframework.beans.Person"> <property name="id" value="1"/> <property name="name" value="Java"/></bean>2. Java 注解注册形式
能够应用 @Component 注解形式来注册 Bean，代码如下：
@Componentpublic class Person { private Integer id; private String name // 疏忽其余办法}也能够应用 @Bean 注解形式来注册 Bean，代码如下：
@Configurationpublic class Person { @Bean public Person person(){ return new Person(); } // 疏忽其余办法}其中 @Configuration 可了解为 XML 配置里的 <beans> 标签，而 @Bean 可了解为用 XML 配置外面的 <bean> 标签。
3. Java API 注册形式
应用 BeanDefinitionRegistry.registerBeanDefinition() 办法的形式注册 Bean，代码如下：
public class CustomBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { } @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { RootBeanDefinition personBean = new RootBeanDefinition(Person.class); // 新增 Bean registry.registerBeanDefinition("person", personBean); }}Bean 的作用域
（1）singleton 作用域：示意在 Spring 容器中只有一个 Bean 实例，以单例的模式存在，是默认的 Bean 作用域。
配置形式，缺省即可，XML 的配置形式如下：
<bean class="..."></bean>（2）prototype 作用域：原型作用域，每次调用 Bean 时都会创立一个新实例，也就是说每次调用 getBean() 办法时，相当于执行了 new Bean()。
XML 的配置形式如下：
<bean class="..." scope="prototype"></bean>（3）request 作用域：每次 Http 申请时都会创立一个新的 Bean，该作用域仅适应于 WebApplicationContext 环境。
XML 的配置形式如下：
<bean class="..." scope="request"></bean>Java 注解的配置形式如下：
@Scope(WebApplicationContext.SCOPE_REQUEST)或是：
@RequestScope(WebApplicationContext.SCOPE_REQUEST)（4）session 作用域：同一个 Http Session 共享一个 Bean 对象，不同的 Session 领有不同的 Bean 对象，仅实用于 WebApplicationContext 环境。
XML 的配置形式如下：
<bean class="..." scope="session"></bean>Java 注解的配置形式如下：
@Scope(WebApplicationContext.SCOPE_SESSION)或是：
@RequestScope(WebApplicationContext.SCOPE_SESSION)（5）application 作用域：全局的 Web 作用域，相似于 Servlet 中的 Application。
XML 的配置形式如下：
<bean class="..." scope="application"></bean>Java 注解的配置形式如下：
@Scope(WebApplicationContext.SCOPE_APPLICATION)或是：
@RequestScope(WebApplicationContext.SCOPE_APPLICATION)考点剖析
在 Spring 中最外围的概念是 AOP（面向切面编程）、IoC（管制反转）、DI（依赖注入）等（此内容将会在下一课时中讲到），而最实用的性能则是 Bean，他们是概念和具体实现的关系。和 Bean 相干的面试题，还有以下几个：
- 什么是同名 Bean？它是如何产生的？应该如何防止？
- 聊一聊 Bean 的生命周期。
常识扩大
1.同名 Bean 问题
每个 Bean 领有一个或多个标识符，在基于 XML 的配置中，咱们能够应用 id 或者 name 来作为 Bean 的标识符。通常 Bean 的标识符由字母组成，容许应用特殊字符。
同一个 Spring 配置文件中 Bean 的 id 和 name 是不可能反复的，否则 Spring 容器启动时会报错。但如果 Spring 加载了多个配置文件的话，可能会呈现同名 Bean 的问题。同名 Bean 指的是多个 Bean 有雷同的 name 或者 id。
Spring 看待同名 Bean 的解决规定是应用最初面的 Bean 笼罩后面的 Bean，所以咱们在定义 Bean 时，尽量应用长命名非反复的形式来定义，防止产生同名 Bean 的问题。
Bean 的 id 或 name 属性并非必须指定，如果留空的话，容器会为 Bean 主动生成一个惟一的
名称，这样也不会呈现同名 Bean 的问题。
2.Bean 生命周期
对于 Spring Bean 来说，并不是启动阶段就会触发 Bean 的实例化，只有当客户端通过显式或者隐式的形式调用 BeanFactory 的 getBean() 办法时，它才会触发该类的实例化办法。当然对于 BeanFactory 来说，也不是所有的 getBean() 办法都会实例化 Bean 对象，例如作用域为 singleton 时，只会在第一次，实例化该 Bean 对象，之后会间接返回该对象。但如果应用的是 ApplicationContext 容器，则会在该容器启动的时候，立刻调用注册到该容器所有 Bean 的实例化办法。
getBean() 既然是 Bean 对象的入口，咱们就先从这个办法说起，getBean() 办法是属于 BeanFactory 接口的，它的真正实现是 AbstractAutowireCapableBeanFactory 的 createBean() 办法，而 createBean() 是通过 doCreateBean() 来实现的，具体源码实现如下：
@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; // 确定并加载 Bean 的 class Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // 验证以及筹备须要笼罩的办法 try { mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // 给BeanPostProcessors 一个机会来返回代理对象来代替真正的 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); } try { // 创立 Bean Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); }}doCreateBean 源码如下：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // 实例化 bean，BeanWrapper 对象提供了设置和获取属性值的性能 BeanWrapper instanceWrapper = null; // 如果 RootBeanDefinition 是单例，则移除未实现的 FactoryBean 实例的缓存 if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // 创立 bean 实例 instanceWrapper = createBeanInstance(beanName, mbd, args); } // 获取 BeanWrapper 中封装的 Object 对象，其实就是 bean 对象的实例 final Object bean = instanceWrapper.getWrappedInstance(); // 获取 BeanWrapper 中封装 bean 的 Class Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // 利用 MergedBeanDefinitionPostProcessor 后处理器，合并 bean 的定义信息 // Autowire 等注解信息就是在这一步实现预解析，并且将注解须要的信息放入缓存 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; } } 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"); } // 为了防止循环依赖，在 bean 初始化实现前，就将创立 bean 实例的 ObjectFactory 放入工厂缓存（singletonFactories） addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // 对 bean 属性进行填充 Object exposedObject = bean; try { populateBean(beanName, mbd, instanceWrapper); // 调用初始化办法，如 init-method 注入 Aware 对象 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 曾经被其余 bean 递归加载过，放入了提前颁布的 bean 缓存中 Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { // 如果 exposedObject 没有在 initializeBean 初始化办法中被加强 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); } } // 如果 actualDependentBeans 不为空，则示意依赖的 bean 并没有被创立完，即存在循环依赖 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."); } } } } try { // 注册 DisposableBean 以便在销毁时调用 registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject;}从上述源码中能够看出，在 doCreateBean() 办法中，首先对 Bean 进行了实例化工作，它是通过调用 createBeanInstance() 办法来实现的，该办法返回一个 BeanWrapper 对象。BeanWrapper 对象是 Spring 中一个根底的 Bean 构造接口，说它是根底接口是因为它连根本的属性都没有。
BeanWrapper 接口有一个默认实现类 BeanWrapperImpl，其次要作用是对 Bean 进行填充，比方填充和注入 Bean 的属性等。
当 Spring 实现 Bean 对象实例化并且设置完相干属性和依赖后，则会调用 Bean 的初始化办法 initializeBean()，初始化第一个阶段是查看以后 Bean 对象是否实现了 BeanNameAware、BeanClassLoaderAware、BeanFactoryAware 等接口，源码如下：
private void invokeAwareMethods(final String beanName, final Object bean) { if (bean instanceof Aware) { if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } if (bean instanceof BeanClassLoaderAware) { ClassLoader bcl = getBeanClassLoader(); if (bcl != null) { ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl); } } if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } }}其中，BeanNameAware 是把 Bean 对象定义的 beanName 设置到以后对象实例中；BeanClassLoaderAware 是将以后 Bean 对象相应的 ClassLoader 注入到以后对象实例中；BeanFactoryAware 是 BeanFactory 容器会将本身注入到以后对象实例中，这样以后对象就会领有一个 BeanFactory 容器的援用。
初始化第二个阶段则是 BeanPostProcessor 加强解决，它次要是对 Spring 容器提供的 Bean 实例对象进行无效的扩大，容许 Spring 在初始化 Bean 阶段对其进行定制化批改，比方解决标记接口或者为其提供代理实现。
在初始化的前置解决实现之后就会检查和执行 InitializingBean 和 init-method 办法。
InitializingBean 是一个接口，它有一个 afterPropertiesSet() 办法，在 Bean 初始化时会判断以后 Bean 是否实现了 InitializingBean，如果实现了则调用 afterPropertiesSet() 办法，进行初始化工作；而后再查看是否也指定了 init-method，如果指定了则通过反射机制调用指定的 init-method 办法，它的实现源码如下：
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable { // 判断以后 Bean 是否实现了 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(); // 属性初始化 } } // 判断是否指定了 init-method() 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); } }}初始化实现之后就能够失常的应用 Bean 对象了，在 Spring 容器敞开时会执行销毁办法，然而 Spring 容器不会主动去调用销毁办法，而是须要咱们被动的调用。
如果是 BeanFactory 容器，那么咱们须要被动调用 destroySingletons() 办法，告诉 BeanFactory 容器去执行相应的销毁办法；如果是 ApplicationContext 容器，那么咱们须要被动调用 registerShutdownHook() 办法，告知 ApplicationContext 容器执行相应的销毁办法。
注：本课时源码基于 Spring 5.2.2.RELEASE。总结
本文讲了 Bean 的三种注册形式：XML、Java 注解和 JavaAPI，以及 Bean 的五个作用域：singleton、prototype、request、session 和 application；还讲了读取多个配置文件可能会呈现同名 Bean 的问题，以及通过源码讲了 Bean 执行的生命周期，它的生命周期如下图所示：
本文由mdnice多平台公布