Spring Cloud（十三）：Spring 扩展

来源：宝玛科技网

Spring扩展点
- Bean的生命周期中的BeanPostProcessor扩展点
- Spring扩展点梳理
Spring扩展点应用场景
- 整合Nacos 服务注册
  - ApplicationListener扩展场景——监听容器中发布的事件
  - Lifecycle Nacos 发布订阅 & Eureka 服务启动、同步、剔除
  - Lifecycle扩展场景——管理具有启动、停止生命周期需求的对象
- 整合Nacos 发布订阅 NacosWatch
- 整合Eureka 注册
  - 扩展： Eureka Server端上下文的初始化是在SmartLifecycle#start中实现的
- 整合Ribbon
  - SmartInitializingSingleton扩展场景—— 对容器中的Bean对象进行定制处理
- 整合Feign
  - FactoryBean的扩展场景——将接口生成的代理对象交给Spring管理
- 整合sentinel
  - HandlerInterceptor扩展场景——对mvc请求增强
  - SmartInitializingSingleton&FactoryBean结合场景——根据类型动态装配对象
- 整合seata
  - AbstractAutoProxyCreator&MethodInterceptor结合场景——实现方法增强

Spring扩展点

Bean的生命周期中的BeanPostProcessor扩展点

Spring扩展点梳理

BeanFactoryPostProcessor
- BeanDefinitionRegistryPostProcessor
  - postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) # 注册Bean 定义
BeanPostProcessor
- InstantiationAwareBeanPostProcessor
  - postProcessBeforeInstantiation
  - postProcessAfterInstantiation
  - postProcessProperties
  - postProcessPropertyValues
- AbstractAutoProxyCreator
  - postProcessAfterInitialization # 实例化之后AOP支持
@Import
- ImportBeanDefinitionRegistrar
  - registerBeanDefinitions
- ImportSelector
  - String[] selectImports(AnnotationMetadata importingClassMetadata)
  - default Predicate getExclusionFilter() { return null;}
Aware
- ApplicationContextAware
  - setApplicationContext(ApplicationContext applicationContext)
- BeanFactoryAware
  - setBeanFactory(BeanFactory beanFactory)
InitializingBean || @PostConstruct
FactoryBean (动态创建Bean)（&beanName factoryBean.getObject | beanName beanFactory.getBean）(Mybatis#mapper、Openfeign)
- T getObject() throws Exception;
- Class<?> getObjectType();
- default boolean isSingleton() { return true; }
SmartInitializingSingleton Bean
- void afterSingletonsInstantiated(); # 初始化之后调用过滤器…
ApplicationListener
- void onApplicationEvent(E event);
Lifecycle
- SmartLifecycle
  - default boolean isAutoStartup() { return true; }
  - default void stop(Runnable callback)
- LifecycleProcessor
HandlerInterceptor
- default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
- default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception
- default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable Exception ex) throws Exception
MethodInterceptor
- Object invoke(MethodInvocation invocation) throws Throwable;

Spring扩展点应用场景

整合Nacos 服务注册

ApplicationListener扩展场景——监听容器中发布的事件

NamingService -> NacosNamingService => registerInstance

思考：为什么整合Nacos注册中心后，服务启动就会自动注册，Nacos是如何实现自动服务注册的？

Tomcat启动之后，在ServletWebServerApplicationContext中，发布事件 ServletWebServerInitializedEvent
spring-cloud-commons 包 AbstractAutoServiceRegistration 监听 WebServerInitializedEvent

public abstract class AbstractAutoServiceRegistration<R extends Registration>
		implements AutoServiceRegistration, ApplicationContextAware,
		ApplicationListener<WebServerInitializedEvent> {

	public void onApplicationEvent(WebServerInitializedEvent event) {
		bind(event); // .... register();
	}
}

Nacos 实现ServiceRegistry.register

Lifecycle Nacos 发布订阅 & Eureka 服务启动、同步、剔除

Lifecycle扩展场景——管理具有启动、停止生命周期需求的对象

start => AbstractApplicationContext.refresh -> finishRefresh() -> getLifecycleProcessor().onRefresh(); -> start()

整合Nacos 发布订阅 NacosWatch

public class NacosWatch
		implements ApplicationEventPublisherAware, SmartLifecycle, DisposableBean {


	@Override
	public void start() {
			...
			NamingService namingService = nacosServiceManager
					.getNamingService(properties.getNacosProperties());
			try {
				namingService.subscribe(properties.getService(), properties.getGroup(),
						Arrays.asList(properties.getClusterName()), eventListener);
			}
			catch (Exception e) {
				log.error("namingService subscribe failed, properties:{}", properties, e);
			}

			this.watchFuture = this.taskScheduler.scheduleWithFixedDelay(
					this::nacosServicesWatch, this.properties.getWatchDelay());
		}
	}

}

整合Eureka 注册

扩展： Eureka Server端上下文的初始化是在SmartLifecycle#start中实现的

EurekaServerInitializerConfiguration

整合Ribbon

SmartInitializingSingleton扩展场景—— 对容器中的Bean对象进行定制处理

所有的单例bean实例化之后调用

思考：为什么@Bean修饰的RestTemplate加上@LoadBalanced就能实现负载均衡功能？

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

LoadBalancerAutoConfiguration
对SmartInitializingSingleton的扩展，为所有用@LoadBalanced修饰的restTemplate（利用了@Qualifier 限定符）绑定实现了负载均衡逻辑的LoadBalancerInterceptor

@LoadBalanced
@Autowired(required = false)
private List<RestTemplate> restTemplates = Collections.emptyList();

@Bean
public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
		final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
	return () -> restTemplateCustomizers.ifAvailable(customizers -> {
		for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
			for (RestTemplateCustomizer customizer : customizers) {
				customizer.customize(restTemplate);
			}
		}
	});
}

/**
 * Annotation to mark a RestTemplate or WebClient bean to be configured to use a
 * LoadBalancerClient.
 * @author Spencer Gibb
 */
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Qualifier //Qualifier
public @interface LoadBalanced {
}

LoadBalancerInterceptor

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
	static class LoadBalancerInterceptorConfig {

		@Bean
		public LoadBalancerInterceptor loadBalancerInterceptor(
				LoadBalancerClient loadBalancerClient,
				LoadBalancerRequestFactory requestFactory) {
			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
		}

		@Bean
		@ConditionalOnMissingBean
		public RestTemplateCustomizer restTemplateCustomizer(
				final LoadBalancerInterceptor loadBalancerInterceptor) {
			return restTemplate -> {
				List<ClientHttpRequestInterceptor> list = new ArrayList<>(
						restTemplate.getInterceptors());
				list.add(loadBalancerInterceptor);
				restTemplate.setInterceptors(list);
			};
		}

	}

整合Feign

FactoryBean的扩展场景——将接口生成的代理对象交给Spring管理

思考：为什么Feign接口可以通过@Autowired直接注入使用？Feign接口是如何交给Spring管理的？

@FeignClient(value = "order-service", path = "/order")
public interface OrderFeignService {

    @GetMapping(value = "/info/{productId}")
    public String findOrderInfoByProductId(@PathVariable("productId") Integer productId);
}

@SpringBootApplication
@EnableFeignClients(basePackages = "com.mx.use.feign")
@EnableHystrix
@EnableHystrixDashboard //开启 Hystrix 监控功能
public class OrderServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
	...
}

FactoryBean => FeignClientsRegistrar -> scan(FeignClient) -> registerFeignClient -> FeignClientFactoryBean

@Override
public Object getObject() {
	return getTarget(); //
}

整合sentinel

HandlerInterceptor扩展场景——对mvc请求增强

AbstractSentinelInterceptor#preHandle

public abstract class AbstractSentinelInterceptor implements HandlerInterceptor {
    ...
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
        try {
            String resourceName = getResourceName(request);

            if (StringUtil.isEmpty(resourceName)) {
                return true;
            }
            
            if (increaseReferece(request, this.baseWebMvcConfig.getRequestRefName(), 1) != 1) {
                return true;
            }
            
            // Parse the request origin using registered origin parser.
            String origin = parseOrigin(request);
            String contextName = getContextName(request);
            ContextUtil.enter(contextName, origin);
            //Sentinel入口
            Entry entry = SphU.entry(resourceName, ResourceTypeConstants.COMMON_WEB, EntryType.IN);
            request.setAttribute(baseWebMvcConfig.getRequestAttributeName(), entry);
            return true;
        } catch (BlockException e) {
            try {
                handleBlockException(request, response, e);
            } finally {
                ContextUtil.exit();
            }
            return false;
        }
    }
    ...
}

SmartInitializingSingleton&FactoryBean结合场景——根据类型动态装配对象

SentinelDataSourceHandler

#Sentinel持久化读数据源设计，利用了SmartInitializingSingleton扩展点
SentinelDataSourceHandler#afterSingletonsInstantiated
# 注册一个FactoryBean类型的数据源 
》SentinelDataSourceHandler#registerBean
》》NacosDataSourceFactoryBean#getObject
# 利用FactoryBean获取到读数据源
》》new NacosDataSource(properties, groupId, dataId, converter)

NacosDataSourceFactoryBean

public class NacosDataSourceFactoryBean implements FactoryBean<NacosDataSource> {
	...
	@Override
	public NacosDataSource getObject() throws Exception {
		...
		return new NacosDataSource(properties, groupId, dataId, converter);
	}
	...
}