spring中自定义scope的代码案例和源码解读

使用spring的小伙伴都知道，一个bean实例是有其作用于的，比如：单例（singleton），多例（prototype），这些都是spring容器管理实例的一种方式，那么在spring中有没有办法按照我们自己的意愿去管理我们的实例呢？答案是肯定的，那就是spring中自定义scope。

那么如何自定义呢？

先看一个简单的bean标签：

其中我定义了一个scope=“JackScope”的自定义bean作用域，那么如何让这个作用域生效呢？

 

1、定义一个类实现BeanFactoryPostProcessor

public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        beanFactory.registerScope("jackScope",new CustomScope());
    }
}

2、定义一个类实现Scope

public class CustomScope implements Scope  {

    private ThreadLocal local = new ThreadLocal();

    /*
    * 这个方法就是自己管理bean
    * */
    @Override
    public Object get(String name, ObjectFactory objectFactory) {
        System.out.println("=============CustomScope========");
        if(local.get() != null) {
            return local.get();
        } else {
            //这个方法就是掉createbean方法获得一个实例
            Object object = objectFactory.getObject();
            local.set(object);
            return object;
        }
    }

    @Override
    public Object remove(String name) {
        return null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {

    }

    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    @Override
    public String getConversationId() {
        return null;
    }
}

在get方法中我们定义了获取bean的方法，我们定义了一个ThreadLocal，不同的用户获取到的bean的实例不一样，也就是说实例和用户绑定了，这样就不会有线程安全问题，当然这只是一个我们自己管理bean的例子，prototype也是这样的管理方式。

3、测试

public static void customScopeTest(final ApplicationContext context) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i1 = 0; i1 < 2; i1++) {
                        System.out.println(Thread.currentThread().getId() + "-->" + context.getBean("customScopeBean"));
                    }
                }
            }).start();
        }

    }

测试结果：

从测试结果来看，相同线程ID打印出来的实例的hashCode是相同的，所以达到了我们的设计预期。OK，自定义scope就搞定了，那么为什么要这么做呢？来我们看源码。

 

 1、首先为什么我们要定义一个类实现Scope接口

我们把spring源码定位到bean实例化的地方：

	protected  T doGetBean(
			final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {

		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						getBean(dep);
					}
				}

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory