Spring框架中RefreshScope注解如何实现Bean的热替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RestController
class MessageRestController {
    @Autowired
    private Config config;
    ...
}

@Data
@RefreshScope
//@Configuration
@Component
public class Config {
    @Value("${message:Hello default}")
    private String message;
  	...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// spring boot
SpringApplication.run	
	refreshContext
		// AbstractApplicationContext
		refresh
		    // Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory)
				// PostProcessorRegistrationDelegate
				invokeBeanFactoryPostProcessors
				    // postProcessor
					postProcessBeanDefinitionRegistry(registry)
					    // ConfigurationClassPostProcessor
						processConfigBeanDefinitions(registry)
							// ConfigurationClassParser
							parse
								processConfigurationClass
									doProcessConfigurationClass
										// Process any @ComponentScan annotations
										// sourceClass 此时为加了@SpringBootApplication main方法启动类
										Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
												sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
										if (!componentScans.isEmpty() &&
												!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
											for (AnnotationAttributes componentScan : componentScans) {
												// The config class is annotated with @ComponentScan -> perform the scan immediately
												// 加载所有@Configuration,@Service, @Component, @Repository, @Controller注解的类
												Set<BeanDefinitionHolder> scannedBeanDefinitions =
														this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
												// Check the set of scanned definitions for any further config classes and parse recursively if needed
												for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
													if (ConfigurationClassUtils.checkConfigurationClassCandidate(
															holder.getBeanDefinition(), this.metadataReaderFactory)) {
															// 处理 @Configuration 中的bean定义
															parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
													}
												}
											}
										}								
		    
		    ...
		 
		    // bean的实例化
			finishBeanFactoryInitialization

1
2
3
4
5
6
7
8
9
10
static BeanDefinitionHolder applyScopedProxyMode(
			ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {

		ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
		if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
			return definition;
		}
		boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public static BeanDefinitionHolder createScopedProxy(BeanDefinitionHolder definition,
			BeanDefinitionRegistry registry, boolean proxyTargetClass) {

		String originalBeanName = definition.getBeanName();
		BeanDefinition targetDefinition = definition.getBeanDefinition();
		String targetBeanName = getTargetBeanName(originalBeanName);

		// Create a scoped proxy definition for the original bean name,
		// "hiding" the target bean in an internal target definition.
		RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
		proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
		proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
		proxyDefinition.setSource(definition.getSource());
		proxyDefinition.setRole(targetDefinition.getRole());

		proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
		if (proxyTargetClass) {
			targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
			// ScopedProxyFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
		}
		else {
			proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
		}

		// Copy autowire settings from original bean definition.
		proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
		proxyDefinition.setPrimary(targetDefinition.isPrimary());
		if (targetDefinition instanceof AbstractBeanDefinition) {
			proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
		}

		// The target bean should be ignored in favor of the scoped proxy.
		targetDefinition.setAutowireCandidate(false);
		targetDefinition.setPrimary(false);

		// Register the target bean as separate bean in the factory.
		registry.registerBeanDefinition(targetBeanName, targetDefinition);

		// Return the scoped proxy definition as primary bean definition
		// (potentially an inner bean).
		return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@WriteOperation
	public Collection<String> refresh() {
		Set<String> keys = this.contextRefresher.refresh();
		return keys;
	}

// 逐步进入this.scope.refreshAll()
public void refreshAll() {
		super.destroy();
		this.context.publishEvent(new RefreshScopeRefreshedEvent());
	}

@Override
	public void destroy() {
		List<Throwable> errors = new ArrayList<Throwable>();
    // 删除全量scopedTarget.bean
		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();
				}
			}
      ...
		}
    ...
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Data
@RefreshScope
//@Configuration
@Component
public class Config {
    @Value("${message:Hello default}")
    private String message;

    public Config() {
        System.out.println("hi new instance for Config!");
        try {
            throw new RuntimeException("hi");
        } catch (RuntimeException ex) {
            ex.printStackTrace();
        }
    }
}

@RestController
class MessageRestController {
    @Autowired
    private Config config;

    @RequestMapping("/message")
    String getMessage() {
        return config.getMessage();
    }
}