springbean的生命周期简单来说就是创建bean、使用bean、销毁bean。
但是spring为了框架的拓展性,添加了更多的步骤。
实例化Bean
首先spring使用AbstractAutowireCapableBeanFactory的createBeanInstance来实例化一个初始的bean,这个bean的属性都是默认值
byte, short, int, long: 0
float, double: 0.0
char: '\u0000' (空字符)
boolean: false,
引用数据类型是null。
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 解析出bean的class对象
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());
}
//如果实现这个接口可以直接获得bean,而不是通过反射创建
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);
}
}
//获取class的构造器对象
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);
初始化
属性注入
调用set方法注入实例化时为默认值的属性(有例外)。
检查aware接口
public interface Aware {
}
可以看到Aware是一个空实现的接口,类似的还有Java的Serializable接口,他们的作用都是标识实现类。
观察Aware的实现类不难发现很多都是BeanFactory这样的与IOC容器相关的类。spring中bean分为两类,一类是自定义的bean,一类的容器自带的bean。普通的属性赋值只能赋值自定义bean,如果你想赋值容器的bean需要实现对应的Aware接口,这样子属性赋值是spring会特殊处理。
public interface BeanFactoryAware extends Aware {
/**
* Callback that supplies the owning factory to a bean instance.
* <p>Invoked after the population of normal bean properties
* but before an initialization callback such as
* {@link InitializingBean#afterPropertiesSet()} or a custom init-method.
* @param beanFactory owning BeanFactory (never {@code null}).
* The bean can immediately call methods on the factory.
* @throws BeansException in case of initialization errors
* @see BeanInitializationException
*/
void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
在invokeAwareMethods中会对实现了这种接口的类特殊处理进行注入。
BeanPostProcessor
此时bean可以说已经可以使用了,但是为了扩展性,spring提供了BeanPostProcessor来进行自定义。BeanPostProcessor提供了两个方法postProcessBeforeInitialization,postProcessAfterInitialization。这其中提到的Initialization不是指广义的初始化bean,而是特定的一个接口InitializingBean。这两个方法的意思就是在InitializingBean接口前,属性注入后或者InitializingBean接口后进行一些操作。最经典的是aop,aop的实现就使用了postProcessAfterInitialization。
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return this.wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
} else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
} else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
} else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
} else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
}
在这里创建了代理对象,还是使用cglib或者JDK。
InitializingBean
而在上面两个方法执行中间还有一步检测InitializingBean接口,如果实现了这个接口要实现afterPropertiesSet方法,可以在这里执行自定义的初始化逻辑。
比如成员变量中有一个map集合,在这个方法中可以给map赋予初始值。
@Service
public class Example implements InitializingBean {
@Autowired
private Map<Integer,Integer> map;
@Override
public void afterPropertiesSet() throws Exception {
map.put(1,1);
map.put(2,3);
}
}
到现在bean就正式创建完成了,其中循环依赖的问题下次再说,不过最好还是避免循环依赖。
接下来就是使用bean了,spring会帮你注入bean,正常使用就行。
销毁bean需要使用 调用close方法,一般不使用,不过也有相关的拓展接口DisposableBean可以定义销毁bean之前执行的逻辑。