JAVA手动传参执行定时任务

配置

定时任务执行的包装类

package com.imot.config;
import java.util.concurrent.ScheduledFuture;
/**

• ClassName:
• Description:定时任务执行的包装类
• @author Chen
  */

public class ScheduledFutureHolder {
    private ScheduledFuture<?> scheduledFuture;

    private Class<? extends Runnable> runnableClass;

    private String corn;

    public ScheduledFuture<?> getScheduledFuture() {
        return scheduledFuture;
    }

    public void setScheduledFuture(ScheduledFuture<?> scheduledFuture) {
        this.scheduledFuture = scheduledFuture;
    }

    public Class<? extends Runnable> getRunnableClass() {
        return runnableClass;
    }

    public void setRunnableClass(Class<? extends Runnable> runnableClass) {
        this.runnableClass = runnableClass;
    }

    public String getCorn() {
        return corn;
    }

    public void setCorn(String corn) {
        this.corn = corn;
    }

    @Override
    public String toString() {
        return "ScheduledFutureHolder{" +
                "scheduledFuture=" + scheduledFuture +
                ", runnableClass=" + runnableClass +
                ", corn='" + corn + '\'' +
                '}';
    }
}

定时任务初始化类（可用于传参）

package com.imot.scheduledTask;

import com.imot.service.ArithmeticTaskService;
import com.imot.utils.BeanUtils;

/**

• ClassName:
• Description:
• @author Chen
  */

public class StartScheduledTaskById implements Runnable{

    //注入service
    private final ArithmeticTaskService service = BeanUtils.getBean(ArithmeticTaskService.class);

    private String taskId;

    public void set(String taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        int id = Integer.parseInt(taskId);
        //service层执行任务
        service.startById(id);
    }
}

通用结果返回类

package com.imot.pojo.entity;

import com.imot.pojo.enums.AppHttpCodeEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;

/**

• 通用的结果返回类
• @author Chen
  */

@Data
@ApiModel("通用的结果返回类")
public class ResponseResult<T> implements Serializable {
    /**
     * 返回码
     */
    @ApiModelProperty("返回码")
    private Integer code;
    /**
     * 错误提示
     */
    @ApiModelProperty("错误提示")
    private String errorMessage;
    /**
     * 返回数据
     */
    @ApiModelProperty("返回数据")
    private T data;

    public ResponseResult() {
        this.code = AppHttpCodeEnum.SUCCESS.getCode();
    }

    public ResponseResult(Integer code, T data) {
        this.code = code;
        this.data = data;
    }

    public ResponseResult(Integer code, String msg) {
        this.code = code;
        this.errorMessage = msg;
    }

    public static ResponseResult okResult() {
        return okResult(null);
    }
    
    public static ResponseResult errorResult(int code, String msg) {
        return new ResponseResult(code, msg);
    }
}

Controller层

package com.imot.controller;

import com.imot.annotation.RequiresPermission;
import com.imot.config.ScheduledFutureHolder;
import com.imot.pojo.dto.ArithmeticTaskPageDTO;
import com.imot.pojo.entity.ArithmeticTask;
import com.imot.pojo.entity.ResponseResult;
import com.imot.pojo.myenum.SystemSecurity;
import com.imot.scheduledTask.StartScheduledTaskById;
import com.imot.service.ArithmeticTaskService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ScheduledFuture;

@Slf4j
@RestController
@RequestMapping(“/api/startScheduledTask”)
public class StartScheduledTaskController {
@Autowired
private ArithmeticTaskService service;
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler;
//存储任务执行的包装类
private HashMap<String, ScheduledFutureHolder> scheduleMap = new HashMap<>();

定时启动任务

/**

• 定时启动任务
• 如果不想手动触发任务可以使用 @PostConstruct注解来启动
  */

@ApiOperation("根据算法任务ID启动定时任务")
@PostMapping("/startSchedule")
public ResponseResult startScheduledTaskById(@RequestParam @ApiParam("corn表达式") String corn,
                                             @RequestParam @ApiParam("任务id") Integer id) {
    try {
        //任务ID转String
        String taskId = id.toString();

        //初始化一个任务（这里可以初始化多个）
        StartScheduledTaskById task = new StartScheduledTaskById();
        task.set(taskId);
        //将任务交给任务调度器执行（即执行初始化类中封装的service层任务）
        ScheduledFuture<?> schedule = threadPoolTaskScheduler.schedule(task, new CronTrigger(corn));
        //将任务包装成ScheduledFutureHolder
        ScheduledFutureHolder scheduledFutureHolder = new ScheduledFutureHolder();
        scheduledFutureHolder.setScheduledFuture(schedule);
        scheduledFutureHolder.setRunnableClass(task.getClass());
        scheduledFutureHolder.setCorn(corn);
        //scheduledFutureHolder.getRunnableClass().getName() + id
        scheduleMap.put(taskId, scheduledFutureHolder);

        log.info("启动定时任务 " + taskId);
        return ResponseResult.okResult(taskId);
    } catch (Exception e) {
        log.error("定时任务启动失败", e);
    }
    return ResponseResult.errorResult(501, "启动失败");
}

查询所有的任务

/**

• 查询所有的任务
  */

@ApiOperation("查询所有进行中的定时任务")
@GetMapping("/querySchedule")
public ResponseResult querySchedule() {
    HashMap<String, String> map = new HashMap<>();
    scheduleMap.forEach((k, v) -> {
        System.out.println(k + "  " + v);
        map.put(k, v.getCorn());
    });
    return ResponseResult.okResult(map);
}

停止任务

/**

• 停止任务
• @param taskId 任务id(字符串类型)
  */

@ApiOperation("根据定时任务名停止定时任务")
@GetMapping("/stopSchedule/{taskId}")
public void stopScheduledTaskByName(@PathVariable String taskId) {
    if (scheduleMap.containsKey(taskId)) {//如果包含这个任务
        ScheduledFuture<?> scheduledFuture = scheduleMap.get(taskId).getScheduledFuture();
        if (scheduledFuture != null) {
            scheduledFuture.cancel(true);
            //更新任务状态
            int id = Integer.parseInt(taskId);
            ArithmeticTask task = service.getById(id);
            task.setStatus(0);
            service.updateById(task);
            log.info("停止定时任务 " + taskId);
        }
    }

}