创建定时器任务，并控制定时器任务启动，停止，开机自动启动，线程Run（）方法中调用外部方法。

public class QuartzJobServiceImpl implements IQuartzJobService {
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler;

/**
 * 在ScheduledFuture中有一个cancel可以停止定时任务。
 */
private ScheduledFuture<?> future;

/*存放定时器任务的map，用于启动停止定时器任务*/
public static ConcurrentHashMap<String, ScheduledFuture> map = new ConcurrentHashMap<String, ScheduledFuture>();
/**
 * ThreadPoolTaskScheduler：线程池任务调度类，能够开启线程池进行任务调度。
 * ThreadPoolTaskScheduler.schedule()方法会创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable（线程接口类） 和CronTrigger（定时任务触发器）
 * @return
 */
@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
	return new ThreadPoolTaskScheduler();
}


 /**
	 * @description: 添加定时任务（启动定时任务）
	 * @param jobClassName : 实现Runnable的线程类的包名加类名
	 *                       比如：cn.com.skyvis.hlwft.controller.MyRunnable
	 * @param cronExpression : 定时规则
	 * @return : void
	 */
public void startCron(String jobClassName, String cronExpression) {
	try {
		//
		/*------在开启新线程之前，将servletRequestAttributes设置为子线程共享--------*/
		ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
		RequestContextHolder.setRequestAttributes(sra, true);
		/*---------------------------------------------------------------------*/
		//使用反射获取实现Runnable的线程类
		Class c1 = Class.forName(jobClassName);
		Object o = c1.newInstance();
		future = threadPoolTaskScheduler.schedule((Runnable) o, new 			org.springframework.scheduling.support.CronTrigger(cronExpression));
		//这里把实现Runnable的线程类的包名加类名作为了key，启动的任务作为value。
		map.put(jobClassName,future);
		System.out.println("DynamicTaskController.startCron()");
	}catch (Exception e) {
		//报错说明没有这个继承Runnable的类。
		throw new JeecgBootException("后台找不到该类名：" + jobClassName, e);
	}
}

	/**
	 * @description: Task停止定时器任务
	 * @param jobClassName : 实现Runnable的线程类的包名加类名
	 * @return : void
	 */
	@Override
	public void pause(String jobClassName) {
		//通过获得实现Runnable的线程类的包名加类名key，让其停止掉。
		ScheduledFuture scheduledFuture = map.get(jobClassName);
		if (scheduledFuture != null) {
			scheduledFuture.cancel(true);
		}
	}

/**
 * @description: 删除定时任务
 * @param jobClassName : 实现Runnable的线程类的包名加类名
 * @return : void
 */
private void TaskDelete(String jobClassName) {
	try {
		//停止定时任务
		pause(jobClassName);
		//从map中删除定时任务
		map.remove(jobClassName);
	} catch (Exception e) {
		log.error(e.getMessage(), e);
		throw new JeecgBootException("删除定时任务失败");
	}
}

/**
 * 编辑&启停定时任务
 * @throws SchedulerException 
 */
@Override
public void editAndScheduleJob(QuartzJob quartzJob) throws SchedulerException {
//判断当前包加类名是否有修改过。
//如果没有修改过，那么就停止任务后，再根据定时规则从新启动任务。
//如果有修改过，那么就停止原来定时任务，并删除原来定时任务，根据新的包加类名和新的定时规则启动任务。
	if (quartzJob.getJobClassNameData().trim().equals(quartzJob.getJobClassName().trim()) {
				pause(quartzJob.getJobClassName().trim());
				startCron(quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
			}else {
				pause(quartzJob.getJobClassNameData().trim());
				map.remove(quartzJob.getJobClassNameData().trim());
				startCron(quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
			}
}
}

/*
实现Runnable的类。测试任务。
*/
package cn.com.skyvis.hlwft.controller;

import cn.com.skyvis.hlwft.service.GroupDemoFeignService;
import lombok.extern.log4j.Log4j2;
import org.jeecg.common.util.SpringContextUtils;

import java.util.Date;
public class MyRunnable implements Runnable {

    public void run() {
    	//GroupDemoFeignService这个是接口类
        GroupDemoFeignService bean = SpringContextUtils.getBean(GroupDemoFeignService.class);
        //SynchronousData()这是接口类中的方法
 		bean.SynchronousData();
    }
}

/*
此类用来解决线程Run（）方法中不能注入service调用外部方法使用。
*/
@Component
public class SpringContextUtils implements ApplicationContextAware {

	/**
	 * 上下文对象实例
	 */
	private static ApplicationContext applicationContext;

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

	/**
	 * 获取applicationContext
	 *
	 * @return
	 */
	public static ApplicationContext getApplicationContext() {
		return applicationContext;
	}

	/**
	 * 通过name获取 Bean.
	 *
	 * @param name
	 * @return
	 */
	public static Object getBean(String name) {
		return getApplicationContext().getBean(name);
	}

	/**
	 * 通过class获取Bean.
	 *
	 * @param clazz
	 * @param       <T>
	 * @return
	 */
	public static <T> T getBean(Class<T> clazz) {
		return getApplicationContext().getBean(clazz);
	}

	/**
	 * 通过name,以及Clazz返回指定的Bean
	 *
	 * @param name
	 * @param clazz
	 * @param       <T>
	 * @return
	 */
	public static <T> T getBean(String name, Class<T> clazz) {
		return getApplicationContext().getBean(name, clazz);
	}
}

/*
开机直接启动定时任务。
*/
@Component
public class ApplicationTask implements ApplicationRunner {
	//这是定时任务接口类。
    @Autowired
    private IQuartzJobService quartzJobService;

    @Override
    public void run(ApplicationArguments applicationArguments) throws Exception {
        //需要执行的方法，调用接口中的startCron()方法启动定时任务。
        //每五秒钟执行一次.这个数据可以保存在数据库。修改数据库每次开机直接启用。
        quartzJobService.startCron("cn.com.skyvis.hlwft.controller.MyRunnable","1/5 * * * * ?",null);
        System.out.println("执行开机启动项目");
    }
}