spring-bean-生命周期有哪些步骤

Spring-bean生命周期有哪些步骤呢？步骤包含spring对bean的加载，解析，创建，销毁等

在java代码中一切bean都是对象，但是不一定所有的对象都是bean。

Bean的创建

狭义

class---new beanClass--填充属性-aware--初始化--aop--放入单例池

广义

class--beanDefinition--beanFactoryPostProcessor---new beanClass--填充属性-aware--初始化--aop--放入单例池

为什么要要加入beanDefinition和beanFactoryPostProcessor，因为beanDefinition和beanFactoryPostProcessor通过修改beanClass可以影响bean的最终实例，所以这里修改会影响bean的创建，那么bean的生命周期固然包含。

bean生命周期

• 原生bean-class
• 先将原生bean转化为BeanDefinition
• 实例化bean-new bean()
• 填充属性（构造参数）
• Aware
• 初始化
• AOP
• 将bean放到单例池中
• DefaultListableBeanFactory的

1、思考：在bean转化为beanDefinition时，在生成实例对象之前。这中间的过程中都是将bean转化为bean的定义，为什么呢。

（1）因为beanDefinition里面包含很多属性，这些属性可以理解为就是原生bean上面定义的注解等，这个时候spring需要将这些注册转化为beanDefinition。

（2）例如在beanDefinition变成new User的过程中，将beanClass进行修改，那么spring容器实例化bean的时候，就会直接实例new User，而并不会实例替换之前的beanClass。

2、由1上面的（2）中，这里就引入了BeanFactoryPostProcessor（BeanFactory后处理器）

假如说在BeanFactoryPostProcessor中对某个BeanDefinition（beanClass进行修改），那么在beanFactory实例化bean的时候就变成了修改后的new beanClass。

@Component
public class WolfBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //beanFactory 这里我可以拿到一个bean工厂
        GenericBeanDefinition beanDefinition = (GenericBeanDefinition) beanFactory.getBeanDefinition("wolfBean");
        System.out.println("beanDefinition.getBeanClass():" + beanDefinition.getBeanClass());
        beanDefinition.setBeanClass(SunBean.class);//这里由WolfBean修改为SunBean
    }
}


System.out.println("wolfBean:"+annotation.getBean("wolfBean"));
在最终输出控制台
wolfBean:SunBean{name='null'}
//最终的bean已经变成了SunBean

 

本基于注解进行学习和分析

先看看beanfactory什么时候初始化的？

在初始化AnnotationConfigApplicationContext时，会自动去实例化父类的构造函数GenericApplicationContext

其中类GenericApplicationContext的无参构造函数

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
    private final DefaultListableBeanFactory beanFactory;
    @Nullable
    private ResourceLoader resourceLoader;
    private boolean customClassLoader;
    private final AtomicBoolean refreshed;

    public GenericApplicationContext() {
        this.customClassLoader = false;
        this.refreshed = new AtomicBoolean();
        this.beanFactory = new DefaultListableBeanFactory();//默认实现
    }

}

FactoryBean

@Component
public class WolfFactoryBean implements FactoryBean {

    @Override
    public Object getObject() throws Exception {
        return new UserMapper() {
            @Override
            public boolean selectUserIsExits(String userId) {
                return false;
            }
        };
    }

    @Override
    public Class<?> getObjectType() {
        return UserMapper.class;
    }
}

这个功能跟

//注册一个bean到beanFactory
beanFactory.registerSingleton("god",new Dog());一样

BeanDefinition（bean定义）

关于bean定义相关属性讲解，单独一篇文章来讲

ImportBeanDefinitionRegistrar

将beanDefinition注册到beanFactory的beanDefinitionMap中，这步是在beanFactory初始化完毕之前完成

//导入自己定义的beanDefinition导入到bean-factory的beanDefinitionMAP中
public class WolfBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        System.out.println("导入beanDefinition");
        List<Class> mapperClasses = new ArrayList<>();
        mapperClasses.add(OrderMapper.class);
        mapperClasses.add(UserMapper.class);
        for(Class cls:mapperClasses){
            BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
            AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
            beanDefinition.setBeanClass(WolfFactoryBean.class);
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(cls);
            registry.registerBeanDefinition(cls.getSimpleName(),beanDefinition);
        }
    }
}

如何调整灵活，通过包扫描的方式

在配置类中需要添加导入

@Import(WolfBeanDefinitionRegistrar.class)需要导入spring容器才会进行处理

BeanPostProcessor(Bean后置处理器)

当bean对象实例化完成后，执行

BeanFactory（bean工厂）

beanFactory = new DefaultListableBeanFactory()

bean工厂组建完成，可以理解为spring通过包扫描或者xml加载等方式，将所有的bean都扫描完毕，并根据bean上面的定义生成了beanDefinition，这个存在

DefaultListableBeanFactory
Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);//中

这个仅仅只是完成了对bean定义的生成（BeanDefinition）。

BeanFactoryPostProcessor(BeanFactory后置处理器)

等beanFactory初始化完成后，操作bean工厂；【在设计上，主要对扩展开放，对修改关闭】

@Component
public class WolfBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //beanFactory 这里我可以拿到一个bean工厂
        GenericBeanDefinition beanDefinition = (GenericBeanDefinition) beanFactory.getBeanDefinition("wolfBean");
        System.out.println("beanDefinition.getBeanClass():" + beanDefinition.getBeanClass());
        WolfBean wolfBean = beanFactory.getBean("wolfBean",WolfBean.class);
        beanDefinition.setBeanClass(SunBean.class);
        //注册一个bean到beanFactory
        beanFactory.registerSingleton("god",new Dog());
    }
}

通过这个可以发现，如果第三方插件或者工具要将其自己的bean来交给spring-beanFactory进行管理，那么就可以通过beanfactory.registerSingleton来。

 

DefaultListableBeanFactory

defaultListableBeanFactory是spring-bean加载的核心部分，是spring注册及加载bean的默认实现。

其中DefaultListableBeanFactory还包含一些子类

（1）XmlBeanFactory

基于xml读取器XmlBeanDefinitionReader实现了读取功能；

 

BeanFactory和ApplicationContext的区别

 

初始化

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	if(System.getSecurityManager() != null) {
		AccessController.doPrivileged(() -> {
			this.invokeAwareMethods(beanName, bean);
			return null;
		}, this.getAccessControlContext());
	} else {
        //回调Aware
		this.invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if(mbd == null || !mbd.isSynthetic()) {
		wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
	}

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

	if(mbd == null || !mbd.isSynthetic()) {
		wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

//
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
    //看看其是不是实现了InitalizingBean接口，如果是就可以调用其实现接口
	boolean isInitializingBean = bean instanceof InitializingBean;
	if(isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if(this.logger.isTraceEnabled()) {
			this.logger.trace("Invoking afterPropertiesSet() on bean with name \'" + beanName + "\'");
		}

		if(System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged(() -> {
					((InitializingBean)bean).afterPropertiesSet();
					return null;
				}, this.getAccessControlContext());
			} catch (PrivilegedActionException var6) {
				throw var6.getException();
			}
		} else {
            //这里最终调用了bean的afterPropertiesSet方法
			((InitializingBean)bean).afterPropertiesSet();
		}
	}

	if(mbd != null && bean.getClass() != NullBean.class) {
		String initMethodName = mbd.getInitMethodName();
		if(StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
			this.invokeCustomInitMethod(beanName, bean, mbd);
		}
	}

}

 

Aware相当于一种回调，是spring一种回调机制。

AbstractAutowireCapableBeanFactory

initializeBean->invokeAwareMethods->invokeAwareMethods实现

 //beanNameAware
if(bean instanceof BeanNameAware) {
        ((BeanNameAware)bean).setBeanName(beanName);
    }
    //BeanClassLoaderAware
    if(bean instanceof BeanClassLoaderAware) {
        ClassLoader bcl = this.getBeanClassLoader();
        if(bcl != null) {
            ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
        }
    }
    //BeanFactoryAware
    if(bean instanceof BeanFactoryAware) {
        ((BeanFactoryAware)bean).setBeanFactory(this);
    }

applicationA

以下为在bean里面，要知道spring给我的当前bean定义的名称是什么，可以通过实现BeanNameAware接口，在spring-bean初始化完毕后就会调用

ApplicationContextAwareProcessor

private void invokeAwareInterfaces(Object bean) {
	if(bean instanceof EnvironmentAware) {
		((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
	}

	if(bean instanceof EmbeddedValueResolverAware) {
		((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
	}

	if(bean instanceof ResourceLoaderAware) {
		((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
	}

	if(bean instanceof ApplicationEventPublisherAware) {
		((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
	}

	if(bean instanceof MessageSourceAware) {
		((MessageSourceAware)bean).setMessageSource(this.applicationContext);
	}

	if(bean instanceof ApplicationContextAware) {
		((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
	}

}

//方法实现
private void invokeAwareMethods(String beanName, Object bean) {
   if(bean instanceof Aware) {
    //beanNameAware
	if(bean instanceof BeanNameAware) {
		((BeanNameAware)bean).setBeanName(beanName);
	}
    //BeanClassLoaderAware
	if(bean instanceof BeanClassLoaderAware) {
		ClassLoader bcl = this.getBeanClassLoader();
		if(bcl != null) {
			((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
		}
	}
    //BeanFactoryAware
	if(bean instanceof BeanFactoryAware) {
		((BeanFactoryAware)bean).setBeanFactory(this);
	}
}
}

例如
public interface BeanNameAware extends Aware {
    void setBeanName(String var1);
}

@Service
@AllArgsConstructor
public class EatService implements BeanNameAware {

    private EatDao eatDao;

    public void showEat() {
        System.out.println("我吃的是，那个啥啥");
        eatDao.save();
    }

    //这个由spring-bean初始化的时候调用
    @Override
    public void setBeanName(String s) {
        System.out.println("eatService-Name:" + s);
    }
}