国产精品久久九九,国产区在线观看,3p视频在线观看

寫在前面
一、基于注解（@Scheduled）
二、數據庫動態配置
- 1、表數據添加，資源配置
  - 1.1 添加表
  - 1.2 插入兩條數據，job_key根據是完整的類名
  - 1.3 引入依賴
  - 1.4 配置application.yml
- 2、瘋狂貼代碼
  - 2.1 創建定時任務線程池
  - 2.2 項目啟動時初始化定時任務
  - 2.3 定時任務公共接口
  - 2.4 創建兩個定時任務實現類
  - 2.5 定時任務管理接口
  - 2.6 定時任務管理實現類
  - 2.8 上面用到的獲取Bean的工具類SpringContextUtil
  - 2.9 表操作對應的一些類
  - 2.10 修改定時任務的接口
- 3、測試結果
  - 3.1 啟動項目，看下定時任務的執行結果，控制臺輸出結果
  - 3.2 修改任務1的cron參數或者狀態
最后

寫在前面

SpringBoot創建定時任務的方式很簡單，主要有兩種方式：一、基于注解的方式（@Scheduled）二、數據庫動態配置。實際開發中，第一種需要在代碼中寫死表達式，如果修改起來，又得重啟會顯得很麻煩；所以我們往往會采取第二種方式，可以直接從數據庫中讀取定時任務的指定執行時間，無需重啟。

下面就來介紹下這兩種方式吧

一、基于注解（@Scheduled）

基于注解是一種靜態的方式，只需要幾行代碼就可以搞定了

添加一個配置類

@Configuration  //標記配置類
@EnableScheduling   //開啟定時任務
public class MyScheduleConfig {

    //添加定時任務
    @Scheduled(cron = "0/5 * * * * ?")
    private void myTasks() {
        System.out.println("執行定時任務 " + LocalDateTime.now());
    }
}

上面代碼的cron表達式表示每5秒執行一次，可以通過這個網站（http://tools.jb51.net/code/Quartz_Cron_create）去生成要的cron表達式

啟動應用，控制臺看效果

SpringBoot如何實現定時任務示例詳解

這個方式的確很簡單方便，但前面介紹也說到了，有個缺點就是當我們需要去修改定時任務的執行周期或者停止的時候，我們需要到代碼層去修改，重啟。

二、數據庫動態配置

這里使用MySQL數據庫

1、表數據添加，資源配置

1.1 添加表

CREATE TABLE `scheduled_job` (
  `job_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `job_key` varchar(128) NOT NULL COMMENT '定時任務完整類名',
  `cron_expression` varchar(20) NOT NULL COMMENT 'cron表達式',
  `task_explain` varchar(50) NOT NULL DEFAULT '' COMMENT '任務描述',
  `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '狀態,1:正常;-1:停用',
  PRIMARY KEY (`job_id`),
  UNIQUE KEY `job_key` (`job_key`),
  UNIQUE KEY `cron_key_unique_idx` (`job_key`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='定時任務表';

1.2 插入兩條數據，job_key根據是完整的類名

SpringBoot如何實現定時任務示例詳解

1.3 引入依賴


            org.springframework.boot
            spring-boot-starter-web
        
        
        
            mysql
            mysql-connector-java
            5.1.49
            runtime
        
        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.3.1.tmp
        
        
        
            org.projectlombok
            lombok
            1.18.20
            provided

1.4 配置application.yml

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?userUnicode=true&characterEncoding=UTF8&useSSL=false
    username: root
    password: 123
    driver-class-name: com.mysql.jdbc.Driver
server:
  servlet:
    context-path: /demo
  port: 8888

2、瘋狂貼代碼

2.1 創建定時任務線程池

@Configuration
@Slf4j
public class ScheduledConfig {

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        log.info("創建定時任務調度線程池 start");
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(20);
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        log.info("創建定時任務調度線程池 end");
        return threadPoolTaskScheduler;
    }

}

2.2 項目啟動時初始化定時任務

@Slf4j
@Component
public class ScheduledTaskRunner implements ApplicationRunner {
    @Autowired
    private ScheduledTaskService scheduledTaskService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("----初始化定時任務開始----");
        scheduledTaskService.initTask();
        log.info("----初始化定時任務完成----");
    }
}

2.3 定時任務公共接口

public interface ScheduledOfTask extends Runnable{

    void execute();

    @Override
    default void run() {
        execute();
    }
}

2.4 創建兩個定時任務實現類

@Component
@Slf4j
public class TaskJob1 implements ScheduledOfTask{
    @Override
    public void execute() {
        log.info("執行任務1 "+ LocalDateTime.now());
    }
}

@Component
@Slf4j
public class TaskJob2 implements ScheduledOfTask{
    @Override
    public void execute() {
        log.info("執行任務2 "+ LocalDateTime.now());
    }
}

2.5 定時任務管理接口

public interface ScheduledTaskService{

    Boolean start(ScheduledJob scheduledJob);

    Boolean stop(String jobKey);

    Boolean restart(ScheduledJob scheduledJob);

    void initTask();
}

2.6 定時任務管理實現類

@Slf4j
@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {

    /**
     * 可重入鎖
     */
    private ReentrantLock lock = new ReentrantLock();

    /**
     * 定時任務線程池
     */
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    /**
     * 啟動狀態的定時任務集合
     */
    public Map scheduledFutureMap = new ConcurrentHashMap<>();

    @Autowired
    private ScheduledJobService scheduledJobService;

    @Override
    public Boolean start(ScheduledJob scheduledJob) {
        String jobKey = scheduledJob.getJobKey();
        log.info("啟動定時任務"+jobKey);
        //添加鎖放一個線程啟動，防止多人啟動多次
        lock.lock();
        log.info("加鎖完成");

        try {
            if(this.isStart(jobKey)){
                log.info("當前任務在啟動狀態中");
                return false;
            }
            //任務啟動
            this.doStartTask(scheduledJob);
        } finally {
            lock.unlock();
            log.info("解鎖完畢");
        }

        return true;
    }

    /**
     * 任務是否已經啟動
     */
    private Boolean isStart(String taskKey) {
        //校驗是否已經啟動
        if (scheduledFutureMap.containsKey(taskKey)) {
            if (!scheduledFutureMap.get(taskKey).isCancelled()) {
                return true;
            }
        }
        return false;
    }

    @Override
    public Boolean stop(String jobKey) {
        log.info("停止任務 "+jobKey);
        boolean flag = scheduledFutureMap.containsKey(jobKey);
        log.info("當前實例是否存在 "+flag);
        if(flag){
            ScheduledFuture scheduledFuture = scheduledFutureMap.get(jobKey);

            scheduledFuture.cancel(true);

            scheduledFutureMap.remove(jobKey);
        }
        return flag;
    }

    @Override
    public Boolean restart(ScheduledJob scheduledJob) {
        log.info("重啟定時任務"+scheduledJob.getJobKey());
        //停止
        this.stop(scheduledJob.getJobKey());

        return this.start(scheduledJob);
    }

    /**
     * 執行啟動任務
     */
    public void doStartTask(ScheduledJob sj){
        log.info(sj.getJobKey());
        if(sj.getStatus().intValue() != 1)
            return;
        Class clazz;
        ScheduledOfTask task;
        try {
            clazz = Class.forName(sj.getJobKey());
            task = (ScheduledOfTask) SpringContextUtil.getBean(clazz);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("spring_scheduled_cron表數據" + sj.getJobKey() + "有誤", e);
        }
        Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定時任務類必須實現ScheduledOfTask接口");
        ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(task,(triggerContext -> new CronTrigger(sj.getCronExpression()).nextExecutionTime(triggerContext)));
        scheduledFutureMap.put(sj.getJobKey(),scheduledFuture);
    }

    @Override
    public void initTask() {
        List list = scheduledJobService.list();
        for (ScheduledJob sj : list) {
            if(sj.getStatus().intValue() == -1) //未啟用
                continue;
            doStartTask(sj);
        }
    }
}

2.8 上面用到的獲取Bean的工具類SpringContextUtil

@Component
public class SpringContextUtil implements ApplicationContextAware {


    private static ApplicationContext applicationContext = null;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if(SpringContextUtil.applicationContext == null){
            SpringContextUtil.applicationContext  = applicationContext;
        }
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    public static  T getBean(Class clazz){
        return getApplicationContext().getBean(clazz);
    }

    public static  T getBean(String name,Class clazz){
        return getApplicationContext().getBean(name, clazz);
    }
}

2.9 表操作對應的一些類

Pojo

@Data
@TableName("scheduled_job")
public class ScheduledJob {

    @TableId(value = "job_id",type = IdType.AUTO)
    private Integer jobId;

    private String jobKey;

    private String cronExpression;

    private String taskExplain;

    private Integer status;

}

ScheduledJobMapper

public interface ScheduledJobMapper extends BaseMapper {
}

ScheduledJobService

public interface ScheduledJobService extends IService {

    /**
     * 修改定時任務，并重新啟動
     * @param scheduledJob
     * @return
     */
    boolean updateOne(ScheduledJob scheduledJob);
}

@Service
@Slf4j
public class ScheduledJobServiceImpl extends ServiceImpl implements ScheduledJobService{

    @Autowired
    private ScheduledTaskService scheduledTaskService;

    @Override
    public boolean updateOne(ScheduledJob scheduledJob) {
        if(updateById(scheduledJob))
            scheduledTaskService.restart(getById(scheduledJob.getJobId()));
        return true;
    }
}

2.10 修改定時任務的接口

@RestController
@RequestMapping("/job")
public class ScheduledJobController {

    @Autowired
    private ScheduledJobService scheduledJobService;

    @PostMapping(value = "/update")
    public CallBackResult update(HttpServletRequest request, ScheduledJob scheduledJob){
         if(scheduledJobService.updateOne(scheduledJob))
             return new CallBackResult(true,"修改成功");
         return new CallBackResult(false,"修改失敗");
    }

}