Spring 高级话题
1. Spring Aware
1.1 基础知识
Spring 的依赖注入，即所有的 Bean 对 Spring 容器的存在是没有意识的。就说明 Bean 之间的耦合度很低。
但在实际项目中，要想用到 Spring 容器中所提供的资源就需要使 Bean 意识到容器 Spring 的存在，才能调用 Spring 所提供的资源，这就是所谓的 Spring Aware。若使用了 Spring Aware ，你的 Bean 将会和 Spring 框架耦合。
Spring 提供的 Aware 接口如下表所示：
|函数名|函数功能|
|--|:--😐--|
|BeanNameAware|获得到容器中 Bean 的名称|
|BeanFactoryAware|获得当前 bean factory，这样可以调用容器的服务|
|ApplicationContextAware*|当前application context，这样可以调用容器的服务|
|MessageSourceAware|获得message source，这样可以获得文本信息|
|ApplicationEventPublisherAware|应用事件发布器，可以发布事件|
|ResourceLoaderAware|获得资源加载器，可以获得外部资源文件|
Spring Aware 的目的是为了让 Bean 获得 Spring 容器的服务。因为 ApplicationContext 接口集成了 MessageSource 接口、ApplicationEventPublisher 接口和 ResourceLoader 接口，所以 Bean 继承 ApplicationContextAware 可以获得 Spring 容器的所有服务。
2. 多线程
2.1 基础知识
Spring 通过任务执行器（TaskExecutor）来实现多线程和并发编程。使用 ThreadPoolTaskExecutor 可实现一个基于线程池的 TaskExecutor。而实际开发中任务一般是非阻碍的，即异步的，所以我们要在配置类中通过 @EnbaleAsync 开启对异步任务的支持，并通过在实际执行的 Bean 的方法中使用 @Async 注解来声明其是一个异步任务。
3. 计划任务
3.1 基础知识
首先通过在配置类中注解 @EnableScheduling 来开启对计划任务的支持，然后在要执行计划任务的方法上注解 @Scheduled ，声明这是一个计划任务。
4. 条件注解 @Conditional
4.1 基础知识
@Conditional 根据满足某一个特定条件创建一个特定的 Bean。比方说，当某一个 jar 包在一个类路径下的时候，自动配置一个或多个 Bean；或者只有某个 Bean 被创建才会创建另外一个 Bean。总的来说，就是根据特定条件来控制 Bean 的创建行为，这样我们可以利用这个特性来进行一些自动配置。
5. 组合注解与元注解
5.1 基础知识
元注解 其实就是可以注解到别的注解上的注解，被注解的注解称之为 组合注解，组合注解具备注解其上的元注解的功能。Spring 的很多注解都可以作为元注解，而且 Spring 本身已经有很多组合注解，如 @Configuration 就是一个组合 @Component 注解，表明这个类其实也是个 Bean。
6. @Enable* 注解的工作原理
6.1 基础知识
@Enable* 的例子有：@EnableAspectJAutoProxy 开启对 AspectJ 自动代理的支持；@EnableAsync 开启异步方法的支持；@EnableScheduling 开启计划任务的支持。
通过观察这些 @Enable* 注解的源码，我们发向所有的注解都有一个 @Import 注解，@Import 是用来导入配置类的，这也就意味着这些自动开启的实现其实是导入了一些自动配置的 Bean。这些导入的配置方式主要分为以下三种类型。
（1）直接导入配置类
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(SchedulingConfiguration.class)
@Documented
public @interface EnableScheduling {
}
直接导入配置类 SchedulingConfiguraiton，这个类注解了 @Configuration，且注册了一个 scheduledAnnotationProcessor 的 Bean，源码如下：
@Configuration
@Role(2)
public class SchedulingConfiguration {
public SchedulingConfiguration() {
}
@Bean(
name = {"org.springframework.context.annotation.internalScheduledAnnotationProcessor"}
)
@Role(2)
public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
return new ScheduledAnnotationBeanPostProcessor();
}
}
（2）依据条件选择配置类
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AsyncConfigurationSelector.class})
public @interface EnableAsync {
Class<? extends Annotation> annotation() default Annotation.class;
boolean proxyTargetClass() default false;
AdviceMode mode() default AdviceMode.PROXY;
int order() default 2147483647;
}
AsyncConfigurationSelector 通过条件来选择需要导入的配置类，AsyncConfigurationSelector 的根接口为 ImportSelector，这个接口需重写 selectImports 方法，在此方法内进行事先条件判断。此例中，若 adviceMode 为 PROXY，则返回 ProxyAsyncConfiguration 这个配置类；若 activeMode 为 ASPECTJ，则返回 AspectJAsyncConfiguration 配置类，源码如下：
public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {
private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME = "org.springframework.scheduling.aspectj.AspectJAsyncConfiguration";
public AsyncConfigurationSelector() {
}
@Nullable
public String[] selectImports(AdviceMode adviceMode) {
switch(adviceMode) {
case PROXY:
return new String[]{ProxyAsyncConfiguration.class.getName()};
case ASPECTJ:
return new String[]{"org.springframework.scheduling.aspectj.AspectJAsyncConfiguration"};
default:
return null;
}
}
}
（3）动态注册 Bean
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
boolean proxyTargetClass() default false;
boolean exposeProxy() default false;
}
AspectJAutoProxyRegistrar 实现了 ImportBeanDefinitionRegistrar 接口，它的作用是在运行时自动添加 Bean 到已有的配置类，通过重写方法：
registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)
其中，AnnotationMetadata 参数用来获得当前配置类上的注解；BeanDefinitionRegistry 参数来注册 Bean。源码如下：
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
AspectJAutoProxyRegistrar() {
}
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}
