定时任务的五种创建方式，你都会么？

客官°小女子只卖身不卖艺 2022-10-05 07:50 204阅读 0赞

0D5F937FE12312312D81F17F.jpg

程序员的成长之路

互联网/程序员/技术/资料共享

关注

阅读本文大概需要 6 分钟。

来自：blog.csdn.net/qq_41463655/article/details/100839629

Quartz表达式生成地址：http://cron.qqe2.com/

支持生成定时任务表达式和反解析，使用Quartz表达式的定时任务如下

  • xxl-job
  • springboot 的 @Scheduled
  • Quartz 框架

一、job 定时任务的五种创建方式

1、使用线程创建 job 定时任务

  1. /**
  2.   * TODO  使用线程创建 job 定时任务
  3.   * @author 王松
  4.   */
  5. public class JobThread {
  7.     public static class Demo01 {
  8.         static long count = 0;
  10.         public static void main(String[] args) {
  11.             Runnable runnable = new Runnable() {
  12.                 @Override
  13.                 public void run() {
  14.                     while (true) {
  15.                         try {
  16.                             Thread.sleep(1000);
  17.                             count++;
  18.                             System.out.println(count);
  19.                         } catch (Exception e) {
  20.                             // TODO: handle exception
  21.                         }
  22.                     }
  23.                 }
  24.             };
  25.             Thread thread = new Thread(runnable);
  26.             thread.start();
  27.         }
  28.     }
  29. }

2、使用 TimerTask 创建job定时任务

  1. /**
  2.  * TODO  使用 TimerTask 创建job定时任务
  3.  * @author 王松
  4.  */
  5. public class JobTimerTask {
  7.     static long count = 0;
  8.     public static void main(String[] args) {
  9.         TimerTask timerTask = new TimerTask() {
  10.             @Override
  11.             public void run() {
  12.                 count++;
  13.                 System.out.println(count);
  14.             }
  15.         };
  16.         //创建timer对象设置间隔时间
  17.         Timer timer = new Timer();
  18.         // 间隔天数
  19.         long delay = 0;
  20.         // 间隔毫秒数
  21.         long period = 1000;
  22.         timer.scheduleAtFixedRate(timerTask, delay, period);
  23.     }
  24. }

3、使用线程池创建 job定时任务

  1.  /**
  2.   * TODO  使用线程池创建 job定时任务
  3.   * @author 王松
  4.   */
  5. public class JobScheduledExecutorService {
  6.         public static void main(String[] args) {
  7.             Runnable runnable = new Runnable() {
  8.                 @Override
  9.                 public void run() {
  10.                     // task to run goes here
  11.                     System.out.println("Hello !!");
  12.                 }
  13.             };
  14.             ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
  15.             // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
  16.             service.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);
  17.         }
  18. }

4.Quartz 框架

1.引入maven依赖

  1. <dependencies>
  2.  <!-- quartz -->
  3.  <dependency>
  4.   <groupId>org.quartz-scheduler</groupId>
  5.   <artifactId>quartz</artifactId>
  6.   <version>2.2.1</version>
  7.  </dependency>
  8.  <dependency>
  9.   <groupId>org.quartz-scheduler</groupId>
  10.   <artifactId>quartz-jobs</artifactId>
  11.   <version>2.2.1</version>
  12.  </dependency>
  13. </dependencies>

2.任务调度类

  1. public class MyJob implements Job {
  3.     @Override
  4.     public void execute(JobExecutionContext context) throws JobExecutionException {
  5.         System.out.println("quartz MyJob date:" + System.currentTimeMillis());
  6.     }
  7. }

3.启动类

  1. public class JobQuartz {
  3.     public static void main(String[] args) throws SchedulerException {
  4.         //1.创建Scheduler的工厂
  5.         SchedulerFactory sf = new StdSchedulerFactory();
  6.         //2.从工厂中获取调度器实例
  7.         Scheduler scheduler = sf.getScheduler();
  8.         //3.创建JobDetail，
  9.         JobDetail jb = JobBuilder.newJob(MyJob.class)
  10.                 //job的描述
  11.                 .withDescription("this is a ram job")
  12.                 //job 的name和group
  13.                 .withIdentity("ramJob", "ramGroup")
  14.                 .build();
  15.         //任务运行的时间，SimpleSchedle类型触发器有效，3秒后启动任务
  16.         long time=  System.currentTimeMillis() + 3*1000L;
  17.         Date statTime = new Date(time);
  18.         //4.创建Trigger
  19.         //使用SimpleScheduleBuilder或者CronScheduleBuilder
  20.         Trigger t = TriggerBuilder.newTrigger()
  21.                 .withDescription("")
  22.                 .withIdentity("ramTrigger", "ramTriggerGroup")
  23.                 //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
  24.                 //默认当前时间启动
  25.                 .startAt(statTime)
  26.                 //两秒执行一次，Quartz表达式，支持各种牛逼表达式
  27.                 .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
  28.                 .build();
  29.         //5.注册任务和定时器
  30.         scheduler.scheduleJob(jb, t);
  31.         //6.启动 调度器
  32.         scheduler.start();
  33.     }

  1. springboot 的 @Scheduled 注解

    @Component
    @Configuration //1.主要用于标记配置类，兼备Component的效果。
    @EnableScheduling // 2.开启定时任务
    public class SaticScheduleTask {

    1.  @Scheduled(cron = "0/5 * * * * ?")  //3.添加定时任务
    2.  //@Scheduled(fixedRate=5000)        //或直接指定时间间隔，例如：5秒
    3.  private void configureTasks() {
    4.      System.err.println("执行静态定时任务时间: " + LocalDateTime.now());
    5.  }

    }

二、xxl-job 任务调度后台 Admin

xxl-job 有什么用？

  • 分布式集群的情况下，保证定时任务不被重复执行。
  • 执行原理同Nginx 类型，所有定时任务通过任务调度平台分发，也可配置负载均衡等等
  • 首先让我们能够使用起来，搭建一个自己的任务

第一步: github下载源码导入

下载地址：https://github.com/xuxueli/xxl-job/

当前版本目录结构 2.1.1

32b299e584a47827ec6c69a890869882.png

图片

第二步: 执行sql

文件地址：xxl-job/doc/db/tables_xxl_job.sql

当前2.1.1版本sql

4a320a6adf83fa361ff8441d2657dad5.png

图片

第三步: 修改xxl-job-admin项目配置

配置文件：application.properties

修改数据库连接

aa886050bdba7eccd2079ee1c7004043.png

图片

第四步: 启动admin项目

springboot 方式启动项目，

6633623e34e400961709f13d13b45222.png

图片

访问 http://localhost:8080/xxl-job-admin/

账号密码：admin / 123456

568a69e823548750e6598f23bd2ff54e.png

图片

任务调度中心就搭建好了

接下来需要创建一个服务器连接任务调度中心

三、自创建boot项目的任务xxl-job 示例demo

创建一个 boot 项目

我的目录结构

72b7d7f73a62eca832de36e1c6dea8bf.png

图片

pom.xml

web核心及 xxl-job-core

  1. <!-- spring-boot-starter-web (spring-webmvc + tomcat) -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-web</artifactId>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-test</artifactId>
  9.     <scope>test</scope>
  10. </dependency>
  12. <!-- xxl-job-core  版本号根据自己下载的版本修改 -->
  13. <dependency>
  14.     <groupId>com.xuxueli</groupId>
  15.     <artifactId>xxl-job-core</artifactId>
  16.     <version>2.1.1-SNAPSHOT</version>
  17. </dependency>

logback.xml

日志配置直接拷贝

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration debug="false" scan="true" scanPeriod="1 seconds">
  4.     <contextName>logback</contextName>
  5.     <property name="log.path" value="/data/applogs/xxl-job/xxl-job-executor-sample-springboot.log"/>
  7.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  8.         <encoder>
  9.             <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
  10.         </encoder>
  11.     </appender>
  13.     <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
  14.         <file>${log.path}</file>
  15.         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  16.             <fileNamePattern>${log.path}.%d{yyyy-MM-dd}.zip</fileNamePattern>
  17.         </rollingPolicy>
  18.         <encoder>
  19.             <pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
  20.             </pattern>
  21.         </encoder>
  22.     </appender>
  24.     <root level="info">
  25.         <appender-ref ref="console"/>
  26.         <appender-ref ref="file"/>
  27.     </root>
  29. </configuration>

application.properties 加入配置

需修改或自定义

  • xxl-job admin 地址
  • xxl.job.executor.appname 自定义名称，后台配置必须对应
  • xxl.job.executor.ip 当前电脑Ip，或部署项目的电脑Ip

  • xxl.job.executor.port 端口

    端口号

    server.port=8081

    日志

    logging.config=classpath:logback.xml

    xxl-job admin 地址，多个逗号分隔”

    xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

    xxl-job名称 || socket ip 当前项目部署的ip地址/本机ip || socket 端口号

    xxl.job.executor.appname=xxl-job-executor-sample
    xxl.job.executor.ip=192.168.43.153
    xxl.job.executor.port=9999

    xxl-job, access token

    xxl.job.accessToken=

    xxl-job log path

    xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler

    xxl-job log retention days

    xxl.job.executor.logretentiondays=-1

添加boot配置类 XxlJobConfig

  1. package xxljob.config;
  2. import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  9. /**
  10.  * xxl-job xxljob.config
  11.  */
  12. @SuppressWarnings("ALL")
  13. @Configuration
  14. public class XxlJobConfig {
  15.     private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);
  17.     @Value("${xxl.job.admin.addresses}")
  18.     private String adminAddresses;
  20.     @Value("${xxl.job.executor.appname}")
  21.     private String appName;
  23.     @Value("${xxl.job.executor.ip}")
  24.     private String ip;
  26.     @Value("${xxl.job.executor.port}")
  27.     private int port;
  29.     @Value("${xxl.job.accessToken}")
  30.     private String accessToken;
  32.     @Value("${xxl.job.executor.logpath}")
  33.     private String logPath;
  35.     @Value("${xxl.job.executor.logretentiondays}")
  36.     private int logRetentionDays;
  39.     @Bean(initMethod = "start", destroyMethod = "destroy")
  40.     public XxlJobSpringExecutor xxlJobExecutor() {
  41.         logger.info(">>>>>>>>>>> xxl-job xxljob.config init.");
  42.         XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
  43.         xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
  44.         xxlJobSpringExecutor.setAppName(appName);
  45.         xxlJobSpringExecutor.setIp(ip);
  46.         xxlJobSpringExecutor.setPort(port);
  47.         xxlJobSpringExecutor.setAccessToken(accessToken);
  48.         xxlJobSpringExecutor.setLogPath(logPath);
  49.         xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
  50.         System.err.println(ip+":"+port);
  51.         return xxlJobSpringExecutor;
  52.     }
  54.     /**
  55.      * 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
  56.      *
  57.      *      1、引入依赖：
  58.      *          <dependency>
  59.      *             <groupId>org.springframework.cloud</groupId>
  60.      *             <artifactId>spring-cloud-commons</artifactId>
  61.      *             <version>${version}</version>
  62.      *         </dependency>
  63.      *
  64.      *      2、配置文件，或者容器启动变量
  65.      *          spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
  66.      *
  67.      *      3、获取IP
  68.      *          String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
  69.      */
  70. }

任务job

  1. @JobHandler(value="demoJobHandler")
  2. @Component
  3. public class DemoJobHandler extends IJobHandler {
  5.      static int count;
  6.     @Override
  7.     public ReturnT<String> execute(String param) throws Exception {
  8.         System.out.println("执行job任务"+count++);
  9.         return SUCCESS;
  10.     }
  11. }

admin 后台配置

执行管理器下

bc4b0ccb5ea59ed10bacd4ce6d62f260.png

图片

任务管理下编辑任务

定时规则生成：http://cron.qqe2.com/

job任务名：@JobHandler注解值 >> 如:@JobHandler(value=“demoJobHandler”)

0be1ed5e90fdca35684394a2b47d16e2.png

图片

启动

56b57e2ec9a443be0fc98f4d220b1ca5.png

图片

这样就配置完成了

dc1b8234d01a9b3a59543882f8e20b11.png

图片

完成。

推荐阅读：

这是你想要的工作吗？灵隐寺招聘：没有KPI，佛系上班……

强烈不建议你用 a.equals(b) 判断对象相等！

  1. 最近面试BAT，整理一份面试资料《Java面试BATJ通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。

获取方式：点个「**在看」，点击上方小卡片，进入公众号后回复「面试题**」领取，更多内容陆续奉上。

朕已阅 177db3c5fa4c61685205f0fe269e4e5d.gif

发表评论

表情：
评论列表 （有 0 条评论，204人围观）

还没有评论，来说两句吧...

相关阅读