生命周期图解
生命周期举例
public class BeanLifeTest implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
private String name;
public BeanLifeTest() {
System.out.println("第一步：实例化类");
}
public void setName(String name) {
System.out.println("第二步：设置属性");
this.name = name;
}
@Override
public void setBeanName(String s) {
System.out.println("第三步：设置bean的名称也就是spring容器中的名称，也就是id值" + s);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("第四步：获取工厂信息ApplicationContext");
}
//第五步执行初始化之前执行的方法
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("第六步：属性设置后执行的方法");
}
public void init() {
System.out.println("第七步：执行自己配置的初始化方法");
}
//第八步执行初始化之后执行的方法
public void start() {
System.out.println("第九步：执行自身的业务方法");
}
@Override
public void destroy() throws Exception {
System.out.println("第十步：执行spring的销毁方法");
}
public void myDestory() {
System.out.println("第十一步：执行自己配置的销毁方法");
}
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("testBeans.xml");
String[] names = applicationContext.getBeanDefinitionNames();
Arrays.stream(names).forEach(e -> System.out.println(e));
BeanLifeTest beanLifeTest = (BeanLifeTest) applicationContext.getBean("testBean");
beanLifeTest.start();
((ClassPathXmlApplicationContext) applicationContext).close();
}
}
public class MyBeanPostProcessor implements BeanPostProcessor {
//后处理bean，最重要的两步
@Override
public Object postProcessBeforeInitialization(Object bean, String s) throws BeansException {
if(bean instanceof BeanLifeTest)
System.out.println("第五步：初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String s) throws BeansException {
if(bean instanceof BeanLifeTest)
System.out.println("第八步：执行初始化之后的方法");
return bean;
}
}
ClassPathXmlApplicationContext原理
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
private Resource[] configResources;
public ClassPathXmlApplicationContext() {
}
// 如果已经有 ApplicationContext 并需要配置成父子关系，那么调用这个构造方法
public ClassPathXmlApplicationContext(ApplicationContext parent) {
super(parent);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
// 如果已经有 ApplicationContext 并需要配置成父子关系，那么调用这个构造方法
setConfigLocations(configLocations);
if (refresh) {
refresh(); //重点！！！
}
}
@Override
protected Resource[] getConfigResources() {
return this.configResources;
}
}
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 准备，记录容器的启动时间startupDate, 标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写
prepareRefresh();
// 这步比较重要(解析)，告诉子类去刷新bean工厂，这步完成后配置文件就解析成一个个bean定义，注册到BeanFactory（但是未被初始化，仅将信息写到了beanDefination的map中）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 设置beanFactory类加载器，添加多个beanPostProcesser
prepareBeanFactory(beanFactory);
try {
// 允许子类上下文中对beanFactory做后期处理
postProcessBeanFactory(beanFactory);
// 调用BeanFactoryPostProcessor各个实现类的方法
invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
registerBeanPostProcessors(beanFactory);
//初始化ApplicationContext的MessageSource
initMessageSource();
//初始化ApplicationContext事件广播器
initApplicationEventMulticaster();
// 初始化子类特殊bean（钩子方法）
onRefresh();
// 注册事件监听器
registerListeners();
// 初始化所有singleton bean 重点！！重点！！
finishBeanFactoryInitialization(beanFactory);
// 广播事件，ApplicationContext初始化完成
finishRefresh();
} catch (BeansException ex) {
}
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化名字为conversionService的bean
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));
}
// 初始化LoadTimeWeaverAware相关bean
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器进行类型匹配，置null
beanFactory.setTempClassLoader(null);
// 冻结(this.configurationFrozen = true;)所有beanDefinition，不让bean继续注册
beanFactory.freezeConfiguration();
// 实例化所有剩余的(非延迟-init)单例
beanFactory.preInstantiateSingletons();
}
//---------------------------------
// 实例化所有剩余的(非延迟-init)单例
public void preInstantiateSingletons() throws BeansException {
// 拿到所有beanName 去遍历
//获取所有bean
List beanNames = new ArrayList(this.beanDefinitionNames);
// 触发所有非懒加载的singleton bean的初始化
for (String beanName : beanNames) {
//将非RootBeanDefinition转换为RootBeanDefinition以方便后续操作，
//因为Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition
//合并bean定义
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//如果当前“不是抽象类 && 是单例 && 不是延迟加载” 则执行
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) { //判断是否factoryBean
//返回一个共享或独立的实例
final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
// ......
if (isEagerInit) {
//返回一个实例
getBean(beanName);
}
} else {
getBean(beanName);
}
}
}
//...
}
//进行实例bean的方法，调用getBean方法最后调到doGetBean
//-返回一个指定bean的实例，无论是共享或独立
protected T doGetBean(final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
//去掉beanName前的'&'，然后再拿当前beanName去别名aliasMap.get(canonicalName)取
final String beanName = transformedBeanName(name);
Object bean;
// 检查是否已创建过 ,并根据注册给定的名字返回singleton
Object sharedInstance = getSingleton(beanName);
//args为空时是获取bean，不为空是创建bean
if (sharedInstance != null && args == null) {
.........................
//返回对象bean实例，如果是(beanInstance instanceof FactoryBean)，则直接返回
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
//检查当前bean是否已被创建，是则抛异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查bean definition是否在该工厂已创建
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 没找到就去找parent容器
String nameToLookup = originalBeanName(name);
if (args != null) {
// 返回父容器(带参数)
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else {
// 不带参数
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
//typeCheckOnly为true时，将指定的bean标记为已创建，添加进Set alreadyCreated中
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//合并bean定义
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查是否Abstract，是则抛异常
checkMergedBeanDefinition(mbd, beanName, args);
// 获取依赖的bean名称
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
//然后遍历传入进行初始化
for (String dependsonBean : dependsOn) {
//判断循环依赖
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsonBean + "'");
}
registerDependentBean(dependsOnBean, beanName);
//递归获取依赖的bean
getBean(dependsOnBean);
}
}
// 接下来就到了创建一个bean实例的过程，创建单例/多例
//单例模式bean创建
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory
