feign:
    client:
     config:
       default:
         # 鏈接超時(shí)
         connectTimeout: 500
         # 讀取超時(shí)
         readTimeout: 8000

feign.client.refresh-enabled: true

public interface Scope {
    //獲取這個(gè) bean，在 BeanFactory.getBean 的時(shí)候會(huì)被調(diào)用
    Object get(String name, ObjectFactory<?> objectFactory);
    //在調(diào)用 BeanFactory.destroyScopedBean 的時(shí)候，會(huì)調(diào)用這個(gè)方法
    @Nullable
	Object remove(String name);
	//注冊(cè) destroy 的 callback
	//這個(gè)是可選實(shí)現(xiàn)，提供給外部注冊(cè)銷毀 bean 的回調(diào)?？梢栽?remove 的時(shí)候，執(zhí)行這里傳入的 callback。
	void registerDestructionCallback(String name, Runnable callback);
	//如果一個(gè) bean 不在 BeanFactory 中，而是根據(jù)上下文創(chuàng)建的，例如每個(gè) http 請(qǐng)求創(chuàng)建一個(gè)獨(dú)立的 bean，這樣從 BeanFactory 中就拿不到了，就會(huì)從這里拿
	//這個(gè)也是可選實(shí)現(xiàn)
	Object resolveContextualObject(String key);
	//可選實(shí)現(xiàn)，類似于 session id 用戶區(qū)分不同上下文的
	String getConversationId();
}

public static class TestScope implements Scope {
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        return objectFactory.getObject();
    }
    @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;
    }
}

@Configuration
public static class Config {
    @Bean
    //自定義 Scope 的名字是 testScope
    @org.springframework.context.annotation.Scope(value = "testScope")
    public A a() {
        return new A();
    }
    //自動(dòng)裝載進(jìn)來(lái)
    @Autowired
    private A a;
}

public static class A {
    public void test() {
        System.out.println(this);
    }
}

public static void main(String[] args) {
    //創(chuàng)建一個(gè) ApplicationContext
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
    //注冊(cè)我們自定義的 Scope
    annotationConfigApplicationContext.getBeanFactory().registerScope("testScope", new TestScope());
    //注冊(cè)我們需要的配置 Bean
    annotationConfigApplicationContext.register(Config.class);
    //調(diào)用 refresh 初始化 ApplicationContext
    annotationConfigApplicationContext.refresh();
    //獲取 Config 這個(gè) Bean
    Config config = annotationConfigApplicationContext.getBean(Config.class);
    //調(diào)用自動(dòng)裝載的 Bean
    config.a.test();
    //從 BeanFactory 調(diào)用 getBean 獲取 A
    annotationConfigApplicationContext.getBean(A.class).test();
    annotationConfigApplicationContext.getBean(A.class).test();
}

com.hopegaming.spring.cloud.parent.ScopeTest$A@5241cf67
com.hopegaming.spring.cloud.parent.ScopeTest$A@716a7124
com.hopegaming.spring.cloud.parent.ScopeTest$A@77192705

public static class A implements DisposableBean {
    public void test() {
        System.out.println(this);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println(this + " is destroyed");
    }
}

public static class TestScope implements Scope {
    private Runnable callback;
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        return objectFactory.getObject();
    }

    @Override
    public Object remove(String name) {
        System.out.println(name + " is removed");
        this.callback.run();
        System.out.println("callback finished");
        return null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        System.out.println("registerDestructionCallback is called");
        this.callback = callback;
    }

    @Override
    public Object resolveContextualObject(String key) {
        System.out.println("resolveContextualObject is called");
        return null;
    }

    @Override
    public String getConversationId() {
        System.out.println("getConversationId is called");
        return null;
    }
}

annotationConfigApplicationContext.getBeanFactory().destroyScopedBean("a");

public static class TestScope implements Scope {

    private final ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Runnable> callback = new ConcurrentHashMap<>();

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        System.out.println("get is called");
        return map.compute(name, (k, v) -> {
            if (v == null) {
                v = objectFactory.getObject();
            }
            return v;
        });
    }

    @Override
    public Object remove(String name) {
        this.map.remove(name);
        System.out.println(name + " is removed");
        this.callback.get(name).run();
        System.out.println("callback finished");
        return null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        System.out.println("registerDestructionCallback is called");
        this.callback.put(name, callback);
    }

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

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

public static void main(String[] args) {
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
    annotationConfigApplicationContext.getBeanFactory().registerScope("testScope", new TestScope());
    annotationConfigApplicationContext.register(Config.class);
    annotationConfigApplicationContext.refresh();
    Config config = annotationConfigApplicationContext.getBean(Config.class);
    config.a.test();
    annotationConfigApplicationContext.getBean(A.class).test();
    //Config 類中注冊(cè) Bean 的方法名稱為 a，所以 Bean 名稱也為 a
    annotationConfigApplicationContext.getBeanFactory().destroyScopedBean("a");
    config.a.test();
    annotationConfigApplicationContext.getBean(A.class).test();
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scope {
	@AliasFor("scopeName")
	String value() default "";
	@AliasFor("value")
	String scopeName() default "";
	ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
}

public enum ScopedProxyMode {
    //走默認(rèn)配置，沒有其他外圍配置則是 NO
	DEFAULT,
    //使用原始對(duì)象作為 Bean
	NO,
    //使用 JDK 的動(dòng)態(tài)代理
	INTERFACES,
    //使用 CGLIB 動(dòng)態(tài)代理
	TARGET_CLASS
}

@Configuration
public static class Config {
    @Bean
    @org.springframework.context.annotation.Scope(value = "testScope"
            //指定代理模式為基于 CGLIB
            , proxyMode = ScopedProxyMode.TARGET_CLASS
    )
    public A a() {
        return new A();
    }
    @Autowired
    private A a;
}

public static void main(String[] args) {
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
    annotationConfigApplicationContext.getBeanFactory().registerScope("testScope", new TestScope());
    annotationConfigApplicationContext.register(Config.class);
    annotationConfigApplicationContext.refresh();
    Config config = annotationConfigApplicationContext.getBean(Config.class);
    config.a.test();
    annotationConfigApplicationContext.getBean(A.class).test();
    //查看 Bean 實(shí)例的類型
    System.out.println(config.a.getClass());
    System.out.println(annotationConfigApplicationContext.getBean(A.class).getClass());
    //這時(shí)候我們需要注意，代理 Bean 的名稱有所變化，需要通過(guò) ScopedProxyUtils 獲取
    annotationConfigApplicationContext.getBeanFactory().destroyScopedBean(ScopedProxyUtils.getTargetBeanName("a"));
    config.a.test();
    annotationConfigApplicationContext.getBean(A.class).test();
}

protected RootBeanDefinition getMergedBeanDefinition(
	String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
	throws BeanDefinitionStoreException {
    //省略我們不關(guān)心的源碼
	if (!StringUtils.hasLength(mbd.getScope())) {
		mbd.setScope(SCOPE_SINGLETON);
	}
	//省略我們不關(guān)心的源碼
}

@Override
public void registerScope(String scopeName, Scope scope) {
	Assert.notNull(scopeName, "Scope identifier must not be null");
	Assert.notNull(scope, "Scope must not be null");
	//不能為 singleton 和 prototype 這兩個(gè)預(yù)設(shè)的 scope
	if (SCOPE_SINGLETON.equals(scopeName) || SCOPE_PROTOTYPE.equals(scopeName)) {
		throw new IllegalArgumentException("Cannot replace existing scopes 'singleton' and 'prototype'");
	}
	//放入 scopes 這個(gè) map 中，key 為名稱，value 為自定義 Scope
	Scope previous = this.scopes.put(scopeName, scope);
	//可以看出，后面放入的會(huì)替換前面的，這個(gè)我們要盡量避免出現(xiàn)。
	if (previous != null && previous != scope) {
		if (logger.isDebugEnabled()) {
			logger.debug("Replacing scope '" + scopeName + "' from [" + previous + "] to [" + scope + "]");
		}
	}
	else {
		if (logger.isTraceEnabled()) {
			logger.trace("Registering scope '" + scopeName + "' with implementation [" + scope + "]");
		}
	}
}

@SuppressWarnings("unchecked")
protected <T> T doGetBean(
	String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
	throws BeansException {
	//省略我們不關(guān)心的源碼
	// 創(chuàng)建 Bean 實(shí)例
    if (mbd.isSingleton()) {
    	//創(chuàng)建或者返回單例實(shí)例
    } else if (mbd.isPrototype()) {
    	//每次創(chuàng)建一個(gè)新實(shí)例
    } else {
    	//走到這里代表這個(gè) Bean 屬于自定義 Scope
    	String scopeName = mbd.getScope();
    	//必須有 Scope 名稱
    	if (!StringUtils.hasLength(scopeName)) {
    		throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
    	}
    	//通過(guò) Scope 名稱獲取對(duì)應(yīng)的 Scope，自定義 Scope 需要手動(dòng)注冊(cè)進(jìn)來(lái)
    	Scope scope = this.scopes.get(scopeName);
    	if (scope == null) {
    		throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    	}
    	try {
    		//調(diào)用自定義 Scope 的 get 方法獲取 Bean
    		Object scopedInstance = scope.get(beanName, () -> {
    			//同時(shí)將創(chuàng)建 Bean 需要的生命周期的回調(diào)傳入，用于創(chuàng)建 Bean
    			beforePrototypeCreation(beanName);
    			try {
    				return createBean(beanName, mbd, args);
    			}
    			finally {
    				afterPrototypeCreation(beanName);
    			}
    		});
    		beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    	}
    	catch (IllegalStateException ex) {
    		throw new ScopeNotActiveException(beanName, scopeName, ex);
    	}
    }
    //省略我們不關(guān)心的源碼
}

public static BeanDefinitionHolder createScopedProxy(BeanDefinitionHolder definition,
			BeanDefinitionRegistry registry, boolean proxyTargetClass) {

    //原始目標(biāo) Bean 名稱
	String originalBeanName = definition.getBeanName();
	//獲取原始目標(biāo) Bean 定義
	BeanDefinition targetDefinition = definition.getBeanDefinition();
	//獲取代理 Bean 名稱
	String targetBeanName = getTargetBeanName(originalBeanName);

    //創(chuàng)建類型為 ScopedProxyFactoryBean 的 Bean
	RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
    //根據(jù)原始目標(biāo) Bean 定義的屬性，配置代理 Bean 定義的相關(guān)屬性，省略這部分源碼
	
    //根據(jù)原始目標(biāo) Bean 的自動(dòng)裝載屬性，復(fù)制到代理 Bean 定義
	proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
	proxyDefinition.setPrimary(targetDefinition.isPrimary());
	if (targetDefinition instanceof AbstractBeanDefinition) {
		proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
	}

	//設(shè)置原始 Bean 定義為不自動(dòng)裝載并且不為 Primary
	//這樣通過(guò) BeanFactory 獲取 Bean 以及自動(dòng)裝載的都是代理 Bean 而不是原始目標(biāo) Bean
	targetDefinition.setAutowireCandidate(false);
	targetDefinition.setPrimary(false);

	//使用新名稱注冊(cè) Bean
	registry.registerBeanDefinition(targetBeanName, targetDefinition);

	return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
}

private static final String TARGET_NAME_PREFIX = "scopedTarget.";
//這個(gè)就是獲取代理 Bean 名稱的工具方法，我們上面 Destroy Bean 的時(shí)候也有用到
public static String getTargetBeanName(String originalBeanName) {
	return TARGET_NAME_PREFIX + originalBeanName;
}

public class ScopedProxyFactoryBean extends ProxyConfig
		implements FactoryBean<Object>, BeanFactoryAware, AopInfrastructureBean {
    private final SimpleBeanTargetSource scopedTargetSource = new SimpleBeanTargetSource();
    //這個(gè)就是通過(guò) SimpleBeanTargetSource 生成的實(shí)際代理，對(duì)于 Bean 的方法調(diào)用都會(huì)通過(guò)這個(gè) proxy 進(jìn)行調(diào)用
    private Object proxy;
}

public class SimpleBeanTargetSource extends AbstractBeanFactoryBasedTargetSource {
	@Override
	public Object getTarget() throws Exception {
		return getBeanFactory().getBean(getTargetBeanName());
	}
}

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()) {
			//對(duì)于 singleton
			registerDisposableBean(beanName, new DisposableBeanAdapter(
					bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
		}
		else {
			//對(duì)于自定義 Scope
			Scope scope = this.scopes.get(mbd.getScope());
			if (scope == null) {
				throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
			}
			//調(diào)用 registerDestructionCallback
			scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
					bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
		}
	}
}

@Override
public void destroyScopedBean(String beanName) {
	RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
	//僅針對(duì)自定義 Scope Bean 使用
	if (mbd.isSingleton() || mbd.isPrototype()) {
		throw new IllegalArgumentException(
				"Bean name '" + beanName + "' does not correspond to an object in a mutable scope");
	}
	String scopeName = mbd.getScope();
	Scope scope = this.scopes.get(scopeName);
	if (scope == null) {
		throw new IllegalStateException("No Scope SPI registered for scope name '" + scopeName + "'");
	}
	//調(diào)用自定義 Scope 的 remove 方法
	Object bean = scope.remove(beanName);
	if (bean != null) {
		destroyBean(beanName, bean, mbd);
	}
}