Spring之@RefreshScope探秘(一)

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销毁的过程

你可能感兴趣的:(Spring源码分析)