定時任務的 5 種創建方式,還有誰不會!!

2022-02-02 Java技術棧

支持生成定時任務表達式和反解析，使用Quartz表達式的定時任務如下：

一、定時任務的五種創建方式
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">/**
  * 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();
        }
    }
}
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">/**
 * 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);
    }
}
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">/**
  * 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);
        }
}
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">1、引入maven依賴
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2"><dependencies>
  <!-- quartz -->
     <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>
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">2、任務調度類
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("quartz MyJob date:" + System.currentTimeMillis());
    }
}
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">3、啟動類
     <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 註解' data-itemshowtype="0" tab="innerlink" data-linktype="2">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();
    }
@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 類型，所有定時任務通過任務調度平臺分發，也可配置負載均衡等等
第一步: github下載源碼導入
下載地址：https://github.com/xuxueli/xxl-job/
當前版本目錄結構 2.1.1
Spring Boot 基礎教程就不介紹了，推薦看這裡：https://github.com/javastacks/spring-boot-best-practice
第二步: 執行sql
文件地址：xxl-job/doc/db/tables_xxl_job.sql
當前2.1.1版本sql
第三步: 修改xxl-job-admin項目配置
配置文件：application.properties
修改資料庫連接，另外，Spring Boot 系列面試題和答案全部整理好了，微信搜索Java技術棧，在後臺發送：面試，可以在線閱讀。
第四步: 啟動admin項目
springboot 方式啟動項目
訪問 http://localhost:8080/xxl-job-admin/
帳號密碼：admin / 123456
任務調度中心就搭建好了，《 Spring Boot 學習筆記》分享給你。
接下來需要創建一個伺服器連接任務調度中心。
三、自創建boot項目的任務xxl-job
創建一個 boot 項目
我的目錄結構
pom.xml
web核心及 xxl-job-core
<!-- spring-boot-starter-web (spring-webmvc + tomcat) -->
<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>

<!-- xxl-job-core 版本號根據自己下載的版本修改 -->
<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 加入配置
需修改或自定義
# 埠號
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 後臺配置
執行管理器下
任務管理下編輯任務
定時規則生成：http://cron.qqe2.com/
job任務名：@JobHandler註解值 >> 如:@JobHandler(value=「demoJobHandler」)
啟動
這樣就配置完成了
原文連結：https://blog.csdn.net/qq_41463655/article/details/100839629
版權聲明：本文為CSDN博主「兮家小二」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處連結及本聲明。

相關焦點

  • Java定時任務的五種創建方式,你都會麼?
    ，使用Quartz表達式的定時任務如下一、job 定時任務的五種創建方式/**  * TODO  使用線程創建 job 定時任務  * @author 王松  */public class JobThread {    public static class Demo01 {
  • 我有 10 種方法搞定定時任務,10種!
    前言最近有幾個讀者私信給我，問我他們的業務場景，要用什麼樣的定時任務。確實，在不用的業務場景下要用不同的定時任務，其實我們的選擇還是挺多的。我今天給大家總結10種非常實用的定時任務，總有一種是適合你的。
  • 學會這 10 種定時任務,我有點飄了
    前言在不用的業務場景下要用不同的定時任務，其實我們的選擇還是挺多的。本文總結了 10 種非常實用的定時任務，總有一種是適合你的。一. linux 自帶的定時任務crontab不知道你有沒有遇到過這種場景：有時需要臨時統計線上的數據，然後導出到 excel 表格中。
  • PHP實現執行定時任務的幾種思路詳解
    本文，我們就來深入的解析幾種常見的php定時任務的思路。Linux伺服器上使用CronTab定時執行php我們先從相對比較複雜的伺服器執行php談起。伺服器上安裝了php，就可以執行php文件，無論是否安裝了nginx或Apache這樣的伺服器環境軟體。而Linux中，使用命令行，用CronTab來定時任務，又是絕佳的選擇，而且也是效率最高的選擇。
  • Python開發:Win10創建定時任務執行Python腳本
    日常開發過程中，可能需要再特定時間段執行我們編寫的Python腳本，如果手動輸入執行執行，會產生頻繁的工作量，對於這種情況，在Win10環境下創建任務計劃程序
  • Python 實現定時任務的八種方案!
    在日常工作中，我們常常會用到需要周期性執行的任務，一種方式是採用 Linux 系統自帶的 crond 結合命令行實現。另外一種方式是直接使用Python。接下來整理的是常見的Python定時任務的實現方式。
  • SpringBoot定時任務:schedule、quartz
    Scheduled只適合處理簡單的計劃任務，不能處理分布式計劃任務。優勢：是spring框架提供的計劃任務，開發簡單，執行效率比較高。且在計劃任務數量太多的時候，可能出現阻塞，崩潰，延遲啟動等問題。Scheduled定時任務是spring3.0版本之後自帶的一個定時任務。
  • 為什麼你的 Spring Task 定時任務沒有定時執行?
    前言定時任務的使用，在開發中可謂是家常便飯了，定時發送郵件、簡訊。 避免資料庫，數據表過大，定時將數據轉儲。通知、對帳等等。當然實現定時任務的方式也有很多，比如使用 linux 下的 contab 腳本，jdk 中自帶的 Timer 類。
  • Java定時任務調度詳解
    前面已經提及到Timer背後是一個單線程，因此Timer存在管理並發任務的缺陷：所有任務都是由同一個線程來調度，所有任務都是串行執行，意味著同一時間只能有一個任務得到執行，而前一個任務的延遲或者異常會影響到之後的任務。其次，Timer的一些調度方式還算比較簡單，無法適應實際項目中任務定時調度的複雜度。
  • Python定時任務(上)
    其一：定時執行任務。例如每天早上 8 點定時推送早報。其二：每隔一個時間段就執行任務。比如：每隔一個小時提醒自己起來走動走動，避免長時間坐著。今天，我跟大家分享下 Python 定時任務的實現方法。第一種辦法是最簡單又最暴力。
  • 初探SpringBoot整合Quartz定時任務
    定時任務有很多實現的方式，包括timer，timertask，scheduledexecutorservice，以及第三方框架Quartz。本篇文章主要介紹SpringBoot整合Quartz實現動態定時任務。1、Quartz是功能強大的開源作業調度庫，可以創建簡單或複雜的計劃，可以運行十個，百個，甚至幾萬個Jobs這樣複雜的日程序表。
  • 實戰Spring Boot 2.0系列:單機定時任務的幾種實現
    前言定時任務一般會存在 中大型企業級 項目中，為了減少 伺服器、資料庫 的壓力，往往會以 定時任務 的方式去完成某些業務邏輯。還有就是 報表的生成，我們一般會在客戶 訪問量小時完成這個操作，也可以採用 定時任務 來完成。
  • 定時任務實現原理詳解
    一、摘要在很多業務的系統中，我們常常需要定時的執行一些任務，例如定時發簡訊、定時變更數據、定時發起促銷活動等等。在上篇文章中，我們簡單的介紹了定時任務的使用方式，不同的架構對應的解決方案也有所不同，總結起來主要分單機和分布式兩大類，本文會重點分析下單機的定時任務實現原理以及優缺點，分布式框架的實現原理會在後續文章中進行分析。
  • Java中創建對象的5種方式
    Java中有5種創建對象的方式，下面給出它們的例子還有它們的字節碼使用new關鍵字} → 調用了構造函數使用Class類的newInstance方法} → 調用了構造函數使用Constructor類的newInstance方法} → 調用了構造函數使用clone方法} → 沒有調用構造函數使用反序列化} → 沒有調用構造函數如果你運行了末尾的的程序，你會發現方法1,2,3
  • PHP在Linux下執行定時任務的實現思路詳解
    好了，已經添加了幾條需要的定時任務了吧。點擊鍵盤上的Esc鍵，輸入「:wq」回車，這樣就保存了設置的定時任務，屏幕上也能看到提示創建了新的定時任務。接下來就是好好寫你的script.php了。利用這個特性，我們在正常的程序流中加入fsockopen，對上面我們創建的這個定時任務php的地址發出請求，即可讓定時任務在後臺執行。
  • VUTLR定時創建快照(Take Snapshot)備份伺服器
    具體思路利用VULTR的API功能，用Centos7的crontab定時任務功能，定時請求來達到定時創建快照（Snapshot）的目的。複製API key和伺服器ID連接到伺服器，將任務添加到crontab定時執行即可詳細步驟開啟API
  • Spring 定時任務玩出花!
    當有一個新的定時任務需要執行時，創建一個 SchedulingRunnable 線程，然後連同 Cron 表達式一起扔到 ThreadPoolTaskScheduler 池子裡去執行就行了。3. 配置分析幾個配置類我們逐一來分析。
  • Python實現定時執行任務的三種方式簡單示例
    本文實例講述了Python實現定時執行任務的三種方式。分享給大家供大家參考，具體如下： 1.定時任務代碼 2.周期性執行任務
  • java的線程創建方式
    Thread類java語言中的Thread類是一個基本的線程類，用於創建線程、中斷線程、獲取線程的基本信息、運行狀態等。我們首先了解下利用Thread類創建線程實例的二種方式。繼承Thread類創建線程//繼承Thread實現自己的線程類class MyThread extends Thread{//重寫run方法，給線程賦予工作任務 @Override public void run() { //任務內容…… System.out.println("當前線程是："+Thread.currentThread
  • Java從源碼角度分析創建線程池究竟有哪些方式
    有些童鞋一直在使用線程池，但是，對於如何創建線程池僅僅停留在使用Executors工具類的方式，那麼，創建線程池究竟存在哪幾種方式呢？就讓我們一起從創建線程池的源碼來深入分析究竟有哪些方式可以創建線程池。