创建定时任务的 5 种方式，还有谁不会！！

Bertha 。 2022-10-08 11:10 165阅读 0赞

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

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

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

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

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

/**
      * TODO 使用线程创建 job 定时任务
      * @author 王松
      */
    public class JobThread {
    
        public static class Demo01 {
            static long count = 0;
    
            public static void main(String[] args) {
                Runnable runnable = new Runnable() {
                    @Override
                    public void run() {
                        while (true) {
                            try {
                                Thread.sleep(1000);
                                count++;
                                System.out.println(count);
                            } catch (Exception e) {
                                // TODO: handle exception
                            }
                        }
                    }
                };
                Thread thread = new Thread(runnable);
                thread.start();
            }
        }
    }

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

/**
     * TODO 使用 TimerTask 创建job定时任务
     * @author 王松
     */
    public class JobTimerTask {
    
        static long count = 0;
        public static void main(String[] args) {
            TimerTask timerTask = new TimerTask() {
                @Override
                public void run() {
                    count++;
                    System.out.println(count);
                }
            };
            //创建timer对象设置间隔时间
            Timer timer = new Timer();
            // 间隔天数
            long delay = 0;
            // 间隔毫秒数
            long period = 1000;
            timer.scheduleAtFixedRate(timerTask, delay, period);
        }
    }

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

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

#### **4、**Quartz\*\* 框架\*\* ####

1、引入maven依赖

<dependencies>
         
         <dependency>
              <groupId>org.quartz-scheduler</groupId>
              <artifactId>quartz</artifactId>
              <version>2.2.1</version>
         </dependency>
         <dependency>
              <groupId>org.quartz-scheduler</groupId>
              <artifactId>quartz-jobs</artifactId>
              <version>2.2.1</version>
         </dependency>
    </dependencies>

2、任务调度类

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

3、启动类

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

#### 5、springboot 的 @Scheduled 注解 ####

@Component
    @Configuration      //1.主要用于标记配置类，兼备Component的效果。
    @EnableScheduling   // 2.开启定时任务
    public class SaticScheduleTask {
    
        @Scheduled(cron = "0/5 * * * * ?") //3.添加定时任务
        //@Scheduled(fixedRate=5000) //或直接指定时间间隔，例如：5秒
        private void configureTasks() {
            System.err.println("执行静态定时任务时间: " + LocalDateTime.now());
        }
    }

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

xxl-job 有什么用？

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

Spring Boot 基础教程就不介绍了，推荐看这里：[https://github.com/javastacks/spring-boot-best-practice][https_github.com_javastacks_spring-boot-best-practice]

**第一步: github下载源码导入**

下载地址：[https://github.com/xuxueli/xxl-job/][https_github.com_xuxueli_xxl-job]

当前版本目录结构 2.1.1

![20210621083201672.png][]

**第二步: 执行sql**

文件地址：xxl-job/doc/db/tables\_xxl\_job.sql

当前2.1.1版本sql

![20210621083201845.png][]

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

配置文件：application.properties

修改数据库连接

![20210621083202336.png][]

**第四步: 启动admin项目**

springboot 方式启动项目

![20210621083202728.png][]

访问 [http://localhost:8080/xxl-job-admin/][http_localhost_8080_xxl-job-admin]

账号密码：admin / 123456

![20210621083203198.png][]

任务调度中心就搭建好了

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

## 三、自创建boot项目的任务xxl-job ##

创建一个 boot 项目

我的目录结构

![20210621083203513.png][]

pom.xml

web核心及 xxl-job-core

<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>
    
    
    <dependency>
        <groupId>com.xuxueli</groupId>
        <artifactId>xxl-job-core</artifactId>
        <version>2.1.1-SNAPSHOT</version>
    </dependency>

logback.xml

日志配置直接拷贝

<?xml version="1.0" encoding="UTF-8"?>
    <configuration debug="false" scan="true" scanPeriod="1 seconds">
    
        <contextName>logback</contextName>
        <property name="log.path" value="/data/applogs/xxl-job/xxl-job-executor-sample-springboot.log"/>
    
        <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
            </encoder>
        </appender>
    
        <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${log.path}</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}.%d{yyyy-MM-dd}.zip</fileNamePattern>
            </rollingPolicy>
            <encoder>
                <pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
                </pattern>
            </encoder>
        </appender>
    
        <root level="info">
            <appender-ref ref="console"/>
            <appender-ref ref="file"/>
        </root>
    
    </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

/**
     * xxl-job xxljob.config
     */
    @SuppressWarnings("ALL")
    @Configuration
    public class XxlJobConfig {
        private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);
    
        @Value("${xxl.job.admin.addresses}")
        private String adminAddresses;
    
        @Value("${xxl.job.executor.appname}")
        private String appName;
    
        @Value("${xxl.job.executor.ip}")
        private String ip;
    
        @Value("${xxl.job.executor.port}")
        private int port;
    
        @Value("${xxl.job.accessToken}")
        private String accessToken;
    
        @Value("${xxl.job.executor.logpath}")
        private String logPath;
    
        @Value("${xxl.job.executor.logretentiondays}")
        private int logRetentionDays;
    
    
        @Bean(initMethod = "start", destroyMethod = "destroy")
        public XxlJobSpringExecutor xxlJobExecutor() {
            logger.info(">>>>>>>>>>> xxl-job xxljob.config init.");
            XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
            xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
            xxlJobSpringExecutor.setAppName(appName);
            xxlJobSpringExecutor.setIp(ip);
            xxlJobSpringExecutor.setPort(port);
            xxlJobSpringExecutor.setAccessToken(accessToken);
            xxlJobSpringExecutor.setLogPath(logPath);
            xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
            System.err.println(ip+":"+port);
            return xxlJobSpringExecutor;
        }
    
        /**
         * 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
         *
         * 1、引入依赖：
         * <dependency>
         * <groupId>org.springframework.cloud</groupId>
         * <artifactId>spring-cloud-commons</artifactId>
         * <version>${version}</version>
         * </dependency>
         *
         * 2、配置文件，或者容器启动变量
         * spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
         *
         * 3、获取IP
         * String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
         */
    }

任务job

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

admin 后台配置

执行管理器下

![20210621083203819.png][]

任务管理下编辑任务

定时规则生成：[http://cron.qqe2.com/][http_cron.qqe2.com 1]

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

![20210621083204275.png][]

启动

![20210621083204578.png][]

这样就配置完成了

![20210621083204814.png][]

原文链接：[https://blog.csdn.net/qq\_41463655/article/details/100839629][https_blog.csdn.net_qq_41463655_article_details_100839629]

**近期热文推荐：**

1.[1,000+ 道 Java面试题及答案整理(2021最新版)][1_000_ _ Java_2021]

2.[终于靠开源项目弄到 IntelliJ IDEA 激活码了，真香！][IntelliJ IDEA]

3.[阿里 Mock 工具正式开源，干掉市面上所有 Mock 工具！][Mock _ Mock]

4.[Spring Cloud 2020.0.0 正式发布，全新颠覆性版本！][Spring Cloud 2020.0.0]

5.[《Java开发手册（嵩山版）》最新发布，速速下载！][Java]

觉得不错，别忘了随手点赞+转发哦！

[http_cron.qqe2.com]: http://cron.qqe2.com
[https_github.com_javastacks_spring-boot-best-practice]: https://github.com/javastacks/spring-boot-best-practice
[https_github.com_xuxueli_xxl-job]: https://github.com/xuxueli/xxl-job/
[20210621083201672.png]: /images/20221005/5c7c1a8509d34822857f35b1f1faa632.png
[20210621083201845.png]: /images/20221005/802ce34970ce4f9598da2ba72bed58ce.png
[20210621083202336.png]: /images/20221005/18c01d43cc46465ca5d4edb3f080e688.png
[20210621083202728.png]: /images/20221005/a1ed5ed8fc4d41088bd72e8256a04b60.png
[http_localhost_8080_xxl-job-admin]: http://localhost:8080/xxl-job-admin/
[20210621083203198.png]: /images/20221005/865a0b0cc9d04ed3b74f8e81ff15696d.png
[20210621083203513.png]: /images/20221005/c952632308424e55ac2a9feddbfa4ab9.png
[20210621083203819.png]: /images/20221005/0f866b0b4d364a0f92fc6b134e11ff10.png
[http_cron.qqe2.com 1]: http://cron.qqe2.com/
[20210621083204275.png]: /images/20221005/7cdbce17137147ad9d785841df861d1e.png
[20210621083204578.png]: /images/20221005/104db45d47bb426b80ad322f4e5232b0.png
[20210621083204814.png]: /images/20221005/75324f53da86494fa7c9c15db158a1e9.png
[https_blog.csdn.net_qq_41463655_article_details_100839629]: https://blog.csdn.net/qq_41463655/article/details/100839629
[1_000_ _ Java_2021]: https://www.javastack.cn/mst/
[IntelliJ IDEA]: http://www.javastack.cn/article/2020/intellij-idea-by-open-source-project/
[Mock _ Mock]: http://www.javastack.cn/article/2021/alibaba-testable-mock-released/
[Spring Cloud 2020.0.0]: http://www.javastack.cn/article/2020/spring-cloud-2020.0.0-released/
[Java]: http://www.javastack.cn/article/2020/alibaba-release-java-develop-rules-songshan/