afredlyj
commented
8 years ago Spring Bean的生命周期
有必要自己通过查看源码，辅助网友的分析资料，梳理Spring Bean的生命周期。下文的分析围绕下图：
需要注意的是，以下分析的是lazyinit属性设为false，且单例的Bean（这个过程，称为预实例化），其他的Bean则会在getBean时才会初始化。两者的区别仅仅在于处罚的时间和场景不同，同样是调用容器的getBean方法。
Spring的ApplicationContext的启动入口在AbstractApplicationContext#refresh方法，接下来需要分析的是finishBeanFactoryInitialization方法，这个方法用于加载非lazy-init的单例bean：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}重点在于beanFactory.preInstantiateSingletons()，在这个方法执行前，会调用freezeConfiguration冻结配置。Spring默认的BeanFactory是DefaultListableBeanFactory。在preInstantiateSingletons中，会遍历定义的beanDefinitionNames获取要加载的bean，加载之前会判断BeanDefinition是否符合加载要求，然后调用getBean方法：
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 判断是否需要实例化
} else {
// 普通bean直接调用getBean方法
getBean(beanName);
}
}
}在实例化Bean前，会分析它依赖的Bean，然后调用createBean实例化，该方法是抽象方法，由子类AbstractAutowireCapableBeanFactory实现：
// AbstractBeanFactory.java
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
getBean(dependsOnBean);
registerDependentBean(dependsOnBean, beanName);
}
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
在实例化Bean时，如果该类由无参构造函数，则调用构造函数实例化，否则使用CGLIB。回到AbstractAutowireCapableBeanFactory#doCreateBean中，接下来会干两件事：装配依赖和Bean初始化：
try {
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}Bean的初始化，如果Bean实现了相关的Aware接口，则会相继调用set方法，有BeanNameAware#setBeanName、BeanClassLoaderAware#setBeanClassLoader和BeanFactoryAware#setBeanFactory.
// AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
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);
}
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
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) {
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
throws Throwable {
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
public Object run() throws Exception {
((InitializingBean) bean).afterPropertiesSet();
return null;
}
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null) {
String initMethodName = mbd.getInitMethodName();
if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}接着会看到invokeInitMethods方法的调用，该方法会调用InitializingBean#afterPropertiesSet方法，该方法同样是对Bean的回调，最后判断Bean是否配置了initMethod，如果有，则通过invokeCustomInitMethod直接调用，完成Bean的初始化。
总的来说，IOC容器中的Bean生命周期，包括如下几个阶段：
- Bean实例创建
- 为Bean实例设置属性
- 调用Bean的初始化方法
- 应用可以通过IOC容器使用Bean
- 当容器关闭时，调用Bean的销毁方法
随后遍历BeanFactory中定义的BeanPostProcessor，在调用Bean初始化方法前，调用postProcessBeforeInitialization，初始化后调用postProcessAfterInitialization。
而初始化方法invokeInitMethods先执行InitializingBean#afterPropertiesSet，随后执行BeanDefinition#initMethodName。初始化过程完成之后，会注册Bean的销毁方法。
参考文档：
Spring MVC 学习笔记
Spring MVC 初始化
要构建一个基于web容器的Spring MVC项目，需要关注一下Spring MVC的基本要素：
在web.xml中指定入口程序
配置业务bean
通过
DispatcherServlet的contextConfigLocation指定核心配置文件xml的路径，这些bean的生命周期将由Spring容器管理。编写控制层代码
业务代码示例如下：
DispatcherServlet
DispatcherServlet属于Spring MVC的核心模块，属于控制器的重要组成部分，另外一部分是开发的业务控制器。默认配置
DispatcherServlet有一系列的默认配置bean，具体的列表可以参考DispatcherServlet.properties文件，需要注意的是，这些默认配置是可以覆盖的。Root WebApplicationContext vs Servlet WebApplicationContext
在Spring中，
ApplicationContext是有作用域的，每个DispatcherServlet都有自己的WebApplicationContext，称为Servlet WebApplicationContext，这些context都从Root WebApplicationContext继承而来，如果DispatcherServlet就有两个不同的context，如果只需要一个context，可以将DispatcherServlet的contextConfigLocation设为空。这两个context的关系，可以参考1和2。ContextLoaderListener
ContextLoaderListener用来启动和关闭Root WebApplicationContext。DelegatingFilterProxy
http://jinnianshilongnian.iteye.com/blog/1752171
Shiro
AuthenticatingRealm
Shiro中Realm的子类，作用类似数据源。AuthenticatingRealm判断认证是否通过，即判断用户名和密码是否正确，需要由子类实现抽象方法
doGetAuthenticationInfo：doGetAuthenticationInfo方法根据传入的参数查询本地数据源的用户信息，本地数据源可以是文件、缓存或数据库，具体查询逻辑由子类实现，之后返回AuthenticationInfo对象。如果查询成功，则会调用CredentialsMatcher#doCredentialsMatch判断用户名&密码是否正确，Shiro内置了几个CredentialsMatcher，比如SimpleCredentialsMatcher：简单地判断密码是否正确。
ShiroFilterFactoryBean
ShiroFilterFactoryBean对象用来创建SpringShiroFilter，各个属性解释如下：DefaultFilter类，获取默认filter配置：拿登录过程来说，如果通过Filter 完成登录业务，
FormAuthenticationFilter代码如下：当请求的url和
loginUrl匹配时，如果当前是POST请求，则执行登录业务逻辑，比如验证密码和账号状态判断，否则直接穿透到下一个流程，进入SpringMVC。注解@PostConstruct
@PostConstruct是Java EE 5引入的注解，Spring允许开发者在受管Bean中使用它。当DI容器实例化当前受管Bean时，@PostConstruct注解的方法会被自动触发，从而完成一些初始化工作，一个bean中只有一个方法能使用本注解。