Spring boot基于ScheduledFuture实现前端动态控制定时器开启关闭执行service层业务逻辑

使用的是swagger2进行前端接口测试

pom坐标

 <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

TaskController

package com.haitai.controller;

import com.haitai.common.TaskConfiguration;
import com.haitai.utils.RunnableEPE;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.core.config.Scheduled;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.concurrent.ScheduledFuture;

@Slf4j
@Controller
@Api(tags = "定时任务")
@RequestMapping("/task")
public class TaskController {
    @Autowired
    private TaskConfiguration TaskConfiguration;
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    private ScheduledFuture<?> future1;
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    @RequestMapping(value ="start",method = RequestMethod.POST)
    @ApiOperation(value = "开启定时任务", httpMethod = "POST")
    @ResponseBody
    public void startCron1() {
        future1 = threadPoolTaskScheduler.schedule(new RunnableEPE(),new Trigger(){
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext){
                return new CronTrigger(TaskConfiguration.getCorn1()).nextExecutionTime(triggerContext);
            }
        });
    }
    @RequestMapping(value ="stop",method = RequestMethod.POST)
    @ApiOperation(value = "关闭定时任务", httpMethod = "POST")
    @ResponseBody
    public void stopCron1() {
        System.out.println("stop!!!!!!!!!!!!!!!!!!!!!!!");
        if (future1 != null) {
            future1.cancel(true);
        }
    }
}

application.properties配置类，可配置多个定时任务时间，我这里就配置了一个

#自定义定时器时间
task.corn1=0/1 * * * * ?

TaskConfiguration获取properties中的定时时间

package com.haitai.common;


import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "task")
@EqualsAndHashCode(callSuper = false)
public class TaskConfiguration {
    private String corn1;
    private String corn2;
}

RunnableUtil工具类

package com.haitai.utils;

import com.haitai.service.TaskService;
import com.haitai.service.impl.TaskServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;


@Component//将工具类声明为spring组件
public class RunnableUtil implements Runnable {
    @Autowired
    TaskService taskService;
    //静态初使化当前类
    public static RunnableUtil runnableUtil;
    //    @PostConstruct注解好多人以为是Spring提供的。其实是Java自己的注解。
    //    Java中该注解的说明：@PostConstruct该注解被用来修饰一个非静态的void（）方法。被、、、@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行，init（）方法之前执行。
    //    通常我们会是在Spring框架中使用到@PostConstruct注解 该注解的方法在整个Bean初始化中的执行顺序：
    //    Constructor(构造方法) -> @Autowired(依赖注入) -> @PostConstruct(注释的方法)
    //    应用：在静态方法中调用依赖注入的Bean中的方法。
    @PostConstruct
    public void init() {
        runnableUtil = this;
        runnableUtil.taskService = this.taskService;
    }
    @Override
    public void run() {
        try {
            runnableUtil.taskService.startEPE();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

TaskService业务接口

package com.haitai.service;

public interface TaskService {
    void startEPE();
}

TaskServiceImpl业务接口实现类

package com.haitai.service.impl;

import com.haitai.service.TaskService;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;

@Service
public class TaskServiceImpl implements TaskService{
    @Override
    public void startEPE() {
        //业务逻辑代码
        System.out.println("first DynamicTask，" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

执行结果：