Spring BeanFactory对于含有@RefreshScope注解的bean加载
Spring BeanFactory对于Bean的加载是大致分为三种的，第一种：单例bean，Scope为Singleton，第二种：多例bean，Scope为Prototype，然后就是第三种，除上述两类的都属于第三种，其中就有Scope为refresh的bean，即被@RefreshScope注解过的bean，BeanFactory对于Scope为refresh的bean的加载代码如下：
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
分析如下：
- 1.首先根据BeanDefinition获取scopeName，然后从Scope实例列表里面获取到相应的实例，针对@RefreshScope而言，scopeName为refresh，Scope实例为RefreshScope类型的实例
- 2.接下来通过Scope的get(String name, ObjectFactory<?> objectFactory)方法获取实例，如果获取不到将会通过传递的ObjectFactory工厂对象创建一个实例（创建的具体过程这里不赘述）
RefreshScope类详解
RefreshScope是继承的GenericScope的get(String name, ObjectFactory<?> objectFactory)方法，GenericScope中会为bean做一个简单的缓存，如下：
@Override
public Object get(String name, ObjectFactory<?> objectFactory) {
BeanLifecycleWrapper value = this.cache.put(name,
new BeanLifecycleWrapper(name, objectFactory));
this.locks.putIfAbsent(name, new ReentrantReadWriteLock());
try {
return value.getBean();
}
catch (RuntimeException e) {
this.errors.put(name, e);
throw e;
}
}
分析如下：
- 1.初始化一个管理bean生命周期的BeanLifecycleWrapper实例，如果不存在这个beanName的缓存的情况下会将这个BeanLifecycleWrapper实例放入BeanLifecycleWrapperCache缓存（其实这里有点缺陷，就是并不需要每次去初始化一个BeanLifecycleWrapper实例）
- 2.如果不存在这个beanName对应的读写锁，将会初始化一个ReentrantReadWriteLock放入locks这个map集合中
- 3.通过BeanLifecycleWrapper的getBean()方法获取bean
- 4.如果有异常，先统计异常然后再重新抛出去
BeanLifecycleWrapper的getBean()
public Object getBean() {
if (this.bean == null) {
synchronized (this.name) {
if (this.bean == null) {
this.bean = this.objectFactory.getObject();
}
}
}
return this.bean;
}
其实就是通过对象创建工厂ObjectFactory创建一个新的bean（这里的双重检查锁也有点问题，bean字段并没有用volatile声明，多线程创建的话即使有某个线程创建成功了，其他线程也感知不到）
由此可见，如果BeanLifecycleWrapperCache中关于beanName的缓存的BeanLifecycleWrapper实例不变的话，那么将一直获取的是上述过程创建的bean（BeanLifecycleWrapper没有提供公开的setBean方法，因此基本不用担心BeanLifecycleWrapper缓存的bean实例被重新设置为null）
RefreshScope的refresh与refreshAll
@ManagedOperation(description = "Dispose of the current instance of bean name "
+ "provided and force a refresh on next method execution.")
public boolean refresh(String name) {
if (!name.startsWith(SCOPED_TARGET_PREFIX)) {
// User wants to refresh the bean with this name but that isn't the one in the
// cache...
name = SCOPED_TARGET_PREFIX + name;
}
// Ensure lifecycle is finished if bean was disposable
if (super.destroy(name)) {
this.context.publishEvent(new RefreshScopeRefreshedEvent(name));
return true;
}
return false;
}
@ManagedOperation(description = "Dispose of the current instance of all beans "
+ "in this scope and force a refresh on next method execution.")
public void refreshAll() {
super.destroy();
this.context.publishEvent(new RefreshScopeRefreshedEvent());
}
分析如下：
- 1.refresh专门针对某一个bean的，在成功销毁之后发推送一个针对该bean的RefreshScopeRefreshedEvent事件
- 2.refreshAll会销毁所有Scope为refresh的bean，在销毁完成之后会推送一个RefreshScopeRefreshedEvent事件
refresh bean的销毁
单个销毁
protected boolean destroy(String name) {
BeanLifecycleWrapper wrapper = this.cache.remove(name);
if (wrapper != null) {
Lock lock = this.locks.get(wrapper.getName()).writeLock();
lock.lock();
try {
wrapper.destroy();
}
finally {
lock.unlock();
}
this.errors.remove(name);
return true;
}
return false;
}
分析如下：
- 1.从BeanLifecycleWrapperCache中移除针对该bean设置的缓存
- 2.如果存在该bean的缓存，先获取到读写锁，然后加锁并执行BeanLifecycleWrapper的destroy()方法，执行完成之后解锁，移除错误列表errors中该bean对应的错误信息
全部销毁
@Override
public void destroy() {
List<Throwable> errors = new ArrayList<Throwable>();
Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();
for (BeanLifecycleWrapper wrapper : wrappers) {
try {
Lock lock = this.locks.get(wrapper.getName()).writeLock();
lock.lock();
try {
wrapper.destroy();
}
finally {
lock.unlock();
}
}
catch (RuntimeException e) {
errors.add(e);
}
}
if (!errors.isEmpty()) {
throw wrapIfNecessary(errors.get(0));
}
this.errors.clear();
}
跟单个销毁是差不多的过程，不赘述
BeanLifecycleWrapper之destroy()
public void destroy() {
if (this.callback == null) {
return;
}
synchronized (this.name) {
Runnable callback = this.callback;
if (callback != null) {
callback.run();
}
this.callback = null;
this.bean = null;
}
}
执行销毁方法，并将缓存的bean以及callback设置为null，下一次获取bean的话将会重新执行ObjectFactory的getObject()方法获取新的bean
注册销毁方法
// BeanLifecycleWrapper
public void setDestroyCallback(Runnable callback) {
this.callback = callback;
}
// GenericScope
@Override
public void registerDestructionCallback(String name, Runnable callback) {
BeanLifecycleWrapper value = this.cache.get(name);
if (value == null) {
return;
}
value.setDestroyCallback(callback);
}
// AbstractBeanFactory
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
if (mbd.isSingleton()) {
// Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
else {
// A bean with a custom scope...
Scope scope = this.scopes.get(mbd.getScope());
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
}
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}
在看到registerDisposableBeanIfNecessary这个方法时，相信看过之前写的一篇Spring bean销毁的文章的朋友会比较熟系，文章地址:Spring bean销毁的过程