quartz定时任务

最新推荐文章于 2024-04-09 19:37:49 发布
最新推荐文章于 2024-04-09 19:37:49 发布
阅读量155 收藏
点赞数
文章标签： python pandas 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Health_C/article/details/125409411
版权

记录一下quartz的配置。

一、QuartzConfigration配置文件

import java.util.Properties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfigration {
   
   /**  
     * attention:  
     * Details：定义quartz调度工厂  
     */    
    @Bean(name = "schedulerSQL")
    public SchedulerFactoryBean schedulerFactory() {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();

        //quartz参数
        Properties prop = new Properties();
        prop.put("org.quartz.scheduler.instanceName", "CraftsoftScheduler");
        prop.put("org.quartz.scheduler.instanceId", "AUTO");
        //线程池配置
        prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        prop.put("org.quartz.threadPool.threadCount", "20");
        prop.put("org.quartz.threadPool.threadPriority", "5");
        //JobStore配置
        prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        //集群配置
        prop.put("org.quartz.jobStore.isClustered", "true");
        prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
        prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");

        prop.put("org.quartz.jobStore.misfireThreshold", "12000");
        prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");

        bean.setSchedulerName("CraftScheduler");
        //延时启动
        bean.setStartupDelay(5);
        bean.setApplicationContextSchedulerContextKey("applicationContextKey");
        //可选，QuartzScheduler 启动时更新己存在的Job
        bean.setOverwriteExistingJobs(true);
        //设置自动启动，默认为true
        bean.setAutoStartup(true);
        return bean;    
    }    
   
}

二、QuartzManager

import com.craftsman.modules.job.entity.ScheduleJobEntity;
import org.quartz.*;

public class QuartzManager {

    /**
     * 创建任务调度
     */
    public static void create(Scheduler scheduler, ScheduleJobEntity jobEntity) {

        try {
            //生成KEY
            JobKey jobkey = new JobKey(jobEntity.getJobKey());
            TriggerKey triggerKey = new TriggerKey(jobEntity.getJobKey());

            JobDetail jobDetail = JobBuilder.newJob(ScheduleJob.class).withIdentity(jobkey).build();
            //构建一个表达式,失效后再恢复并立即执行
            CronScheduleBuilder schedBuilder = CronScheduleBuilder.cronSchedule(jobEntity.getCronExpression()).withMisfireHandlingInstructionDoNothing();
            //构建一个trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(schedBuilder).build();
            //放入对象
            jobDetail.getJobDataMap().put(ScheduleJobEntity.JOB_PARAMS_KEY, jobEntity);

            //注册触发器
            scheduler.scheduleJob(jobDetail, trigger);

            //暂停任务
            if (jobEntity.getStatus() == 1) {
                pause(scheduler, jobEntity);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 修改调度任务
     */
    public static void modify(Scheduler scheduler, ScheduleJobEntity jobEntity) {
        TriggerKey triggerKey = new TriggerKey(jobEntity.getJobKey());

        try {
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            CronScheduleBuilder schedBuilder = CronScheduleBuilder.cronSchedule(jobEntity.getCronExpression()).withMisfireHandlingInstructionDoNothing();
            //重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(schedBuilder).build();
            //放入对象
            trigger.getJobDataMap().put(ScheduleJobEntity.JOB_PARAMS_KEY, jobEntity);

            scheduler.rescheduleJob(triggerKey, trigger);

            //暂停任务
            if (jobEntity.getStatus() == 1) {
                pause(scheduler, jobEntity);
            }

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除调度任务
     */
    public static void delete(Scheduler scheduler, ScheduleJobEntity jobEntity) {
        try {
            scheduler.deleteJob(JobKey.jobKey(jobEntity.getJobKey()));
            System.out.println("删除调度任务");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 运行调度任务
     */
    public static void run(Scheduler scheduler, ScheduleJobEntity jobEntity) {
        try {
            //参数
            JobDataMap dataMap = new JobDataMap();
            dataMap.put(ScheduleJobEntity.JOB_PARAMS_KEY, jobEntity);
            scheduler.triggerJob(new JobKey(jobEntity.getJobKey()), dataMap);
            System.out.println("运行调度任务");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 暂停调度任务
     */
    public static void pause(Scheduler scheduler, ScheduleJobEntity jobEntity) {
        try {
            scheduler.pauseJob(new JobKey(jobEntity.getJobKey()));
            System.out.println("暂停调度任务");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 恢复调度任务
     */
    public static void resume(Scheduler scheduler, ScheduleJobEntity jobEntity) {
        try {
            scheduler.resumeJob(new JobKey(jobEntity.getJobKey()));
            System.err.println("恢复调度任务");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

}

三、ScheduleJob

import com.craftsman.modules.job.entity.ScheduleJobEntity;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class ScheduleJob extends QuartzJobBean {

   private final Logger log = LoggerFactory.getLogger(ScheduleJob.class);

   private ExecutorService service = Executors.newSingleThreadExecutor();

   @Override
   protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
      //根据主键获取job对象
      ScheduleJobEntity jobEntity = (ScheduleJobEntity)context.getMergedJobDataMap().get(ScheduleJobEntity.JOB_PARAMS_KEY);

      //任务开始时间
      long startTime = System.currentTimeMillis();

      ScheduleRunnable schedule = new ScheduleRunnable(jobEntity);
      Future<?> future = service.submit(schedule);

      try {
         //通过获取线程结果来捕获异常
         future.get();
         //任务总计时间
         long times = System.currentTimeMillis() - startTime;
         log.debug("执行完成，耗时:" + times / 1000f + "s");
      } catch (InterruptedException e) {
         log.error("任务执行失败,失败原因:" + e.getMessage());
      } catch (ExecutionException e) {
         log.error("任务执行失败,失败原因:" + e.getMessage());
      }
   }

}

四、ScheduleRunnable

import com.craftsman.common.utils.SpringContextUtils;
import com.craftsman.modules.job.entity.ScheduleJobEntity;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;


public class ScheduleRunnable implements Runnable {

   private ScheduleJobEntity jobEntity;

   public ScheduleRunnable(ScheduleJobEntity jobEntity) {
      this.jobEntity = jobEntity;
   }

   @Override
   public void run() {
      //利用反射执行bean中的方法
      try {
         Object target = SpringContextUtils.getBean(jobEntity.getBeanName());
         Object params = jobEntity.getParams();
         Method method = null;
         if (null != params && !params.equals("")) {
            method = target.getClass().getDeclaredMethod(jobEntity.getMethodName(), params.getClass());
            ReflectionUtils.makeAccessible(method);
            method.invoke(target, params);
         } else {
            method = target.getClass().getDeclaredMethod(jobEntity.getMethodName());
            ReflectionUtils.makeAccessible(method);
            method.invoke(target);
         }
         
      } catch (NoSuchMethodException e) {
         throw new RuntimeException("执行任务调度异常,找不到执行方,详细:" + e.getMessage());
      } catch (SecurityException e) {
         throw new RuntimeException("执行任务调度异常,详细:" + e.getMessage());
      } catch (IllegalAccessException e) {
         throw new RuntimeException("执行任务调度异常,详细:" + e.getMessage());
      } catch (IllegalArgumentException e) {
         throw new RuntimeException("执行任务调度异常,详细:" + e.getMessage());
      } catch (InvocationTargetException e) {
         throw new RuntimeException("执行任务调度异常,详细:" + e.getMessage());
      }
   }

}

五、ScheduleJobEntity

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.util.Date;

@TableName(value = "SCHEDULE_JOB")
public class ScheduleJobEntity {

   /**
    * 任务运行
    */
   public static final int SCHEDULE_JOB_RUN = 0;

   /**
    * 任务停止
    */
   public static final int SCHEDULE_JOB_STOP = 1;

   /**
    * 传递参数的KEY
    */
   public static String JOB_PARAMS_KEY = "JOB_PARAMS_KEY";

   @TableId
   private String id;
   
   /**
    * 名称
    */
   private String name;
   
   /**
    * 时间表达式
    */
   private String cronExpression;
   
   /**
    * bean名称
    */
   private String beanName;
   
   /**
    * 方法名称
    */
   private String methodName;
   
   /**
    * 参数(可以使用json格式)
    */
   private Object params;
   
   /**
    * 状态 0 运行 1暂停
    */
   private int status;

   /**
    * 创建时间
    */
   private Date createTime;

   /**
    * 备注
    */
   private String remark;


   public String getId() {
      return id;
   }

   public void setId(String id) {
      this.id = id;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public String getCronExpression() {
      return cronExpression;
   }

   public void setCronExpression(String cronExpression) {
      this.cronExpression = cronExpression;
   }

   public String getBeanName() {
      return beanName;
   }

   public void setBeanName(String beanName) {
      this.beanName = beanName;
   }

   public String getMethodName() {
      return methodName;
   }

   public void setMethodName(String methodName) {
      this.methodName = methodName;
   }

   public Object getParams() {
      return params;
   }

   public void setParams(Object params) {
      this.params = params;
   }

   public int getStatus() {
      return status;
   }

   public void setStatus(int status) {
      this.status = status;
   }

   public Date getCreateTime() {
      return createTime;
   }

   public void setCreateTime(Date createTime) {
      this.createTime = createTime;
   }

   public String getRemark() {
      return remark;
   }

   public void setRemark(String remark) {
      this.remark = remark;
   }

   /**
    * 获取job key
    * @return
    */
   public String getJobKey() {
      return this.beanName + "_" + this.id;
   }
   
}

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

Health_C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java学习之多线程
qq_40523277的博客
09-11 92
目录 同步&&异步 并发&&并行 多线程技术： 线程技术———接口方法 对比多线程技术中两个方法（Thread / Runnable）Runnable所具有的优势： 设置获取线程名称和线程休眠方法 守护线程： 线程安全问题： 显式锁和隐式锁的区别： 线程池： 同步&&异步 同步：排队执行效率低但是安全； 异步：同时执行效率高但是数据不安全； 并发&&并行 并发：两个或两个以上事件在同一时间段内发生； ..
【一】Quartz定时任务
mengyb个人文档记录
12-30 2867
对Quartz技术的基本介绍以及简单运用
Quartz定时任务
Flying_Fish_roe的博客
03-25 933
Quartz可以根据时间表达式自动调度任务的执行，支持复杂的调度周期和时间间隔。可以设置固定时间点、每天、每周、每月等多种调度方式。Quartz可以同时管理多个任务，每个任务都有自己的调度配置，可以独立执行。可以实现任务的串行、并行、按顺序执行等灵活的调度策略。Quartz支持多种任务触发方式，包括时间触发、手动触发、系统启动触发等。可以根据需求自由选择任务触发方式。Quartz提供了故障恢复机制，可以在任务执行失败或调度器崩溃后自动恢复任务的执行状态。
多线程学习（2）：ScheduledThreadPoolExecutor 与 schedule 之小结
Diligence is the mother of success.
07-29 4257
2018年7月9日08:48:58 【1】前言 线程池与任务定时执行，一是项目随处可见的一种技术，二是自己还需打打扎实基础；不可以仅仅局限于业务的实现，要去体会底层的思想； 【2】关于线程池ThreadPoor与Timer的使用 2.1 Java提供的Time类可以周期性地或者延期执行任务，但是有时我们需要并行执行同样的任务，这个时候如果创建多个Time对象会给系...
定时任务框架Quartz
m0_53151031的博客
02-11 8364
一、spring自带调度器 二、Quartz集成 三、Quartz内存版基本使用
Java多线程案例——定时器
如风暖阳的博客
05-09 872
Java多线程案例——定时器
C# 控制台Quartz定时任务.doc
07-13
Quartz定时任务
java quartz 定时任务
06-01
使用quartz实现的java 定时任务，通过写cron表达式，让任务在制定时刻触发执行。
Quartz定时任务框架
12-17
Quartz定时任务框架，本次小白使用它实现一个简单的定时任务。每隔3秒打印一次Hello。这个是例子的jar包，实现过程在博客首页可看到。
java定时任务quartz的基本实现
09-27
自留demo，java定时任务quartz的基本实现，对应博客https://blog.csdn.net/jing12062011/article/details/82758536
定时任务设置及实现quartz
01-10
quartz定时任务 包括定时邮件，本地执行文件等。
2.Quartz定时任务
相互学习 共同进步
04-24 565
代表一个调度参数的配置，什么时候去调org.quartz.Calendar和java.util.Calendar不同，它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合，代表一个日历时间点）。一个Trigger可以和多个Calendar关联，以便排除或包含某些时间点假设：安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用 Calendar进行定点排除。
【Quartz】分布式定时任务
记录了，但是完全不会。
06-29 1214
Quartz是一个功能强大且灵活的开源作业调度库，用于在Java应用程序中实现任务调度和作业管理。它提供了一种简单且可靠的方式来安排执行定时任务、重复任务或基于特定时间表的任务。
Quartz定时任务调度(笔记)
山高水长
11-09 490
文章目录一、引言1.1 简介二、Quartz使用2.1 导入依赖2.2 定义Job2.3 API测试2.4 配置2.5 核心类说明三、Trigger3.1 SimpleTrigger3.2 CronTrigger3.2.1 Cron表达式组成3.2.2 Cron表达式符号3.2.3 Cron表达式示例四、Spring整合Quartz4.1 依赖4.2 定义Job4.3 配置4.4 操作4.4.1 启动任务4.4.2 任务操作4.4.2.1 删除任务4.4.2.2 暂停、恢复4.4.2.3 批量操作 一、引.
Quartz定时任务实战篇3：定时任务框架Quartz详解，裁员被逼啃透Java22个技术点
最新发布
2301_79987255的博客
04-09 753
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
解决quartz 定时任务报错问题
JUNY_JAVA的博客
01-16 9064
定时任务运行提示： java.lang.ClassCastException: bdhj.modules.job.entity.ScheduleJobEntity cannot be cast to bdhj.modules.job.entity.ScheduleJobEntity at bdhj.modules.job.utils.ScheduleJob.executeInterna...
ScheduledFuture和RunnableScheduledFuture详解
weixin_34290631的博客
05-08 1130
  ScheduledFuture java.util.concurrent 接口 ScheduledFuture&lt;V&gt; 类型参数：     V - 此 Future 返回的结果类型。 所有超级接口：     Comparable&lt;Delayed&gt;, Delayed, Future&lt;V&gt; 所有已知子接口：     RunnableSchedul...
quartz 定时任务
07-29
好的，下面是关于使用Spring Boot和Quartz实现定时任务的简介： Quartz是一个流行的Java定时任务框架，可以在应用程序中执行各种定时任务，如定期备份、数据抽取和数据分析等。而Spring Boot是一个快速开发框架，提供了方便的集成Quartz的方式。 要使用Spring Boot和Quartz实现定时任务，首先需要在pom.xml文件中添加Quartz和Spring Boot Quartz的依赖项。然后，定义一个定时任务，可以使用注解@Scheduled来指定任务的执行时间。例如： ```java @Component public class MyScheduler { @Scheduled(cron = "0 0/10 * * * ?") public void myTask() { //执行定时任务的代码 } } ``` 上述代码表示每隔10分钟执行一次myTask()方法。然后，在Spring Boot的主类中，使用@EnableScheduling注解来开启定时任务的支持。例如： ```java @SpringBootApplication @EnableScheduling public class MyApp { public static void main(String[] args) { SpringApplication.run(MyApp.class, args); } } ``` 最后，启动应用程序，定时任务将按照预定时间自动执行。如果需要更高级的定时任务控制，还可以使用Quartz的其他功能，如JobDetail和Trigger等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值