Quartz 框架接收 cron表达式后，没有按 cron表达式的任务时间执行而是 每秒执行任务

Quartz 框架接收 cron表达式后，没有按 cron表达式的任务时间执行而是 每秒执行任务
如何改修改

controller

    @PostMapping("startBackup")
    public ResponseData start(@RequestParam("somethingToUse") String somethingToUse,
                              @RequestParam("cron")String cron
                        ){
        System.out.println("=================开始执行=================");
        try{
            jobService.startOrResumeJobBackup(somethingToUse,cron);
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new ErrorResponseData(403,"失败");
        }
        return new SuccessResponseData(200, "成功",true);
    }

job

public class JobBackup extends QuartzJobBean {

    private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) {

        Date now = new Date();
        String currentData = sdf.format(now);
        System.out.println("执行备份脚本定时任务"+currentData);
    }
    
}

@Service
public class JobService {

    @Autowired
    Scheduler scheduler;

    static TriggerKey task1 = new TriggerKey("task1");

    public void startOrResumeJobBackup(String somethingToUse,String cron) throws SchedulerException {
        if (scheduler.getTriggerState(task1).toString() == "PAUSED") {
            scheduler.resumeTrigger(task1);
        } else {

            JobDetail jobDetail = JobBuilder.newJob(JobBackup.class)
                    .usingJobData("somethingToUse",somethingToUse)
                    .build();
            Trigger trigger= TriggerBuilder.newTrigger()
                    .withIdentity(task1)
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            scheduler.scheduleJob(jobDetail,trigger);
        }
    }


    public void pauseJobBackup() throws SchedulerException{
        scheduler.pauseTrigger(task1);
    }
}

传入参数

传入所有cron都是按秒执行

写个测试类，单独执行看看。

public class QuartzTest {
 
 
    public static void main(String[] args) throws SchedulerException{
        //1.调度器（Scheduler）
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        //拿到调度器，调度器只需要一个即可，可以调度多个任务
        Scheduler scheduler = schedulerfactory.getScheduler();
        //2.Job实例（JobDetil）
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job", "default") //name:任务的名称，group：分组名
                .build();
        //3.触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "default") //name:触发器名称，group：分组名
                .startNow() //马上执行一次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))//使用Cron触发器
                .build();
        //4.让Job和触发器关联
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }
 
 
    public static class MyJob implements Job {
 
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            //打印当前时间
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = dateFormat.format(new Date());
            System.out.println(date);
        }
    }
}

你应该是没有设置任务的misfird策略。

下边策略是MISFIRE_INSTRUCTION_DO_NOTHING：目前不执行，然后就按照正常的计划执行。
其他策略可自行百度。

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfiguration {


    // 使用jobDetail包装job
    @Bean
    public JobDetail myCronJobDetail() {
        return JobBuilder.newJob(HelloJob.class).withIdentity("helloJob").storeDurably().build();
    }

    // 把jobDetail注册到Cron表达式的trigger上去
    @Bean
    public Trigger CronJobTrigger() {
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("25 * * * * ? *");
        cronScheduleBuilder.withMisfireHandlingInstructionDoNothing();//设置misfire策略
        return TriggerBuilder.newTrigger()
                .forJob(myCronJobDetail())
                .withIdentity("myCronJobTrigger")
                .withSchedule(cronScheduleBuilder)
                .build();
    }
}

按照你的代码，大概改了一下，测试没啥问题
JobController

@RestController
@RequiredArgsConstructor
public class JobController {
    private final JobService jobService;

    @PostMapping("startBackup")
    public void start(@RequestParam("somethingToUse") String somethingToUse, @RequestParam("cron") String cron) {
        try {
            jobService.startOrResumeJobBackup(somethingToUse, cron);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

}

JobService

@Service
@RequiredArgsConstructor
public class JobService {

    private final Scheduler scheduler;

    static TriggerKey task1 = new TriggerKey("task1");

    public void startOrResumeJobBackup(String somethingToUse,String cron) throws SchedulerException {
        if ("PAUSED".equals(scheduler.getTriggerState(task1).toString())) {
            scheduler.resumeTrigger(task1);
        } else {
            JobDetail jobDetail = JobBuilder.newJob(JobBackup.class)
                    .usingJobData("somethingToUse",somethingToUse)
                    .build();
            Trigger trigger= TriggerBuilder.newTrigger()
                    .forJob(jobDetail)
                    .withIdentity(task1)
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            scheduler.scheduleJob(jobDetail,trigger);
            scheduler.start();
        }
    }


    public void pauseJobBackup() throws SchedulerException {
        scheduler.pauseTrigger(task1);
    }
}

JobBackup

@Slf4j
public class JobBackup implements Job {

    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//    @Override
//    protected void executeInternal(JobExecutionContext jobExecutionContext) {
//        Date now = new Date();
//        String currentData = sdf.format(now);
//        log.info("执行备份脚本定时任务" + currentData);
//    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        Date now = new Date();
        String currentData = sdf.format(now);
        log.info("执行备份脚本定时任务" + currentData);
    }
}

其中使用了一下lombok的注解
如果对您有帮助，麻烦采纳一下回答，谢谢