三、spring进阶

3.1 Spring Aware

Spring的依赖注入的最大亮点就是你所有的Bean对Spring容器的存在是没有意识的。
但是在实际项目中，你不可避免的要用到Spring容器本身的功能资源，这时你的Bean必须要意识到Spring容器的存在，才能调用Spring所提供的资源，这就是所谓的Spring Aware。
其实Spring Aware本来就是Spring设计用来框架内部使用的，若使用了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容器的所有服务，但原则上我们还是用到什么接口，就实现什么接口。

---

示例

（1）准备。在com.wisely.highlight_spring4.ch3.aware包下新建一个test.txt，内容随意，给下面的外部资源加载使用。
（2）Spring Aware演示Bean

package com.wisely.highlight_spring4.ch3.aware; 

@Service 
public class AwareService implements BeanNameAware,ResourceLoaderAware{//1 
    
    private String beanName; 
    private ResourceLoader loader; 
    
    @Override 
    public void setResourceLoader(ResourceLoader resourceLoader) {//2 
        this.loader = resourceLoader; 
    } 
  
    @Override 
    public void setBeanName(String name) {//3 
        this.beanName = name; 
    } 
    
    public void outputResult(){ 
        System.out.println("Bean的名称为：" + beanName); 
        
        Resource resource = loader.getResource("classpath:com/wisely/highlight_spring4/ch2/aware/test.txt"); 
        try{ 
            System.out.println("ResourceLoader加载的文件内容为: " + IOUtils.toString(resource.getInputStream())); 
        }catch(IOException e){ 
            e.printStackTrace(); 
           } 
        } 
} 

①实现BeanNameAware、ResourceLoaderAware接口，获得Bean名称和资源加载的服务。
②实现ResourceLoaderAware需重写setResourceLoader。
③实现BeanNameAware需重写setBeanName方法。

（3）配置类

package com.wisely.highlight_spring4.ch3.aware; 

@Configuration 
@ComponentScan("com.wisely.highlight_spring4.ch3.aware") 
public class AwareConfig { 
} 

（4）运行

package com.wisely.highlight_spring4.ch3.aware; 

public class Main { 
    public static void main(String[] args) { 
        
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AwareConfig.class); 
        
        AwareService awareService = context.getBean(AwareService.class); 
        awareService.outputResult(); 
        context.close(); 
    } 
} 

（5）结果

Bean的名称为：awareService
ResourceLoader加载的文件内容为: 11111....//文件内容

---

3.2 多线程

Spring通过任务执行器（TaskExecutor）来实现多线程和并发编程。
使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor。而实际开发中任务一般是非阻碍的，即异步的，所以我们要在配置类中通过@EnableAsync开启对异步任务的支持，并通过在实际执行的Bean的方法中使用@Async注解来声明其是一个异步任务。

---

3.2.2 示例

（1）配置类

package com.wisely.highlight_spring4.ch3.taskexecutor; 

@Configuration 
@ComponentScan("com.wisely.highlight_spring4.ch3.taskexecutor") 
@EnableAsync //1 
public class TaskExecutorConfig implements AsyncConfigurer{//2 
  
    @Override 
    public Executor getAsyncExecutor() {//2 
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); 
        taskExecutor.setCorePoolSize(5); 
        taskExecutor.setMaxPoolSize(10); 
        taskExecutor.setQueueCapacity(25); 
        taskExecutor.initialize(); 
        return taskExecutor; 
    } 
  
    @Override 
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { 
        return null; 
    } 
  
} 

①利用@EnableAsync注解开启异步任务支持。
②配置类实现AsyncConfigurer接口并重写getAsyncExecutor方法，并返回一个ThreadPoolTaskExecutor，这样我们就获得了一个基于线程池TaskExecutor。

（2）任务执行类

@Service 
public class AsyncTaskService { 
    @Async //1 
    public void executeAsyncTask(Integer i){ 
        System.out.println("执行异步任务: "+i); 
    } 
    @Async 
    public void executeAsyncTaskPlus(Integer i){ 
        System.out.println("执行异步任务+1: "+(i+1)); 
    } 
} 

①通过@Async注解表明该方法是个异步方法，如果注解在类级别，则表明该类所有的方法都是异步方法，而这里的方法自动被注入使用ThreadPoolTaskExecutor作为TaskExecutor。

（3）运行

package com.wisely.highlight_spring4.ch3.taskexecutor; 

public class Main { 
    
    public static void main(String[] args) { 
         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskExecutorConfig. class); 
          
         AsyncTaskService asyncTaskService = context.getBean(AsyncTaskService.class); 
          
         for(int i =0 ;i<10;i++){ 
             asyncTaskService.executeAsyncTask(i); 
             asyncTaskService.executeAsyncTaskPlus(i); 
            } 
            context.close(); 
    } 
} 

---

3.3 计划任务

首先通过在配置类注解@EnableScheduling来开启对计划任务的支持，然后在要执行计划任务的方法上注解@Scheduled，声明这是一个计划任务。
Spring通过@Scheduled支持多种类型的计划任务，包含cron、fixDelay、fixRate等。

---

3.3.1 示例

（1）计划任务执行类

package com.wisely.highlight_spring4.ch3.taskscheduler; 

@Service 
public class ScheduledTaskService { 
    
      private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss"); 
  
      @Scheduled(fixedRate = 5000) //1 
      public void reportCurrentTime() { 
           System.out.println("每隔五秒执行一次 " + dateFormat.format(new Date())); 
       } 
  
      @Scheduled(cron = "0 28 11 ? * *"  ) //2 
      public void fixTimeExecution(){ 
          System.out.println("在指定时间 " + dateFormat.format(new Date())+"执行"); 
      } 
} 

①通过@Scheduled声明该方法是计划任务，使用fixedRate属性每隔固定时间执行。
②使用cron属性可按照指定时间执行，本例指的是每天11点28分执行；cron是UNIX和类UNIX（Linux）系统下的定时任务。

（2）配置类

package com.wisely.highlight_spring4.ch3.taskscheduler; 

@Configuration 
@ComponentScan("com.wisely.highlight_spring4.ch3.taskscheduler") 
@EnableScheduling //1 
public class TaskSchedulerConfig { 
} 

①通过@EnableScheduling注解开启对计划任务的支持。

（3）运行

package com.wisely.highlight_spring4.ch3.taskscheduler; 

public class Main { 
    public static void main(String[] args) { 
         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskSchedulerConfig.class); 
    } 
} 

3.4 条件注解

Spring 4提供了一个更通用的基于条件的Bean的创建，即使用@Conditional注解。
@Conditional根据满足某一个特定条件创建一个特定的Bean。
在Spring Boot中将会大量应用到条件注解。

3.4.1 示例

下面的示例将以不同的操作系统作为条件，我们将通过实现Condition接口，并重写其matches方法来构造判断条件。若在Windows系统下运行程序，则输出列表命令为dir；若在Linux操作系统下运行程序，则输出列表命令为ls。

---

1.判断条件定义
（1）判断windows的条件

package com.wisely.highlight_spring4.ch3.conditional; 

public class WindowsCondition implements Condition { 
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
        return context.getEnvironment().getProperty("os.name").contains("Windows"); 
    } 
} 

（2）判定Linux的条件

package com.wisely.highlight_spring4.ch3.conditional; 

public class LinuxCondition implements Condition { 
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
        return context.getEnvironment().getProperty("os.name").contains("Linux");
    }
}

2.不同系统下Bean的类
（1）接口

package com.wisely.highlight_spring4.ch3.conditional; 
  
public interface ListService { 
    public String showListCmd(); 
} 

（2）Windows下所要创建的Bean的类

package com.wisely.highlight_spring4.ch3.conditional; 
  
public class WindowsListService implements ListService { 
    @Override 
    public String showListCmd() { 
        return "dir"; 
    } 
} 

（3）Linux下所要创建的Bean的类

package com.wisely.highlight_spring4.ch3.conditional; 
  
public class LinuxListService implements ListService{ 
    @Override 
    public String showListCmd() { 
        return "ls"; 
    } 
} 

3.配置类

package com.wisely.highlight_spring4.ch3.conditional;       

@Configuration 
public class ConditionConifg { 
    @Bean 
    @Conditional(WindowsCondition.class) //1 
    public ListService windowsListService() { 
        return new WindowsListService(); 
    } 
  
    @Bean 
    @Conditional(LinuxCondition.class) //2 
    public ListService linuxListService() { 
        return new LinuxListService(); 
    } 
} 

①通过@Conditional注解，符合Windows条件则实例化windowsListService。
②通过@Conditional注解，符合Linux条件则实例化linuxListService。

4.运行

package com.wisely.highlight_spring4.ch3.conditional; 

public class Main { 
  
    public static void main(String[] args) { 
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConditionConifg.class); 
        
        ListService listService = context.getBean(ListService.class); 
        System.out.println(context.getEnvironment().getProperty("os.name")  + "系统下的列表命令为: "  + listService.showListCmd()); 
    } 
} 

---

3.5 组合注解与元注解

Spring的注解主要用来配置注入Bean，切面相关配置（@Transactional）。随着注解的大量使用，尤其相同的多个注解用到各个类中，会相当啰嗦。这就是所谓的模板代码，是Spring设计原则中要消除的代码。
元注解其实就是可以注解到别的注解上的注解，被注解的注解称之为组合注解、是可能有点拗口，体会含义最重要），组合注解具备元注解的功能。Spring的很多注解都可以作为元注解，而且Spring本身已经有很多组合注解，如@Configuration就是一个组合@Component注解，表明这个类其实也是一个Bean。

3.5.1 示例

---

（1）示例组合注解

package com.wisely.highlight_spring4.ch3.annotation; 

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Configuration //1 
@ComponentScan //2 
public @interface WiselyConfiguration { 
    String[] value() default {}; //3 
} 

①组合@Configuration元注解。
②组合@ComponentScan元注解。
③覆盖value参数。

（2）演示服务Bean

package com.wisely.highlight_spring4.ch3.annotation; 
  
@Service 
public class DemoService { 
    public void outputResult(){ 
        System.out.println("从组合注解配置照样获得的bean"); 
    } 
} 

（3）新的配置类

package com.wisely.highlight_spring4.ch3.annotation; 
  
@WiselyConfiguration("com.wisely.highlight_spring4.ch3.annotation")//1 
public class DemoConfig { 
} 

①使用@WiselyConfiguration组合注解替代@Configuration和@ComponentScan。

（4）运行

public class Main { 
    
    public static void main(String[] args) { 
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DemoConfig.class); 
        
        DemoService demoService =  context.getBean(DemoService.class); 
        demoService.outputResult(); 
        context.close(); 
    } 
} 

（5）结果

从组合注解配置赵阳获得的bean

---

3.6　@Enable*注解的工作原理

通过简单的@Enable* 来开启一项功能的支持，从而避免自己配置大量的代码，大大降低使用难度。
通过观察这些@Enable*注解的源码，我们发现所有的注解都有一个@Import注解，@Import是用来导入配置类的，这也就意味着这些自动开启的实现其实是导入了一些自动配置的Bean。这些导入的配置方式主要分为以下三种类型。

3.6.1 第一类：直接导入配置类

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

直接导入配置类SchedulingConfiguration，这个类注解了@Configuration，且注册了一个scheduledAnnotationProcessor的Bean，源码如下：

@Configuration 
@Role(BeanDefinition.ROLE_INFRASTRUCTURE) 
public class SchedulingConfiguration { 
  
    @Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME) 
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE) 
    public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() { 
            return new ScheduledAnnotationBeanPostProcessor(); 
    } 
} 

3.6.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 Ordered.LOWEST_PRECEDENCE; 
} 

AsyncConfigurationSelector通过条件来选择需要导入的配置类，AsyncConfigurationSelector的根接口为ImportSelector，这个接口需重写selectImports方法，在此方法内进行事先条件判断。此例中，若adviceMode为PORXY，则返回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"; 
  
    @Override 
    public String[] selectImports(AdviceMode adviceMode) { 
        switch (adviceMode) { 
            case PROXY: 
                return new String[] { ProxyAsyncConfiguration.class.getName() }; 
            case ASPECTJ: 
                return new String[] { ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME }; 
            default: 
                return null; 
        } 
    } 
} 

3.6.3 第三类：动态注册Bean

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Import(AspectJAutoProxyRegistrar.class) 
public @interface EnableAspectJAutoProxy { 
    boolean proxyTargetClass() default false; 
}

AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口，ImportBean DefinitionRegistrar的作用是在运行时自动添加Bean到已有的配置类，通过重写方法：

registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)