springmvc+quartz 实现定时任务

摘要:
Spring mvc+石英实现计时任务;1.在pom.xml中添加依赖项1)省略了Spring mvc依赖项*Cront表达式来设置调度的频率*秒、分钟、天、月,和周年纪念设置**Scheduler的主函数*DatescheduleJob绑定JobDetail和Trigger返回上次执行的时间*voidstart()启动*voidstandby()暂停执行*voidshutdown()关闭*/@ServicepublicclassJobTask{privateLoggerlog=LoggerFactory.getLogger;@AutowiredprivateSchedulerFactoryBainschedulerFactoryBean;/**启动任务*@throwsSchedulerException*/publicboolean startJobthrowsScheduler exception{//创建调度器实例SchedulersScheduler=schedulerFactoryBean.getScheduler();//创建JobDetail实例并绑定创建的作业Classclazz=null;尝试{clazz=Class.forName;}catch{e.printStackTrace();}JobDetailjobDetail=JobBuilder.newJob.build());//创建触发器;TriggerKeytriggerKey=TriggerKey.TriggerKey;CronTrigger=TriggerBuilder.newTrigger().withIdentity.withSchedule.build();schedule.scheuleJob;//如果(!Scheduler.isShutdown()){Scheduler.start();log.info(“--task[”+triggerKey.getName()+“]已成功启动..”);returntrue;}否则{log.info(”--task[“+triggerKey()+”]已启动,则无需再次启动。。。

springmvc+quartz实现定时任务;

1.pom.xml中添加依赖

    1)springmvc依赖省略。。

     2)quartz依赖

   

       
<dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.0</version> </dependency>

 

2. 代码实现

  1)systemJob实体类

   springmvc+quartz 实现定时任务第1张

  省略 geter and seter

   2.) service 类

  springmvc+quartz 实现定时任务第2张

  3.)任务调度类

   

package com.meta.wx.quartz;

import com.meta.wx.beans.SystemJob;
import com.meta.wx.utils.DateUtil;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

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

/**
 * 定时任务
 * @author Administrator
 * CronTrigger的作业 (Trigger的另一个分支)比较强大
 *  基于日历的作业调度器 (如在每月的1号执行或每周一调用等)
 *  而不像SimpleTrigger那样精确指定间隔时间,比SimpleTrigger更常用。
 *  Cront 表达式来设置调度的频率
 *  秒 分 时 日 月 周 年     顺序设置
 *
 *  Scheduler 的主要函数
 *  Date scheduleJob(JobDetail jobDetail,Trigger trigger) 绑定JobDetail和Trigger 返回最近一次要执行的时间
 *  void start() 启动
 *  void standby()挂起执行(可用start()开启)
 *  void  shutdown()关闭
 */
@Service
public class JobTask {
    private Logger log= LoggerFactory.getLogger(JobTask.class);
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;


    /**
     * 启动任务
     * @throws SchedulerException
     */
  public boolean startJob(SystemJob sjob) throws SchedulerException{
      //创建Scheduler实例
      Scheduler scheduler=schedulerFactoryBean.getScheduler();
    //创建一个JobDetail实例,绑定所建的作业
      Class clazz= null;
      try {
          clazz = Class.forName(sjob.getClasspath());
      } catch (ClassNotFoundException e) {
          e.printStackTrace();
      }

      JobDetail jobDetail=JobBuilder.newJob(clazz).build();
      // 创建一个Trigger;
      TriggerKey triggerKey=TriggerKey.triggerKey(sjob.getId(),Scheduler.DEFAULT_GROUP);
      CronTrigger trigger =(CronTrigger)TriggerBuilder.newTrigger()
              .withIdentity(triggerKey)
              .withSchedule(
                      //1.2018年内每天10点15分出发一次
                      //可通过cront表达式在线生成 http://cron.qqe2.com/
                      CronScheduleBuilder.cronSchedule(sjob.getCron())//参数为cront表达式(秒 分 时 日 月 周 年)
              )
              .build();
          scheduler.scheduleJob(jobDetail,trigger);//绑定与触发器

      //启动任务
      if(!scheduler.isShutdown()){
          scheduler.start();
          log.info("---任务["+triggerKey.getName()+"] 启动成功。。。");
          return true;
      }else{
          log.info("---任务["+triggerKey.getName()+"] 已启动,无需再次启动。。。");
      }
    return false;
  }

    /**
     * 修改任务
     * @param sjob
     * @return
     * @throws SchedulerException
     */
    public boolean updateJob(SystemJob sjob) {
        //创建Scheduler实例
        Scheduler scheduler=schedulerFactoryBean.getScheduler();
        String createTime = DateUtil.getCurDate();

        try {
            Class clazz =null;
            try {
                clazz = Class.forName(sjob.getClasspath());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //创建一个JobDetail实例,绑定所建的作业(将该实例与HelloJobClass绑定)
            JobDetail jobDetail=JobBuilder.newJob(clazz).build();
            // 创建一个Trigger;
            TriggerKey triggerKey=TriggerKey.triggerKey(sjob.getId(),Scheduler.DEFAULT_GROUP);

            if (scheduler.checkExists(triggerKey)){
                return false;
            }

            JobKey jobKey=JobKey.jobKey(sjob.getId(),Scheduler.DEFAULT_GROUP);
            CronScheduleBuilder scheduleBuilder=CronScheduleBuilder.cronSchedule(sjob.getCron())
                    .withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger=TriggerBuilder.newTrigger().withIdentity(triggerKey)
                    .withDescription(createTime).withSchedule(scheduleBuilder).build();

                JobDetail jobDetail1=scheduler.getJobDetail(jobKey);

            HashSet<Trigger> triggerSet=new HashSet<>();
            triggerSet.add(trigger);
            scheduler.scheduleJob(jobDetail,triggerSet,true);
            log.info("---任务[{}]更新成功---",triggerKey.getName());
            return true;
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }
    }

    /**
     * 删除
     * @param job
     * @return
     */
    public boolean remove(SystemJob job){
        Scheduler scheduler=schedulerFactoryBean.getScheduler();
        TriggerKey triggerKey=TriggerKey.triggerKey(job.getId(),Scheduler.DEFAULT_GROUP);

        try {
            if (checkJob(job)){
                scheduler.pauseTrigger(triggerKey);
                scheduler.unscheduleJob(triggerKey);
                log.info("---任务[{}]删除成功!",triggerKey.getName());
                return true;
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return  false;
    }

    /**
     *     true 存在 false 不存在
     * @param job
     * @return
     */
    public boolean checkJob(SystemJob job){
        Scheduler scheduler=schedulerFactoryBean.getScheduler();
        //触发器
        TriggerKey triggerKey=TriggerKey.triggerKey(job.getId(),Scheduler.DEFAULT_GROUP);

        try {
               if(scheduler.checkExists(triggerKey)){
                   return true;
               }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
       return false;
    }
}

4.)任务启动线程类
package com.meta.wx.model;

import com.meta.wx.beans.SystemJob;
import com.meta.wx.quartz.JobTask;
import com.meta.wx.service.JobService;
import com.meta.wx.utils.SpringUtil;
import org.quartz.Job;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.List;

/**
 * Created by Administrator on 2019/3/28.
 * 启动数据库中已经设定为启动状态(status:true)的任务,项目启动时init
 */
@Configuration
public class JobTreadModel extends Thread{
    private Logger log= LoggerFactory.getLogger(JobTreadModel.class);
    @Resource
   private JobService jobService;


    @Override
    public void run() {

           try {
               Thread.sleep(1000);
               log.info("---启动任务线程----");
               JobTask jobTask = SpringUtil.getBean("jobTask");
               List<SystemJob> jobList = jobService.startJob();
               //开启任务
               jobList.forEach(jobs -> {
                   log.info("---任务[{}] 系统 init---开始启动 ", jobs.getId());
                   try {
                       jobTask.startJob(jobs);
                   } catch (SchedulerException e) {
                       e.printStackTrace();
                   }
               });
               if (jobList.size() == 0) {
                   log.info("---数据库暂无启动的任务---------");
               } else {
                   log.info("---任务启动完毕---------");
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
    }
}

5)使用spring的ApplicationListener监听待加载完毕时启动任务

package com.meta.wx.model;

import org.apache.log4j.Logger;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

/**
 * Created by Administrator on 2019/3/28.
 * 通过监听,开辟线程,执行定时任务 当然 也可以执行其他
 */
@Component
public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
   public Logger log=Logger.getLogger(MyApplicationListener.class);


    /**
     * bean加载完之后执行
     * @param event
     */
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("-------------bean初始化完毕-------------");
        /**
         * 系统两种容器:root application context 和项目名-servlet context ;
         * 下面代码防止执行两次
         */
        if(event.getApplicationContext().getParent() == null) {

            JobTreadModel myThread = (JobTreadModel) event.getApplicationContext().getBean(
                    "jobTreadModel");
            myThread.start();
        }
    }
}

6)配置spring的Application_mvc.xml

    <!-- quartz 定时任务配置-->
    <bean id="jobFactory" class="com.meta.wx.quartz.MyJobFactory"></bean>

    <bean name="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobFactory" ref="jobFactory"></property>
    </bean>



免责声明:文章转载自《springmvc+quartz 实现定时任务》仅用于学习参考。如对内容有疑问,请及时联系本站处理。

上篇网工笔记Oracle EBS 入门下篇

宿迁高防,2C2G15M,22元/月;香港BGP,2C5G5M,25元/月 雨云优惠码:MjYwNzM=

相关文章

基于ASP.NET MVC(C#)和Quartz.Net组件实现的定时执行任务调度

http://www.cnblogs.com/bobositlife/p/aspnet-mvc-csharp-quartz-net-timer-task-scheduler.html 在之前的文章《推荐一个简单、轻量、功能非常强大的C#/ASP.NET定时任务执行管理器组件–FluentScheduler》和《简单、轻量、功能非常强大的C#/ASP.NET...

Quartz使用

Quartz简介 Quartz 是一种功能丰富的,开放源码的作业调度库,可以在几乎任何Java应用程序集成。Quartz可以用来创建简单或复杂的日程安排执行几十,几百,甚至是十万的作业数 -  作业被定义为标准的Java组件,可以执行几乎任何东西,可以编程让它们执行。 Quartz调度包括许多企业级功能,如JTA事务和集群支持。 Quartz特点:强大的调...

java中实现定时任务 task 或quartz

转载大神的 https://www.cnblogs.com/hafiz/p/6159106.html https://www.cnblogs.com/luchangyou/p/6856725.html 使用Spring Task轻松完成定时任务 一、背景  最近项目中需要使用到定时任务进行库存占用释放的需求,就总结了如何使用Spring Task进行简单配...

定时任务应该这么玩

1.场景 在电商系统中会经常遇到这样一种场景,就是商品的定时上下架功能,总不能每次都手动执行吧,这个时候我们首先想到的就是利用定时任务来实现这个功能。 目前实现定时任务主要有以下几种方式: JDK自带 :JDK自带的Timer以及JDK1.5+ 新增的ScheduledExecutorService; 第三方框架 :使用 Quartz、elastic-j...

Net Core2.0 基于QuartzNet任务管理系统

Net Core2.0 基于QuartzNet任务管理系统Quartz.NET官网地址:https://www.quartz-scheduler.net/ Quartz.NET文档地址:https://www.quartz-scheduler.net/documentation/index.html Quartz.NET是一个开源的作业调度框架,是Open...

springmvc+quartz简单实现定时调度

一、简介:Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个,百个,甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.0。 二、因为定...