首页 > > 程序设计 > Java技术 >

SpringBoot 2.x （11）：定时任务与异步任务

2019-05-13 07:16:19来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

定时任务：有时候我们需要做定时的一些操作，比如统计信息，定时发送邮件等

在SpringBoot中如何进行整合和使用呢？

 

有哪些方式可以实现定时任务呢？

Java自带的java.util.timer：

优点：Java自带，无需导包

缺点：配置复杂，时间延后等问题

 

Quartz框架：

优点：配置简单，使用方便

缺点：需要导包

 

@EnableSchedule：

优点：SpringBoot自带，高兼容，无需导包

 

使用：

 在启动类加入@EnableScheduling注解

package org.dreamtech.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class DemoApplication {

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

}

 

定义Task：

package org.dreamtech.demo.task;

import java.util.Date;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class TestTask {
    @Scheduled(fixedRate = 2000)
    public void test() {
        System.out.println("[ " + "当前时间 : " + new Date() + " ]");
    }
}

 

效果：控制台每过两秒打印一次当前时间

[ 当前时间 : Fri May 10 14:01:42 CST 2019 ]
[ 当前时间 : Fri May 10 14:01:44 CST 2019 ]
[ 当前时间 : Fri May 10 14:01:46 CST 2019 ]
[ 当前时间 : Fri May 10 14:01:48 CST 2019 ]
[ 当前时间 : Fri May 10 14:01:50 CST 2019 ]
[ 当前时间 : Fri May 10 14:01:52 CST 2019 ]
[ 当前时间 : Fri May 10 14:01:54 CST 2019 ]

 

使用CRON表达式：

每两秒执行一次的另一种表达方式：

    @Scheduled(cron = "*/2 * * * * *")

 关于CRON表达式的百度即可，一堆介绍，我就不多写了

 

 

异步任务：适用于发送短信、邮件、处理Log等问题

为什么需要异步任务？

比如电商网站用户下单，要做的事情有这几样：库存查询、用户校验、余额校验等

SpringBoot使用异步任务：@EnableAsync注解

基本实现：

启动类加入@EnableAsync注解

package org.dreamtech.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class DemoApplication {

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

}

 

定义任务类：这里模拟耗时的操作

package org.dreamtech.demo.task;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
@Async
public class AsyncTask {
    public void test1() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println("[ " + "任务1耗时 : " + (end - begin) + " ]");
    }

    public void test2() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(2000);
        long end = System.currentTimeMillis();
        System.out.println("[ " + "任务2耗时 : " + (end - begin) + " ]");
    }

    public void test3() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(3000);
        long end = System.currentTimeMillis();
        System.out.println("[ " + "任务2耗时 : " + (end - begin) + " ]");
    }
}

 

Controller层做测试：

package org.dreamtech.demo.controller;

import org.dreamtech.demo.task.AsyncTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    private AsyncTask task;

    @GetMapping("/test")
    private Object test() {
        long begin = System.currentTimeMillis();
        try {
            task.test1();
            task.test2();
            task.test3();
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("[ " + "Controller耗时 : " + (end - begin) + " ]");
        return "test";
    }
}

 

访问localhost:8080/test打印如下：

[ Controller耗时 : 4 ]
[ 任务1耗时 : 1000 ]
[ 任务2耗时 : 2000 ]
[ 任务2耗时 : 3000 ]

 

结论：异步任务的执行类似多线程，可以用来做一些耗时操作

 

有时候需要某个任务确定执行完毕才能继续其他操作

如何获取任务的执行结果呢？

package org.dreamtech.demo.task;

import java.util.concurrent.Future;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

@Component
@Async
public class AsyncTask {

    public Future<String> test1() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println("[ " + "任务1耗时 : " + (end - begin) + " ]");
        return new AsyncResult<String>("任务1");
    }

    public Future<String> test2() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(2000);
        long end = System.currentTimeMillis();
        System.out.println("[ " + "任务2耗时 : " + (end - begin) + " ]");
        return new AsyncResult<String>("任务2");
    }

    public Future<String> test3() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(3000);
        long end = System.currentTimeMillis();
        System.out.println("[ " + "任务3耗时 : " + (end - begin) + " ]");
        return new AsyncResult<String>("任务3");
    }
}

 

Controller：

package org.dreamtech.demo.controller;

import java.util.concurrent.Future;

import org.dreamtech.demo.task.AsyncTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    private AsyncTask task;

    @GetMapping("/test")
    private Object test() {
        long begin = System.currentTimeMillis();
        try {
            Future<String> task1Result = task.test1();
            Future<String> task2Result = task.test2();
            Future<String> task3Result = task.test3();
            while (true) {
                if (task1Result.isDone() && task2Result.isDone() && task3Result.isDone()) {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("[ " + "Controller耗时 : " + (end - begin) + " ]");
        return "test";
    }
}

 

访问localhost:8080/test

等待3秒之后，打印如下：

[ 任务1耗时 : 1001 ]
[ 任务2耗时 : 2001 ]
[ 任务3耗时 : 3001 ]
[ Controller耗时 : 3007 ]

 只有三个任务都完成，Controller层代码才会执行完毕

 

总结：异步任务大大地提高了开发的效率

 

顺便来记录Logback的使用：

Logback：一款优秀的日志框架

SpringBoot的Starter默认日志框架：Logback，默认级别：INFO

如果我们想以DEBUG方式启动：java -jar springboot.jar --debug

配置文件：官方推荐名称logback-spring.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>

    <appender name="consoleApp"
        class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>
                %date{yyyy-MM-dd HH:mm:ss.SSS} %-5level[%thread]%logger{56}.%method:%L -%msg%n
            </pattern>
        </layout>
    </appender>

    <appender name="fileInfoApp"
        class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>DENY</onMatch>
            <onMismatch>ACCEPT</onMismatch>
        </filter>
        <encoder>
            <pattern>
                %date{yyyy-MM-dd HH:mm:ss.SSS} %-5level[%thread]%logger{56}.%method:%L -%msg%n
            </pattern>
        </encoder>
        <!-- 滚动策略 -->
        <rollingPolicy
            class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 路径 -->
            <fileNamePattern>app_log/log/app.info.%d.log</fileNamePattern>
        </rollingPolicy>
    </appender>

    <appender name="fileErrorApp"
        class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
        <encoder>
            <pattern>
                %date{yyyy-MM-dd HH:mm:ss.SSS} %-5level[%thread]%logger{56}.%method:%L -%msg%n
            </pattern>
        </encoder>
        <!-- 设置滚动策略 -->
        <rollingPolicy
            class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 路径 -->
            <fileNamePattern>app_log/log/app.err.%d.log</fileNamePattern>
            <!-- 控制保留的归档文件的最大数量，超出数量就删除旧文件，假设设置每个月滚动， 且<maxHistory> 是1，则只保存最近1个月的文件，删除之前的旧文件 -->
            <MaxHistory>1</MaxHistory>
        </rollingPolicy>
    </appender>
    <root level="INFO">
        <appender-ref ref="consoleApp" />
        <appender-ref ref="fileInfoApp" />
        <appender-ref ref="fileErrorApp" />
    </root>
</configuration>

 

使用和测试：

package org.dreamtech.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @GetMapping("/log")
    private Object log() {
        logger.debug("test");
        logger.info("test");
        logger.warn("test");
        logger.error("test");
        return "log";
    }
}

 

访问localhost:8080/log

会在项目目录生成一个新目录app_log

存在两个文件：一个用来存放ERROR级别信息，一个存放INFO级别和WARN级别

2019-05-11 12:53:53.668 ERROR[http-nio-8080-exec-1]org.dreamtech.demo.controller.TestController.log:18 -test
2019-05-11 12:53:36.264 INFO [main]org.dreamtech.demo.DemoApplication.logStarting:50 -Starting DemoApplication on DESKTOP-59O94TD with PID 14180 (D:\PROJECT\STS_PROJECT\demo\target\classes started by 20235 in D:\PROJECT\STS_PROJECT\demo)
2019-05-11 12:53:36.266 INFO [main]org.dreamtech.demo.DemoApplication.logStartupProfileInfo:675 -No active profile set, falling back to default profiles: default
2019-05-11 12:53:37.019 INFO [main]o.s.boot.web.embedded.tomcat.TomcatWebServer.initialize:90 -Tomcat initialized with port(s): 8080 (http)
2019-05-11 12:53:37.031 INFO [main]org.apache.coyote.http11.Http11NioProtocol.log:173 -Initializing ProtocolHandler ["http-nio-8080"]
2019-05-11 12:53:37.039 INFO [main]org.apache.catalina.core.StandardService.log:173 -Starting service [Tomcat]
2019-05-11 12:53:37.041 INFO [main]org.apache.catalina.core.StandardEngine.log:173 -Starting Servlet engine: [Apache Tomcat/9.0.17]
2019-05-11 12:53:37.122 INFO [main]o.a.catalina.core.ContainerBase.[Tomcat].[localhost].[/].log:173 -Initializing Spring embedded WebApplicationContext
2019-05-11 12:53:37.122 INFO [main]org.springframework.web.context.ContextLoader.prepareWebApplicationContext:296 -Root WebApplicationContext: initialization completed in 824 ms
2019-05-11 12:53:37.289 INFO [main]o.s.scheduling.concurrent.ThreadPoolTaskExecutor.initialize:171 -Initializing ExecutorService 'applicationTaskExecutor'
2019-05-11 12:53:37.413 INFO [main]org.apache.coyote.http11.Http11NioProtocol.log:173 -Starting ProtocolHandler ["http-nio-8080"]
2019-05-11 12:53:37.447 INFO [main]o.s.boot.web.embedded.tomcat.TomcatWebServer.start:204 -Tomcat started on port(s): 8080 (http) with context path ''
2019-05-11 12:53:37.450 INFO [main]org.dreamtech.demo.DemoApplication.logStarted:59 -Started DemoApplication in 1.528 seconds (JVM running for 2.39)
2019-05-11 12:53:53.641 INFO [http-nio-8080-exec-1]o.a.catalina.core.ContainerBase.[Tomcat].[localhost].[/].log:173 -Initializing Spring DispatcherServlet 'dispatcherServlet'
2019-05-11 12:53:53.642 INFO [http-nio-8080-exec-1]org.springframework.web.servlet.DispatcherServlet.initServletBean:524 -Initializing Servlet 'dispatcherServlet'
2019-05-11 12:53:53.650 INFO [http-nio-8080-exec-1]org.springframework.web.servlet.DispatcherServlet.initServletBean:546 -Completed initialization in 8 ms
2019-05-11 12:53:53.668 INFO [http-nio-8080-exec-1]org.dreamtech.demo.controller.TestController.log:16 -test
2019-05-11 12:53:53.668 WARN [http-nio-8080-exec-1]org.dreamtech.demo.controller.TestController.log:17 -test
2019-05-11 12:54:23.513 INFO [RMI TCP Connection(2)-127.0.0.1]o.s.b.a.SpringApplicationAdminMXBeanRegistrar$SpringApplicationAdmin.shutdown:163 -Application shutdown requested.
2019-05-11 12:54:23.515 INFO [RMI TCP Connection(2)-127.0.0.1]o.s.scheduling.concurrent.ThreadPoolTaskExecutor.shutdown:208 -Shutting down ExecutorService 'applicationTaskExecutor'

 


原文链接:https://www.cnblogs.com/xuyiqing/p/10843960.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Springboot集成Quartz集群

下一篇：自学Java编程，如何才能混到一个7k薪资实习生的岗位

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签