Spring Boot 中使用定时任务

最新推荐文章于 2023-11-16 16:36:19 发布

非正常编码

最新推荐文章于 2023-11-16 16:36:19 发布

阅读量347

点赞数 2

分类专栏： spring boot 文章标签： spring boot java 定时任务

本文链接：https://blog.csdn.net/HuYiAn1004/article/details/100667731

版权

spring boot 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

静态的定时任务

spring为我们提供了@EnableScheduling和@Scheduled注解。
首先在启动类添加：

//开启定时任务
@EnableScheduling
@SpringBootApplication
public class DemoApplication {

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

}

然后创建一个定时任务：

/**
 * @author 黄豪琦
 * 日期:2019-09-09 11:32
 * 说明:
 */
@Component
@Slf4j
public class FixedPrintTask {

    private static int i = 0;

    @Scheduled(cron = "*/3 * * * * ?")
    public void execute(){
        log.info("固定打印信息" + i++);

    }
}

@Scheduled的参数是一个cron表达式，这里*/3 * * * * ?的意思是每三秒执行一次。如果不会用建议百度学一下或者前往在线cron表达式生成器。
执行效果：
在这里插入图片描述
这种方式简单，但是代码是写死的，要修改只能重启，真实环境肯定是需要动态的。

动态定时任务

首先创建数据库表：

sqlcreate table scheduled_cron
(
    id              int auto_increment
        primary key,
    cron_key        varchar(50)             not null comment '定时任务完整类名',
    cron_expression varchar(50)             not null comment 'corn表达式',
    task_explain    varchar(100) default '' not null comment '任务描述',
    status          int          default 1  not null comment '状态；1正常，2停用',
    constraint cron_key
        unique (cron_key),
    constraint scheduled_cron_cron_key_uindex
        unique (cron_key)
)
    comment '定时任务';

然后用generator生成实体类、mapper映射。
编写service:

package com.example.demo.service.impl;

import com.example.demo.entity.ScheduledCron;
import com.example.demo.mapper.ScheduledCronMapper;
import com.example.demo.service.ScheduledService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 15:53
 * 说明:
 */
@Slf4j
@Component
public class ScheduledServiceImpl implements ScheduledService {


    @Autowired
    private ScheduledCronMapper scheduledCronMapper;

    private List<ScheduledCron> scheduledCronList;

    @PostConstruct
    private void init(){
        this.scheduledCronList = scheduledCronMapper.findAll();
    }

    @Override
    public ScheduledCron findByCronKey(String cronKey) {
    	//在scheduledCronList中根据cronKey找出符合的
        List<ScheduledCron> list = scheduledCronList.stream()
                .filter(cron -> cronKey.equals(cron.getCronKey())).collect(Collectors.toList());
        if (list.isEmpty()) {
            throw new IllegalArgumentException("失败,cronKey有误:" + cronKey);
        }
        return list.get(0);
    }

    @Override
    public List<ScheduledCron> getCronList() {
        return scheduledCronList;
    }

    @Override
    public Integer updateScheduledCron(ScheduledCron scheduledCron) {
        return scheduledCronMapper.updateByPrimaryKeySelective(scheduledCron);
    }
}

为了之后方便，写一个接口：

package com.example.demo.config;


import com.example.demo.entity.ScheduledCron;
import com.example.demo.enums.StatusEnum;
import com.example.demo.service.impl.ScheduledServiceImpl;
import com.example.demo.utils.SpringUtils;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 14:21
 * 说明:
 */
public interface ScheduledOfTask extends Runnable {

    /**
     * 定时任务方法
     */
    void execute();

    @Override
    default void run(){
        //从spring容器中取出service
        ScheduledServiceImpl context = SpringUtils.getBean(ScheduledServiceImpl.class);
        //在service任务列表中 查找当前任务
        ScheduledCron scheduledCron = context.findByCronKey(this.getClass().getName());
        //如果当前任务的状态是以停用 则返回
        if(scheduledCron.getStatus().equals(StatusEnum.DISABLED.getCode())){
            return;
        }
        //执行
        execute();
    }
}

创建定时任务类，实现刚刚的接口：

package com.example.demo.tasks;

import com.example.demo.config.ScheduledOfTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 15:42
 * 说明:
 */
@Slf4j
@Component
public class DynScheduledTask implements ScheduledOfTask {

    private static int i = 0;

    @Override
    public void execute() {
        log.info("定时任务[" + this.getClass().getSimpleName() + "]正在执行中，以执行" + i++ +"次。");
    }
}

execute()方法就是要执行的内容。
向表中插入测试数据：

insert into scheduled_cron(cron_key, cron_expression, task_explain)
values('com.example.demo.tasks.DynScheduledTask','*/3 * * * * ?','定时任务描述1');
insert into scheduled_cron(cron_key, cron_expression, task_explain)
values('com.example.demo.tasks.DynScheduledTask1','*/3 * * * * ?','定时任务描述2');

数据库中cron_key列一定要有对应的类。

编写配置类：

package com.example.demo.config;

import com.example.demo.service.ScheduledService;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 13:51
 * 说明:
 */
@Configuration
public class ScheduledConfig implements SchedulingConfigurer {

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private ScheduledService scheduledService;

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledService.getCronList().forEach(scheduled -> {
        	//这里是一个校验的过程
            Class<?> clazz;
            Object task;
            try {
            	//尝试加载定时任务类
                clazz = Class.forName(scheduled.getCronKey());
                //尝试从spring容器中获取定时任务类对应的bean
                task = applicationContext.getBean(clazz);
            } catch (ClassNotFoundException e) {
                throw new IllegalArgumentException("scheduled_cron表数据" + scheduled.getCronKey() + "有误", e);
            } catch (BeansException e) {
                throw new IllegalArgumentException(scheduled.getCronKey() + "未纳入到spring管理", e);
            }
            //动态注册任务
            scheduledTaskRegistrar.addTriggerTask( ((Runnable) task),
                    triggerContext -> new CronTrigger(scheduled.getCronExpression())
                            .nextExecutionTime(triggerContext));
        });
    }

}

运行查看效果：
在这里插入图片描述
效果已经出来了，可以写个控制器测试是否能动态的修改。

package com.example.demo.controllers;

import com.example.demo.entity.ScheduledCron;
import com.example.demo.service.ScheduledService;
import com.example.demo.utils.CronUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 14:38
 * 说明:
 */
@RestController
@RequestMapping("/task")
public class TaskController {

    @Autowired
    private ApplicationContext context;

    @Autowired
    private ScheduledService scheduledService;


    /**
     * 查看任务列表
     * @return
     */
    @GetMapping("/getTaskList")
    public List<ScheduledCron> getTaskList(){
        return  scheduledService.getCronList();
    }

    /**
     * 编辑任务cron表达式
     *
     * @param cronKey
     * @param newCron
     * @return
     */
    @RequestMapping("/editTaskCron")
    public Integer editTaskCron(String cronKey, String newCron) {
        if (!CronUtils.isValidExpression(newCron)) {
            throw new IllegalArgumentException("失败,非法表达式:" + newCron);
        }
        ScheduledCron scheduledCron = scheduledService.findByCronKey(cronKey);
        scheduledCron.setCronExpression(newCron);
        scheduledService.updateScheduledCron(scheduledCron);
        return 1;
    }

    /**
     * 执行定时任务
     *
     * @param cronKey
     * @return
     * @throws Exception
     */
    @RequestMapping("/runTaskCron")
    public Integer runTaskCron(String cronKey) throws Exception {
        ((Runnable) context.getBean(Class.forName(cronKey))).run();
        return 1;
    }

    /**
     * 启用或禁用定时任务
     *
     * @param status
     * @param cronKey
     * @return
     */
    @RequestMapping("/changeStatusTaskCron")
    public Integer changeStatusTaskCron(Integer status, String cronKey) {
        final ScheduledCron scheduledCron = scheduledService.findByCronKey(cronKey);
        scheduledCron.setStatus(status);
        scheduledService.updateScheduledCron(scheduledCron);
        return 1;

    }
}

用到的工具类以及枚举：
CronUtils

package com.example.demo.utils;

import lombok.extern.slf4j.Slf4j;
import org.quartz.impl.triggers.CronTriggerImpl;

import java.util.Date;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 16:38
 * 说明:
 */
@Slf4j
public class CronUtils {

    public static boolean isValidExpression(final String cronExpression) {
        CronTriggerImpl trigger = new CronTriggerImpl();
        try {
            trigger.setCronExpression(cronExpression);
            Date date = trigger.computeFirstFireTime(null);
            return date != null && date.after(new Date());
        } catch (Exception e) {
            log.error("invalid expression:{},error msg:{}", cronExpression, e.getMessage());
        }
        return false;
    }
}

SpringUtils

package com.example.demo.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @author 黄豪琦
 * 日期:2019-09-09 14:28
 * 说明:
 */
@Component
public class SpringUtils implements ApplicationContextAware {

    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtils.context = applicationContext;
    }

    public static <T> T getBean(Class<T> clz) {
        return context.getBean(clz);
    }

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

    public ApplicationContext getApplicationContext() {
        return context;
    }
}

StatusEnum

package com.example.demo.enums;

public enum StatusEnum {

    ENABLED(1),
    DISABLED(2),
    ;

    private Integer code;

    StatusEnum(int code) {
        this.code = code;
    }

    public Integer getCode() {
        return code;
    }
}