开发者社区> 琴岛蛏子> 正文

SpringBoot Quartz页面交互控制

简介: SpringBoot Quartz页面交互控制
+关注继续查看

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,完全由Java开发,可以用来执行定时任务。

SpringBoot对quartz进行了集成。

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

<!-- mysql -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>

<!-- jdbc -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

JobStore任务存储

RAMJobStoreJDBCJobStore

若使用jdbc存储需指定数据库如mysql及数据源datasource如jdbc或者mybatis

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.3.2</version>
</dependency>

application.yml配置

spring:
  server:
    port: 8080
    servlet:
      context-path: /lovin
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/quartz?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  quartz:
    job-store-type: jdbc #数据库方式
    jdbc:
      initialize-schema: never #不初始化表结构 never always
    properties:
      org:
        quartz:
          scheduler:
            instanceId: AUTO #默认主机名和时间戳生成实例ID,可以是任何字符串,但对于所有调度程序来说,必须是唯一的 对应qrtz_scheduler_state INSTANCE_NAME字段
            #instanceName: clusteredScheduler #quartzScheduler
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX #持久化配置
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate #我们仅为数据库制作了特定于数据库的代理
            useProperties: false #以指示JDBCJobStore将JobDataMaps中的所有值都作为字符串,因此可以作为名称 - 值对存储而不是在BLOB列中以其序列化形式存储更多复杂的对象。从长远来看,这是更安全的,因为您避免了将非String类序列化为BLOB的类版本问题。
            tablePrefix: QRTZ_  #数据库表前缀
            misfireThreshold: 60000 #在被认为“失火”之前,调度程序将“容忍”一个Triggers将其下一个启动时间通过的毫秒数。默认值(如果您在配置中未输入此属性)为60000(60秒)。
            clusterCheckinInterval: 5000 #设置此实例“检入”*与群集的其他实例的频率(以毫秒为单位)。影响检测失败实例的速度。
            isClustered: true #打开群集功能
          threadPool: #连接池
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true

Quartz.jdbc.initialize-schema 改成always 会初始化表结构,生成标后改为never

注意tablePrefix: QRTZ_ 的大小写,查看数据库生成的表进行设置。

表名称说明
qrtz_blob_triggersTrigger作为Blob类型存储(用于Quartz用户用JDBC创建他们自己定制的Trigger类型,JobStore 并不知道如何存储实例的时候)
qrtz_calendars以Blob类型存储Quartz的Calendar日历信息, quartz可配置一个日历来指定一个时间范围
qrtz_cron_triggers存储Cron Trigger,包括Cron表达式和时区信息。
qrtz_fired_triggers存储与已触发的Trigger相关的状态信息,以及相联Job的执行信息
qrtz_job_details存储每一个已配置的Job的详细信息
qrtz_locks存储程序的非观锁的信息(假如使用了悲观锁)
qrtz_paused_trigger_graps存储已暂停的Trigger组的信息
qrtz_scheduler_state存储少量的有关 Scheduler的状态信息,和别的 Scheduler 实例(假如是用于一个集群中)
qrtz_simple_triggers存储简单的 Trigger,包括重复次数,间隔,以及已触的次数
qrtz_triggers存储已配置的 Trigger的信息
qrzt_simprop_triggers

编写任务执行器

继承自QuartzJobBean, 此处添加@Component加入IOC容器,可以不添加通过class使用

@Slf4j
@Component
public class HelloJob extends QuartzJobBean {

  @Override
  protected void executeInternal (JobExecutionContext context) throws JobExecutionException {
    log.info("HelloJob "+System.currentTimeMillis());
  }
}

操作job的服务

spring-boot-starter-quartz集成注入了Scheduler,通过PostConstruct启动调度器。

@Service
public class QuartzService {

  @Autowired
  private Scheduler scheduler;

  @PostConstruct
  public void startScheduler () {
    try {
      scheduler.start();
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
  }

  /**
   * 增加一个job
   *
   * @param jobClass     任务实现类
   * @param jobName      任务名称
   * @param jobGroupName 任务组名
   * @param jobTime      时间表达式 (这是每隔多少秒为一次任务)
   * @param jobTimes     运行的次数 (<0:表示不限次数)
   * @param jobData      参数
   */
  public void addJob (Class<? extends QuartzJobBean> jobClass, String jobName, String jobGroupName, int jobTime,
      int jobTimes, Map jobData) {
    try {
      // 任务名称和组构成任务key
      JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
          .build();
      // 设置job参数
      if (jobData != null && jobData.size() > 0) {
        jobDetail.getJobDataMap().putAll(jobData);
      }
      // 使用simpleTrigger规则
      Trigger trigger = null;
      if (jobTimes < 0) {
        trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)
            .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobTime))
            .startNow().build();
      } else {
        trigger = TriggerBuilder
            .newTrigger().withIdentity(jobName, jobGroupName).withSchedule(SimpleScheduleBuilder
                .repeatSecondlyForever(1).withIntervalInSeconds(jobTime).withRepeatCount(jobTimes))
            .startNow().build();
      }
      // 注册jobDetail与trigger到调度器
      scheduler.scheduleJob(jobDetail, trigger);
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
  }

  /**
   * 增加一个job
   *
   * @param jobClass     任务实现类
   * @param jobName      任务名称(建议唯一)
   * @param jobGroupName 任务组名
   * @param jobTime      时间表达式 (如:0/5 * * * * ? )
   * @param jobData      参数
   */
  public void addJob (Class<? extends QuartzJobBean> jobClass, String jobName, String jobGroupName, String jobTime, Map jobData) {
    try {
      // 创建jobDetail实例,绑定Job实现类
      // 指明job的名称,所在组的名称,以及绑定job类
      // 任务名称和组构成任务key
      JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
          .build();
      // 设置job参数
      if (jobData != null && jobData.size() > 0) {
        jobDetail.getJobDataMap().putAll(jobData);
      }
      // 定义调度触发规则
      // 使用cornTrigger规则
      // 触发器key
      Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)
          .startAt(DateBuilder.futureDate(1, IntervalUnit.SECOND))
          .withSchedule(CronScheduleBuilder.cronSchedule(jobTime)).startNow().build();
      // 把作业和触发器注册到任务调度中
      scheduler.scheduleJob(jobDetail, trigger);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * 修改 一个job的 时间表达式
   *
   * @param jobName
   * @param jobGroupName
   * @param jobTime
   */
  public void updateJob (String jobName, String jobGroupName, String jobTime) {
    try {
      TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
      CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
      trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
          .withSchedule(CronScheduleBuilder.cronSchedule(jobTime)).build();
      // 重启触发器
      scheduler.rescheduleJob(triggerKey, trigger);
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
  }

  /**
   * 删除任务一个job
   *
   * @param jobName      任务名称
   * @param jobGroupName 任务组名
   */
  public void deleteJob (String jobName, String jobGroupName) {
    try {
      scheduler.deleteJob(new JobKey(jobName, jobGroupName));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /**
   * 暂停一个job
   *
   * @param jobName
   * @param jobGroupName
   */
  public void pauseJob (String jobName, String jobGroupName) {
    try {
      JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
      scheduler.pauseJob(jobKey);
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
  }

  /**
   * 恢复一个job
   *
   * @param jobName
   * @param jobGroupName
   */
  public void resumeJob (String jobName, String jobGroupName) {
    try {
      JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
      scheduler.resumeJob(jobKey);
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
  }

  /**
   * 立即执行一个job
   *
   * @param jobName
   * @param jobGroupName
   */
  public void runAJobNow (String jobName, String jobGroupName) {
    try {
      JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
      scheduler.triggerJob(jobKey);
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
  }

  /**
   * 获取所有计划中的任务列表
   *
   * @return
   */
  public List<Map<String, Object>> queryAllJob () {
    List<Map<String, Object>> jobList = null;
    try {
      GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
      Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
      jobList = new ArrayList<Map<String, Object>>();
      for (JobKey jobKey : jobKeys) {
        List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
        for (Trigger trigger : triggers) {
          Map<String, Object> map = new HashMap<>();
          map.put("jobName", jobKey.getName());
          map.put("jobGroupName", jobKey.getGroup());
          map.put("description", "触发器:" + trigger.getKey());
          Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
          map.put("jobStatus", triggerState.name());
          if (trigger instanceof CronTrigger) {
            CronTrigger cronTrigger = (CronTrigger) trigger;
            String cronExpression = cronTrigger.getCronExpression();
            map.put("jobTime", cronExpression);
          }
          jobList.add(map);
        }
      }
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
    return jobList;
  }

  /**
   * 获取所有正在运行的job
   *
   * @return
   */
  public List<Map<String, Object>> queryRunJob () {
    List<Map<String, Object>> jobList = null;
    try {
      List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
      jobList = new ArrayList<Map<String, Object>>(executingJobs.size());
      for (JobExecutionContext executingJob : executingJobs) {
        Map<String, Object> map = new HashMap<String, Object>();
        JobDetail jobDetail = executingJob.getJobDetail();
        JobKey jobKey = jobDetail.getKey();
        Trigger trigger = executingJob.getTrigger();
        map.put("jobName", jobKey.getName());
        map.put("jobGroupName", jobKey.getGroup());
        map.put("description", "触发器:" + trigger.getKey());
        Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
        map.put("jobStatus", triggerState.name());
        if (trigger instanceof CronTrigger) {
          CronTrigger cronTrigger = (CronTrigger) trigger;
          String cronExpression = cronTrigger.getCronExpression();
          map.put("jobTime", cronExpression);
        }
        jobList.add(map);
      }
    } catch (SchedulerException e) {
      e.printStackTrace();
    }
    return jobList;
  }
}

Quartz控制器

与前端页面交互的control,前端页面交互时调用service实现对job的操控。

@Api(tags = "Quartz控制器")
@RestController
public class QuartzController {


  @Autowired
  private QuartzService quartzService;

  @ApiOperation("添加任务")
  @PostMapping("/addJob")
  public Object addJob (@RequestBody JobRequestDto requestDto){
    Object bean = SpringUtil.getBean(requestDto.getBeanName());
    if(!(bean instanceof QuartzJobBean)){
      return "bean type is not QuartzJobBean";
    }
    QuartzJobBean jobBean = (QuartzJobBean) bean;
    quartzService.addJob(jobBean.getClass(),requestDto.getJobName(),requestDto.getJobGroupName(),requestDto.getCron(),requestDto.getParams());

    return "success";
  }

  // ... updateJob deleteJob pauseJob resumeJob  runAJobNow queryAllJob queryRunJob
}
@Data
public class JobRequestDto {

  String beanName;

  String jobName;

  String jobGroupName;

  String cron;

  Map<String,Object> params;
}

启动服务,发送请求

{
  "beanName": "helloJob",
  "cron": "0/5 * * * * ?",
  "jobGroupName": "paw-demo",
  "jobName": "helloJob",
  "params": {}
}

就会看到控制台输出,HelloJob已启动

2021-08-12 14:20:30.029  INFO 17620 --- [eduler_Worker-7] com.paw.quartz.jobs.HelloJob             : HelloJob 1628749230029
2021-08-12 14:20:35.035  INFO 17620 --- [eduler_Worker-8] com.paw.quartz.jobs.HelloJob             : HelloJob 1628749235035
2021-08-12 14:20:40.030  INFO 17620 --- [eduler_Worker-9] com.paw.quartz.jobs.HelloJob             : HelloJob 1628749240030
2021-08-12 14:20:45.031  INFO 17620 --- [duler_Worker-10] com.paw.quartz.jobs.HelloJob             : HelloJob 1628749245031

查看数据库

相关数据已保存,如QRTZ_JOB_DETAILS

SCHED_NAME    JOB_NAME    JOB_GROUP    DESCRIPTION    JOB_CLASS_NAME    IS_DURABLE    IS_NONCONCURRENT    IS_UPDATE_DATA    REQUESTS_RECOVERY    JOB_DATA
quartzScheduler    helloJob    paw-demo        com.paw.quartz.jobs.HelloJob    0    0    0    0    

停止服务再次启动

quartz会通过jdbc从数据库获取配置,启动任务。

总结

Springboot提供了quartz的集成spring-boot-starter-quartz,可以采用jdbcStore的方式将job存储在数据库,服务重启任务不丢失。通过API接口对job进行控制,从而实现页面交互控制。用户只需要继承QuartzJobBean实现业务逻辑,然后通过页面将业务类bean提交到job中即可实现定时服务。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
阿里云ECS云服务器初始化设置教程方法
阿里云ECS云服务器初始化是指将云服务器系统恢复到最初状态的过程,阿里云的服务器初始化是通过更换系统盘来实现的,是免费的,阿里云百科网分享服务器初始化教程: 服务器初始化教程方法 本文的服务器初始化是指将ECS云服务器系统恢复到最初状态,服务器中的数据也会被清空,所以初始化之前一定要先备份好。
13901 0
阿里云服务器安全组设置内网互通的方法
虽然0.0.0.0/0使用非常方便,但是发现很多同学使用它来做内网互通,这是有安全风险的,实例有可能会在经典网络被内网IP访问到。下面介绍一下四种安全的内网互联设置方法。 购买前请先:领取阿里云幸运券,有很多优惠,可到下文中领取。
17798 0
阿里云服务器怎么设置密码?怎么停机?怎么重启服务器?
如果在创建实例时没有设置密码,或者密码丢失,您可以在控制台上重新设置实例的登录密码。本文仅描述如何在 ECS 管理控制台上修改实例登录密码。
18653 0
使用OpenApi弹性释放和设置云服务器ECS释放
云服务器ECS的一个重要特性就是按需创建资源。您可以在业务高峰期按需弹性的自定义规则进行资源创建,在完成业务计算的时候释放资源。本篇将提供几个Tips帮助您更加容易和自动化的完成云服务器的释放和弹性设置。
18205 0
使用SSH远程登录阿里云ECS服务器
远程连接服务器以及配置环境
11304 0
如何设置阿里云服务器安全组?阿里云安全组规则详细解说
阿里云安全组设置详细图文教程(收藏起来) 阿里云服务器安全组设置规则分享,阿里云服务器安全组如何放行端口设置教程。阿里云会要求客户设置安全组,如果不设置,阿里云会指定默认的安全组。那么,这个安全组是什么呢?顾名思义,就是为了服务器安全设置的。安全组其实就是一个虚拟的防火墙,可以让用户从端口、IP的维度来筛选对应服务器的访问者,从而形成一个云上的安全域。
16345 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,阿里云优惠总结大概有三种登录方式: 登录到ECS云服务器控制台 在ECS云服务器控制台用户可以更改密码、更换系.
23667 0
+关注
琴岛蛏子
潮来潮去,打洞卧沙
62
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
OceanBase 入门到实战教程
立即下载
阿里云图数据库GDB,加速开启“图智”未来.ppt
立即下载
实时数仓Hologres技术实战一本通2.0版(下)
立即下载