【SpringBoot】SpringBoot 与任务（二十二）

　　本章介绍SpringBoot 与任务，这里任务包括异步任务和定时任务

异步任务

　　在Java应用中，绝大多数情况下都是通过同步的方式来实现交互处理的；但是在处理与第三方系统交互的时候，容易造成响应迟缓的情况，之前大部分都是使用多线程来完成此类任务，其实，在Spring 3.x之后，就已经内置了@Async来完美解决这个问题。

　　@Async

　　1、新建一个SpringBoot Web项目

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test</groupId>
    <artifactId>test-springboot-task</artifactId>
    <version>1.0-SNAPSHOT</version>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>


    <!-- SpringBoot打包插件，可以将代码打包成一个可执行的jar包 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

　　2、编辑一个AsyncService，写一个say方法，这里的say方法要处理的内容，就是异步任务，且需要等待5秒钟，在方法上加上@Async注解

@Service
public class AsyncService {

    // 告诉Spring这是一个异步方法
    @Async
    public void say(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("数据处理中。。。。。。");
    }
}

　　3、在启动类上，使用@EnableAsync开启异步注解功能

// 开启异步注解
@EnableAsync
@SpringBootApplication
public class Application {

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

　　4、编写一个AsyncController用来调用异步任务。内容如下：

@RestController
public class AsyncController {

    @Autowired
    AsyncService asyncService;

    @RequestMapping("/hello")
    public String say(){
        asyncService.say();
        return "success";
    }
}

　　5、测试，在浏览器上是使用地址：http://localhost:8080/hello，访问AsyncController，F12查看浏览器控制台，可以看到请求响应耗时181，证明say()方法是异步执行的

　　　　

　　Spring提供了异步执行任务调度的方式，提供TaskExecutor 、TaskScheduler 接口。

　　TaskExecutor 接口

　　1、在容器中注入TaskExecutor

@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setMaxPoolSize(10);
    taskExecutor.setCorePoolSize(5);
    taskExecutor.setQueueCapacity(20);
    return taskExecutor;
}

　　2、编写controller，调用TaskExecutor执行任务

@RestController
public class TaskExecutorController {

    // 注入任务执行器
    @Autowired
    TaskExecutor taskExecutor;


    @RequestMapping("/taskExecutor")
    public String executor(){
        // 执行任务
        taskExecutor.execute(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() +  ":taskExecutor ..... start " + new Date());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() +  ":taskExecutor ..... end " + new Date());
            }
        });
        return "success";
    }
}

　　3、启动项目测试，访问地址：http://localhost:8080/taskExecutor，可以看到响应时间只有25ms，任务值异步执行

　　　　

　　TaskScheduler 接口

　　1、在容器中注入TaskScheduler

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(10);

    return taskScheduler;
}

　　2、编写controller，调用TaskScheduler执行任务

@RestController
public class TaskSchedulerController {

    // 注入TaskScheduler
    @Autowired
    TaskScheduler taskScheduler;

    @RequestMapping("/taskScheduled")
    public String executor(){

        taskScheduler.schedule(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() +  ":taskScheduled ..... start " + new Date());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() +  ":taskScheduled ..... end " + new Date());
            }
        }, new Date(new Date().getTime() + 5000));
        return "success";
    }
}

 　　3、启动项目测试，访问地址：http://localhost:8080/taskScheduled，可以看到响应时间只有277ms，任务值异步执行

　　　　

定时任务

　　项目开发中经常需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息。

　　1、编写定时任务Service，且在方式上使用@Scheduled，里面是cron表达式（可以参阅网上其他文档）

@Service
public class ScheduledService {

    @Scheduled(cron = "0/5 * * * * ?")
    public void hello(){
        System.out.println("hello ... " + new Date());
    }
}

 　　2、在启动类上，使用@EnableScheduling开启定时任务功能

// 开启定时任务注解
@EnableScheduling
@SpringBootApplication
public class Application {

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

　　3、 启动项目测试，观察控制台，定时任务按时间规则执行