定时任务 订阅
定时任务是一款系统安全类软件,支持Android 2.1。 展开全文
定时任务是一款系统安全类软件,支持Android 2.1。
信息
应用名称
定时任务
应用版本
0.3
运行环境
Android 2.1
应用平台
mobile
应用类型
系统安全类
三维重建简介
Timed Tasks是一款Wi-Fi、飞行模式、蓝牙、数据连接、屏幕亮度定时开关任务软件,让各项设置按自己所设的时间、日期开启或关闭。
收起全文
精华内容
参与话题
问答
  • 定时任务 quartz

    千次阅读 2019-07-04 23:40:37
    Quartz有四个核心接口Job、JobDetail、Trigger和Scheduler。Trigger主要有CronTrigger(表达式触发)和SimpleTrigger(简单触发)两...将需要完成的任务写在execute()方法中。一个job可以有多个trigger,一个trigg...

    Quartz有四个核心接口Job、JobDetail、Trigger和Scheduler。Trigger主要有CronTrigger(表达式触发)和SimpleTrigger(简单触发)两个接口,表达式触发的功能更强大,在开发时使用比较广泛,Job是一个实现org.quartz.Job接口的java类。将需要完成的任务写在execute()方法中。一个job可以有多个trigger,一个trigger只能有一个job。JobDetail包含了Job的调度策略和调度方案。Scheduler是对定时任务进行调度的控制器。Quartz的运行原理如图所示。

    Scheduler是整个任务调度的总部,里面注册了很多的JobDetail和trigger。Trigger主要用来设置调度参数,用来设置多久进行一次任务调度。当Scheduler容器启动时,JobDetail和Trigger会在scheduler容器上进行注册。注册后,JobDetail和Trigger将会组成的一对装配好的作业。在Scheduler中有一个线程池,按照Trigger中配置的规则,为每个作业开启一个线程来并行执行。 

    SimpleTrigger

    应用小demo

    public class HelloJob implements Job{
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            System.out.println(new Date());
        }
    }
    =================================================================
    
    package job;
    
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerFactory;
    import org.quartz.Trigger;
    import org.quartz.impl.StdSchedulerFactory;
    import java.util.Date;
    import static org.quartz.DateBuilder.evenSecondDate;
    import static org.quartz.JobBuilder.newJob;
    import static org.quartz.TriggerBuilder.newTrigger;
    
    /**
     * created by reedfan on 2019/7/4 0004
     */
    public class SimpleExample {
        public void run() throws Exception {
            System.out.println("------- Initializing ----------------------");
            // 定义调度器
            SchedulerFactory sf = new StdSchedulerFactory();
            Scheduler sched = sf.getScheduler();
            System.out.println("------- Initialization Complete -----------");
            // 获取当前时间的下一秒钟
            Date runTime = evenSecondDate(new Date());
            System.out.println("------- Scheduling Job  -------------------");
            // 定义job
            // 在quartz中,有组的概念,组+job名称 唯一的
            JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
            // 定义触发器,在下一秒钟启动
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
            // 将job注册到调度器
            sched.scheduleJob(job, trigger);
            System.out.println(job.getKey() + " will run at: " + runTime);
            // 启动调度器
            sched.start();
            System.out.println("------- Started Scheduler -----------------");
            // 等待5秒
            System.out.println("------- Waiting 5 seconds... -------------");
            try {
                // wait 65 seconds to show job
                Thread.sleep(5L * 1000L);
                // executing...
            } catch (Exception e) {
                //
            }
            // 关闭调度器
            System.out.println("------- Shutting Down ---------------------");
            sched.shutdown(true);
            System.out.println("------- Shutdown Complete -----------------");
        }
    
        public static void main(String[] args) throws Exception {
            SimpleExample example = new SimpleExample();
            example.run();
    
        }
    }
    

    运行结果

     

    CronTrigger

    quartz表达式生成器

    package job;
    
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerFactory;
    import org.quartz.Trigger;
    import org.quartz.impl.StdSchedulerFactory;
    import java.util.Date;
    
    import static org.quartz.CronScheduleBuilder.cronSchedule;
    import static org.quartz.DateBuilder.evenSecondDate;
    import static org.quartz.JobBuilder.newJob;
    import static org.quartz.TriggerBuilder.newTrigger;
    
    /**
     * created by reedfan on 2019/7/4 0004
     */
    public class SimpleExample {
        public void run() throws Exception {
            System.out.println("------- Initializing ----------------------");
            // 定义调度器
            SchedulerFactory sf = new StdSchedulerFactory();
            Scheduler sched = sf.getScheduler();
            System.out.println("------- Initialization Complete -----------");
            // 获取当前时间的下一秒钟
            Date runTime = evenSecondDate(new Date());
            System.out.println("------- Scheduling Job  -------------------");
            // 定义job
            // 在quartz中,有组的概念,组+job名称 唯一的
            JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
            // 定义触发器,在下一钟启动
          //  Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
            // 将job注册到调度器
    
            // 定义触发器,每2秒执行一次
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
                    .withSchedule(cronSchedule("0/2 * * * * ?")).build();
    
            sched.scheduleJob(job, trigger);
            System.out.println(job.getKey() + " will run at: " + runTime);
            // 启动调度器
            sched.start();
            System.out.println("------- Started Scheduler -----------------");
            // 等待5秒
            System.out.println("------- Waiting 10 seconds... -------------");
            try {
                // wait 10 seconds to show job
                Thread.sleep(10L * 1000L);
                // executing...
            } catch (Exception e) {
                //
            }
            // 关闭调度器
            System.out.println("------- Shutting Down ---------------------");
            sched.shutdown(true);
            System.out.println("------- Shutdown Complete -----------------");
        }
    
        public static void main(String[] args) throws Exception {
            SimpleExample example = new SimpleExample();
            example.run();
    
        }
    }
    

     

    展开全文
  • 至于Quartz到底是什么,可以看我上一篇转载的文章,或者百度。下面直接举例: 1.Spring配置Quartz a.需要导入quartz的jar包:  quartz-2.1.7.jar b.【Spring配置文件ApplicationContext.xml】 ...

    至于Quartz到底是什么,可以看我上一篇转载的文章,或者百度。下面直接举例:

    1.Spring配置Quartz

    a.需要导入quartz的jar包:

       quartz-2.1.7.jar

    b.【Spring配置文件ApplicationContext.xml】

    	<!-- 启动触发器的配置开始 -->
    	<bean name="startQuertz" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    		<property name="triggers">
    			<list>
    			  <ref bean="myJobTrigger_1" />
    			  <ref bean="myJobTrigger_2" />
    			</list>
    		</property>
    	</bean>
    	
    	<!-- quartz-2.x的配置 -->
    	<bean id="myJobTrigger_1" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    		<property name="jobDetail">
    		  <ref bean="myJobDetail_1" />
    		</property>
    		<property name="cronExpression">
    		  <value>0/5 * * * * ?</value>
    		</property>
    	</bean>
    	
    	<!-- job的配置开始 -->
    	<bean id="myJobDetail_1" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    		<property name="targetObject">
    		  <ref bean="myJob_1" />
    		</property>
    		<property name="targetMethod">
    		  <value>work</value>
    		</property>
    	</bean>
    	<!-- 工作的bean -->
    	<bean id="myJob_1" class="com.myb.timertask.SysQuartzJob" />
    	
    	<!-- quartz-2.x的配置 (第二个quartz定时任务)-->
    	<bean id="myJobTrigger_2" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    		<property name="jobDetail">
    		  <ref bean="myJobDetail_2" />
    		</property>
    		<property name="cronExpression">
    		  <value>0/5 * * * * ?</value>
    		</property>
    	</bean>
    	
    	<!-- job的配置开始 -->
    	<bean id="myJobDetail_2" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    		<property name="targetObject">
    		  <ref bean="myJob_2" />
    		</property>
    		<property name="targetMethod">
    		  <value>work</value>
    		</property>
    	</bean>
    	<!-- 工作的bean -->
    	<bean id="myJob_2" class="com.myb.timertask.SysQuartzJob2" />
    c.【job bean对应的java】

    package com.myb.timertask;
    
    import javax.annotation.Resource;
    
    import com.myb.service.util.MybUtilService;
    import com.myb.util.DateUtil;
    
    /**
     * 
     * <b>所属模块:</b>牧羊仒Admin.系统定时任务示例<br/> 
     * <b>类名称:</b>SysQuartzJob<br/> 
     * <b>类描述:</b> Quartz定时任务示例   <br/> 
     * <b>版本:</b>V1.0<br/> 
     * <b>创建人:</b><a href="mailto:han_huayi@163.com">牧羊仒</a><br/>  
     * <b>创建时间:</b>2016年3月5日 下午10:21:22<br/>
     */
    public class SysQuartzJob {
    	
    	@Resource(name="mybUtilService")
    	private MybUtilService mybUtilService;
    	
    	public void work() throws Exception{
    		System.out.println("第一个定时任务:"+DateUtil.getTime());
    	}
    }
    
    package com.myb.timertask;
    
    import javax.annotation.Resource;
    
    import com.myb.service.util.MybUtilService;
    import com.myb.util.DateUtil;
    
    /**
     * 
     * <b>所属模块:</b>牧羊仒Admin.系统定时任务示例<br/> 
     * <b>类名称:</b>SysQuartzJob<br/> 
     * <b>类描述:</b> Quartz定时任务示例   <br/> 
     * <b>版本:</b>V1.0<br/> 
     * <b>创建人:</b><a href="mailto:han_huayi@163.com">牧羊仒</a><br/>  
     * <b>创建时间:</b>2016年3月5日 下午10:22:01<br/>
     */
    public class SysQuartzJob2 {
    	
    	@Resource(name="mybUtilService")
    	private MybUtilService mybUtilService;
    	
    	public void work() throws Exception{
    		System.out.println("第二个定时任务:"+DateUtil.getTime());
    	}
    }
    

    2. 直接调用Quartz方法

    a.创建要被定执行的任务类,实现org.quartz.Job接口,并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException

    package com.myb.timertask;
    
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    import com.myb.util.DateUtil;
    
    /**
     * 
     * <b>所属模块:</b>牧羊仒Admin.系统定时任务示例<br/> 
     * <b>类名称:</b>SysQuartzJob<br/> 
     * <b>类描述:</b> Quartz定时任务示例   <br/> 
     * <b>版本:</b>V1.0<br/> 
     * <b>创建人:</b><a href="mailto:han_huayi@163.com">牧羊仒</a><br/>  
     * <b>创建时间:</b>2016年3月5日 下午10:29:47<br/>
     */
    public class SysJob implements Job{
    
    	@Override
    	public void execute(JobExecutionContext arg0) throws JobExecutionException {
    		System.out.println("SysJob,系统任务:"+DateUtil.getTime());
    	}
    }
    

    b.创建任务调度,并执行

    package com.myb.timertask;
    
    import static org.quartz.CronScheduleBuilder.cronSchedule;
    import static org.quartz.JobBuilder.newJob;
    import static org.quartz.TriggerBuilder.newTrigger;
    
    import java.util.Date;
    
    import org.quartz.CronTrigger;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.impl.StdSchedulerFactory;
    
    import com.myb.util.DateUtil;
    
    /**
     * 
     * <b>所属模块:</b>牧羊仒Admin.系统定时任务示例<br/> 
     * <b>类名称:</b>SysQuartzJob<br/> 
     * <b>类描述:</b> Quartz定时任务示例   <br/> 
     * <b>版本:</b>V1.0<br/> 
     * <b>创建人:</b><a href="mailto:han_huayi@163.com">牧羊仒</a><br/>  
     * <b>创建时间:</b>2016年3月5日 下午10:31:20<br/>
     */
    public class TestQuartz {
    	
    	public static void main(String[] arsg) throws SchedulerException{
    		new TestQuartz().execute();
    	}
    	
    	public void execute() throws SchedulerException{
    		//创建调度器工厂(Scheduler的引用 )
    		SchedulerFactory sf = new StdSchedulerFactory();
    		Scheduler sched = sf.getScheduler();
    		
    		//jobs可以在scheduled的sched.start()方法前被调用 
    		//job 1将每隔20秒执行一次 
            JobDetail job = newJob(SysJob.class).withIdentity("job1", "group1").build(); 
            CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build(); 
            Date ft = sched.scheduleJob(job, trigger); 
            System.out.println(job.getKey() + " 已被安排执行于: " + DateUtil.getTime() + ",并且以如下重复规则重复执行: " + trigger.getCronExpression()); 
    		
            // job 2将每2分钟执行一次(在该分钟的第15秒) 
            job = newJob(SysJob.class).withIdentity("job2", "group1").build(); 
            trigger = newTrigger().withIdentity("trigger2", "group1").withSchedule(cronSchedule("0/25 * * * * ?")).build(); 
            ft = sched.scheduleJob(job, trigger); 
           System.out.println(job.getKey() + " 已被安排执行于: " + DateUtil.getTime() + ",并且以如下重复规则重复执行: "+ trigger.getCronExpression()); 
            
            // 开始执行,start()方法被调用后,计时器就开始工作,计时调度中允许放入N个Job 
            sched.start();
            
            try { 
                //主线程等待一分钟 
            	Thread.sleep(60L * 1000L); 
            } catch (Exception e) {}     
           
           //关闭定时调度,定时器不再工作 
           sched.shutdown(true); 
    	}
    	
    }
    

    cronExpression表达式,参考我上一篇转载的文章。





    展开全文
  • Java定时任务Quartz

    千次阅读 2018-06-03 15:21:48
    1.浅谈Trigger2.浅谈CronTrigger3.Quartz实际应用4.总结

    1.Trigger通用属性

          Trigger的触发器通用属性:JobKey——job实例的标识,触发器被触发时,该指定的job实例会执行;StartTime——表示触发器的时间表首次被触发的时间,它的值的类型是Java.util.Date;EndTime——指定触发器不再被触发的时间,它的值的类型是Java.util.Date;Job示例代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.quartz.JobKey;
    import org.quartz.Trigger;
    public class HelloJob implements Job{
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		//打印当前执行时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("任务执行时间为:"+sf.format(startTime));
    		Trigger currentTrigger = context.getTrigger();
    		System.out.println("Start Time is:"+sf.format(currentTrigger.getStartTime()));
    		System.out.println("End Time is:"+sf.format(currentTrigger.getEndTime()));
    		JobKey jobKey = currentTrigger.getJobKey();
    		System.out.println("JobKey info---"+"jobName:"+jobKey.getName()+"jobGroup:"+jobKey.getGroup());
    	}
    }

    Trigger示例代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.SimpleScheduleBuilder;
    import org.quartz.Trigger;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//获取当前时间3秒后的时间
    		startTime.setTime(startTime.getTime()+3000);
    		//获取当前时间6秒后的时间
    		Date endDate = new Date();
    		endDate.setTime(endDate.getTime()+6000);
    		// 创建一个Trigger实例,定义该Job立即执行,且每隔两秒钟执行一次直到永远
    		Trigger trigger = TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").
    				startAt(startTime).endAt(endDate).
    				withSchedule(SimpleScheduleBuilder.simpleSchedule().
    				withIntervalInSeconds(2).repeatForever()).build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		scheduler.scheduleJob(jobDetail,trigger);
    	}
    }

    2.浅谈SimpleTrigger

          SimpleTrigger:在一个指定时间段内执行一次作业任务,或者是在指定的时间间隔内多次执行作业任务。创建定时任务:距离当前时间4秒之后执行且仅执行一次,代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    public class HelloJob implements Job{
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		//打印当前执行时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("任务执行时间为:"+sf.format(startTime));
    		System.out.println("Hello World!");
    	}
    }
    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.SimpleTrigger;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//获取距离当前时间4秒之后的时间
    		startTime.setTime(startTime.getTime()+4000L);
    		// 创建一个Trigger实例,距离当前时间4秒钟后执行且仅执行一次任务
    		SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").startAt(startTime).build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		scheduler.scheduleJob(jobDetail,trigger);
    	}
    }
    

           创建定时任务:距离当前时间4秒之后执行之后每隔两秒执行一次,距离当前时间6秒之后停止执行,代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.SimpleScheduleBuilder;
    import org.quartz.SimpleTrigger;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//获取距离当前时间4秒之后的时间
    		startTime.setTime(startTime.getTime()+4000L);
    		// 创建一个Trigger实例,距离当前时间4秒钟后执行任务,之后每隔两秒执行一次任务
    		//withRepeatCount方法参数:SimpleTrigger.REPEAT_INDEFINITELY永远执行下去,若设置为具体数字则就执行几次
    		SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").startAt(startTime).
    				withSchedule(SimpleScheduleBuilder.simpleSchedule().
    				withIntervalInSeconds(2).withRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY)).build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		scheduler.scheduleJob(jobDetail,trigger);
    	}
    }
    

           创建定时任务:距离当前时间4秒之后执行之后每隔两秒执行一次,永远执行下去,代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.SimpleScheduleBuilder;
    import org.quartz.SimpleTrigger;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//获取距离当前时间4秒之后的时间
    		startTime.setTime(startTime.getTime()+4000L);
    		//获取6秒之后的时间
    		Date endDate = new Date();
    		endDate.setTime(endDate.getTime()+6000L);
    		/**
    		 * 创建一个Trigger实例,距离当前时间4秒钟后执行任务,之后每隔两秒执行一次任务,距离当前6秒之后停止执行
    		 * withRepeatCount方法参数:SimpleTrigger.REPEAT_INDEFINITELY永远执行下去,若设置为具体数字则就执行几次
    		 * 任务只执行两次,由此可见endDate条件是优先于withRepeatCount
    		 */
    		SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").startAt(startTime).endAt(endDate).
    				withSchedule(SimpleScheduleBuilder.simpleSchedule().
    				withIntervalInSeconds(2).withRepeatCount(5)).build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		scheduler.scheduleJob(jobDetail,trigger);
    	}
    }

           注意:重复次数(withRepeatCount)可以为0、正整数或者是SimpleTrigger.REPEAT_INDEFINITELY常量值;重复的执行间隔必须为0或者长整数;一旦被制定了endTime参数,那么它会覆盖重复次数参数的效果。

    3.浅谈CronTrigger

          CornTrigger:基于日历的作业调度器,而不是像SimpleTrigger那样精确指定间隔时间,比SimpleTrigger更常用。基于Cron表达式,用于配置CronTrigger实例,是由7个子表达式组成的字符串,描述了时间表的详细信息。格式: [秒] [分] [小时][日] [月] [周] [年],示例代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//每秒钟触发一次任务
    		CronTrigger trigger = (CronTrigger)TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").
    				withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ? *")).
    				build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		scheduler.scheduleJob(jobDetail,trigger);
    	}
    }

          常用Corn表达式:

    • 2017年内每天10点15分触发一次:0 15 10 ? * * 2017
    • 每天10点15分触发:0 15 10 ? * *
    • 每天下午的2点到2点59分执行(整点开始,每隔5分钟触发):0 0/5 14 * * ?
    • 从周一到周五的每天上午10点15分触发:0 15 10 ? * MON-FRI
    • 每月第三周的星期五(6#3:6代表星期五,#代表第)10点15分开始触发:0 15 10 ? 6#3
    • 从2016年到2017年每月最后一周的星期五10点15分触发:0 15 10 ? * 6L 2016-2017
    • 每天14点整至14点59分55秒及18点整至18点59分55秒,每5秒触发一次:0/5 * 14,18 * * ?
      说明:'L'和'W'可以一起组合使用;周字段英文字母不区分大小写,即MON和mon意识相同;可以利用在线工具自动生成。

    4.浅谈Scheduler

          Scheduler——工厂模式:所有的Scheduler实例应该由SchedulerFactory来创建,一般包含:StdSchedulerFactory、DirectSchedulerFactory(参数信息需要在代码中维护故不常用)。StdSchedulerFactory使用一组参数来创建和初始化Quartz调度器,配置参数一般存储在quartz.properties文件中,调用getScheduler方法就能创建和初始化调度器对象。Scheduler的主要函数:Data scheduleJob(JobDetail jobDetail,Trigger trigger);返回最近一次任务将要执行的时间,代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//每天10点15分触发:0 15 10 ? * *
    		//每天下午的2点到2点59分执行(整点开始,每隔5分钟触发):0 0/5 14 * * ?
    		//从周一到周五的每天上午10点15分触发:0 15 10 ? * MON-FRI
    		//每月第三周的星期五(6#3:6代表星期五,#代表第)10点15分开始触发:0 15 10 ? 6#3
    		//从2016年到2017年每月最后一周的星期五10点15分触发:0 15 10 ? * 6L 2016-2017
    		CronTrigger trigger = (CronTrigger)TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").
    				withSchedule(CronScheduleBuilder.cronSchedule("0 15 10 ? * *")).
    				build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		System.out.println("Schedule time is:"+sf.format(scheduler.scheduleJob(jobDetail,trigger)));
    	}
    }

          void start();——启动Scheduler;void standby();——将Scheduler暂时挂起,可以用start()继续执行任务;void shutDown()关闭Scheduler且不能被重启;示例代码如下:

    package com.luna.timer.quarts;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    public class HelloScheduler {
    	public static void main(String[] args) throws SchedulerException, InterruptedException {
    		// 创建一个JobDetail实例与HelloJob类绑定
    		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build();
    		//打印当前时间
    		Date startTime = new Date();
    		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		System.out.println("打印当前时间:"+sf.format(startTime));
    		//每秒钟执行一次,Scheduler执行两秒之后挂起,Scheduler挂起3秒之后重新启动
    		CronTrigger trigger = (CronTrigger)TriggerBuilder.newTrigger().
    				withIdentity("mtTrigger", "group1").
    				withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?")).
    				build();
    		//创建scheduler实例
    		SchedulerFactory sFactory = new StdSchedulerFactory();
    		Scheduler scheduler = sFactory.getScheduler();
    		scheduler.start();
    		System.out.println("Schedule time is:"+sf.format(scheduler.scheduleJob(jobDetail,trigger)));
    		Thread.sleep(2000L);
    		scheduler.standby();
    		Thread.sleep(3000L);
    		scheduler.start();
    		/**
    		 * shutDown()可以传入一个Boolean类型的参数,若参数为true:表示等待所有正在执行的job执行完毕之后,再关闭scheduler
    		 * 若参数为false,即和没有传入参数一样,表示直接关闭scheduler,不管是否有Job正在运行
    		 */
    		scheduler.shutdown(); //关闭之后不可以重新开启
    		Thread.sleep(5000L);
    		scheduler.start();//调用重新开启抛出异常:The Scheduler cannot be restarted after shutdown() has been called.
    	}
    }

          线程池属性:threadCount——工作者线程的数目,最少为1,最大不超过100;threadPriority——设置线程池线程的优先级,最小值为1,最大值为10,默认值为5;org.quartz.threadPool.class——org.quartz.simple.SimpleThreadPool;作业存储设置——描述了在调度器实例的生命周期中,job和trigger信息是如何被存储的;插件配置——满足特定需求用到的Quartz插件的配置。

    5.Quartz实际应用

        原文地址:https://blog.csdn.net/u011635492/article/details/80552481
    展开全文
  • 定时任务quartz原理以及配置

    千次阅读 2018-08-06 17:28:06
    前些日子有业务需要定时任务,经过了解选择了quartz quartz是一个用java实现的开源调度任务框架,有这么几个好处 1.配置方便,支持多任务 2.业务-定时可控,灵活配置,随时更改 3.支持分布式集群 下面是核心...

    前些日子有业务需要定时任务,经过了解选择了quartz

    quartz是一个用java实现的开源调度任务框架,有这么几个好处

    1.配置方便,支持多任务

    2.业务-定时可控,灵活配置,随时更改

    3.支持分布式集群

    下面是核心元素的关系

    在quartz中,Scheduler调度线程主要有两个:regular Scheduler Thread(执行常规调度)和Misfire Scheduler Thread(执行错失的任务)。其中Regular Thread 轮询Trigger,如果有将要触发的Trigger,则从任务线程池中获取一个空闲线程,然后执行与改Trigger关联的job;Misfire Thraed则是扫描所有的trigger,查看是否有错失的,如果有的话,根据一定的策略进行处理。

    先举个例子做定时任务配置

    引用maven

    <dependency>
          <groupId>org.quartz-scheduler</groupId>
          <artifactId>quartz</artifactId>
          <version>2.2.2</version>
        </dependency>
    
    <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context-support</artifactId>
          <version>4.3.7.RELEASE</version>
        </dependency>

    先建一个job.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="
    	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"
    	default-autowire="byName">
    
    	<description>job配置</description>
    
    	<!--采用xml配置可读性比较强 -->
    	<!--清空当月报表然后重新生成当月报表 -->
    	<bean name="test" class="cn.xxx.schedule.web.job.Test" />
    	<bean id="testJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    		<property name="jobClass">
    			<value>cn.xxx.schedule.web.util.MyDetailQuartzJobBean</value>
    		</property>
    		<property name="jobDataAsMap">
    			<map>
    				<entry key="targetObject" value="test" />
    				<entry key="targetMethod" value="run" />
    			</map>
    		</property>
    	</bean>
    	<bean id="testTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    		<property name="jobDetail">
    			<ref bean="testJob" />
    		</property>
    		<property name="cronExpression">
    			<value>0 * * * * ?</value>
    		</property>
    	</bean>
    
    
    	<!-- Scheduler集合 工厂bean-->
    	<bean id="mapScheduler"
    		  class="org.springframework.scheduling.quartz.SchedulerFactoryBean"
    		  autowire="no" lazy-init="false">
    		<property name="triggers">
    			<list>
    				<ref local="testTrigger" />
    			</list>
    		</property>
    		<property name="applicationContextSchedulerContextKey" value="applicationContext" />
    		<property name="configLocation" value="classpath:quartz.properties" />
    		<property name="startupDelay" value="10" /><!-- 延迟加载10秒,即启动后10秒再执行 -->
    	</bean>
    </beans>
    

     

    首先解决JobDetailFactoryBean的问题,在不修改Spring源码的情况下,可以避免使用这个类,直接调用JobDetail。但是使用JobDetail实现,需要自己实现MothodInvoking的逻辑,可以使用JobDetail的jobClass和JobDataAsMap属性来自定义一个Factory(Manager)来实现同样的目的。例如,本示例中新建了一个MyDetailQuartzJobBean来实现这个功能。

    import java.lang.reflect.Method;  
    
    import org.quartz.JobExecutionContext;  
    import org.quartz.JobExecutionException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.context.ApplicationContext;  
    import org.springframework.scheduling.quartz.QuartzJobBean;
    
    public class MyDetailQuartzJobBean extends QuartzJobBean {  
        private static final Logger logger = LoggerFactory.getLogger(MyDetailQuartzJobBean.class);
        private String targetObject;  
        private String targetMethod;  
        private ApplicationContext ctx;  
      
        @Override  
        protected void executeInternal(JobExecutionContext context)  
                throws JobExecutionException {  
            try {  
                logger.info("execute [" + targetObject + "] at once>>>>>>");  
                Object otargetObject = ctx.getBean(targetObject);  
                Method m = null;  
      
                try {  
                    m = otargetObject.getClass().getMethod(targetMethod, new Class[] {JobExecutionContext.class});  
                    m.invoke(otargetObject, new Object[] {context});  
                } catch (SecurityException e) {  
                    logger.error(e.toString());  
                } catch (NoSuchMethodException e) {  
                    logger.error(e.toString());  
                }  
            } catch (Exception e) {  
                throw new JobExecutionException(e);  
            }  
        }  
      
        public void setApplicationContext(ApplicationContext applicationContext) {  
            this.ctx = applicationContext;  
        }  
      
        public void setTargetObject(String targetObject) {  
            this.targetObject = targetObject;  
        }  
      
        public void setTargetMethod(String targetMethod) {  
            this.targetMethod = targetMethod;  
        }
    }

    JobDetailFactoryBean是job工厂,指定要执行的job类和方法名
    Quartz调度一次任务,会干如下的事:
    JobClass jobClass=JobDetail.getJobClass()
    Job jobInstance=jobClass.newInstance()。所以Job实现类,必须有一个public的无参构建方法。
    jobInstance.execute(JobExecutionContext context)。JobExecutionContext是Job运行的上下文,可以获得Trigger、Scheduler、JobDetail的信息
    CronTriggerFactoryBean:基于时间刻度(可以设置具体时间,具体设置时间规则下面会说)
    jobDetail:job的详细配置,依赖job工厂

    cronExpression:表达式

    lazy-init='false'那么容器启动就会执行调度程序

    triggers:依赖要执行的任务名

     通过applicationContextSchedulerContextKey属性配置spring上下文

    configLocation:本地配置如下给出:

    #表示如果某个任务到达执行时间,而此时线程池中没有可用线程时,任务等待的最大时间,如果等待时间超过下面配置的值(毫秒),本次就不在执行,而等待下一次执行时间的到来,可根据任务量和负责程度来调整  
    org.quartz.jobStore.misfireThreshold=60000
    
    #实现集群时,任务的存储实现方式,org.quartz.impl.jdbcjobstore.JobStoreTX表示数据库存储,无需修改  
    org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
    
    #quartz存储任务相关数据的表的前缀,无需修改   
    org.quartz.jobStore.tablePrefix=QRTZ_
    
    #连接数据库数据源名称,与下面配置中org.quartz.dataSource.myDS的myDS一致即可,可以无需修改    
    org.quartz.jobStore.dataSource=myDS
    
    #是否启用集群,启用,改为true,注意:启用集群后,必须配置下面的数据源,否则quartz调度器会初始化失败     
    org.quartz.jobStore.isClustered=true
    
    #集群中服务器相互检测间隔,每台服务器都会按照下面配置的时间间隔往服务器中更新自己的状态,如果某台服务器超过以下时间没有checkin,调度器就会认为该台服务器已经down掉,不会再分配任务给该台服务器  
    org.quartz.jobStore.clusterCheckinInterval=10000
    
    #==============================================================    
    #Non-Managed Configure Datasource    
    #==============================================================  
    
    #配置连接数据库的实现类,可以参照IAM数据库配置文件中的配置     
    org.quartz.dataSource.myDS.driver=com.mysql.jdbc.Driver
    
    #配置连接数据库连接,可以参照IAM数据库配置文件中的配置    
    org.quartz.dataSource.myDS.URL=jdbc:mysql://xxx:3306/quartz
    
    #配置连接数据库用户名  
    org.quartz.dataSource.myDS.user=aa
    
    #配置连接数据库密码  
    org.quartz.dataSource.myDS.password=bbbbb
    
    #配置连接数据库连接池大小,一般为上面配置的线程池的2倍  
    artz.dataSource.myDS.maxConnections=10

    下面是指定执行业务的任务,有什么话就来这里说吧

    @Slf4j
    public class Test{
    
    	public void run(JobExecutionContext context){
    		log.info("开始执行定时任务");
    
    
    		log.info("完成定时任务!");
    	}
    }

     

    下面是表结构

    表名 描述
    QRTZ_CALENDARS 以 Blob 类型存储 Quartz 的 Calendar 信息
    QRTZ_CRON_TRIGGERS 存储 Cron Trigger,包括 Cron 表达式和时区信息
    QRTZ_FIRED_TRIGGERS 存储与已触发的 Trigger 相关的状态信息,以及相联 Job 的执行信息
    QRTZ_PAUSED_TRIGGER_GRPS 存储已暂停的 Trigger 组的信息
    QRTZ_SCHEDULER_STATE 存储少量的有关 Scheduler 的状态信息,和别的 Scheduler 实例(假如是用于一个集群中)
    QRTZ_LOCKS 存储程序的非观锁的信息(假如使用了悲观锁)
    QRTZ_JOB_DETAILS 存储每一个已配置的 Job 的详细信息
    QRTZ_JOB_LISTENERS 存储有关已配置的 JobListener 的信息
    QRTZ_SIMPLE_TRIGGERS 存储简单的 Trigger,包括重复次数,间隔,以及已触的次数
    QRTZ_BLOG_TRIGGERS Trigger 作为 Blob 类型存储(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型,JobStore 并不知道如何存储实例的时候)
    QRTZ_TRIGGER_LISTENERS 存储已配置的 TriggerListener 的信息
    QRTZ_TRIGGERS 存储已配置的 Trigger 的信息

    可以在qrtz_cron_triggers这个表定时每天执行时间,比如说这个

    CRON_EXPRESSION这个字段,是按秒分时天月的顺序设置时间的,TRIGGER_NAME对应对应的任务

    第一个含义:每天下午6点执行,第二个含义每天晚上两点半执行

    qrtz_triggers这个表是详细对应关系,如果要改动下次执行时间,可以更改NEXT_FIRE_TIME

     

    资料引用:http://www.cnblogs.com/Dorae/p/9357180.html

    展开全文
  • 定时任务Quartz超详细教程

    万次阅读 2017-05-26 17:36:39
    看到一篇比较好的关于Quartz定时任务的详细介绍就想发出来,但是原博主博客打不开了。我只能发一波,希望喜欢的速来查看。。。。。 下载地址:http://download.csdn.net/detail/flower_vip/9853393 中文版...
  • 定时任务quartz与java注解

    千次阅读 2016-10-13 14:50:10
    在现在项目中注解应用越来越广泛。为了有更深的理解,前面学习了java注解使用的一些原理,做了相关的总结和梳理,对注解有了...一般的管理系统中,都会有定时执行的任务,一般用于按一定规律进行统计。比如日,周,月的
  • Spring 3整合Quartz 2实现定时任务一:常规整合 Spring 3整合Quartz 2实现定时任务二:动态添加任务 Spring 3整合Quartz 2实现定时任务三:动态暂停 恢复 修改和删除任务
  • springboot中整合分布式定时任务Quartz的模本范例。参考这个配置,十分简便 两个bean配置,一个properties文件,一个sql文件,使用的为mysql. QRTZ_tables_mysql_innodb.sql # # In your Quartz properties file,...
  • spring多个定时任务quartz配置

    万次阅读 2011-03-31 17:05:00
    spring多个定时任务quartz配置   <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=...
  • java中定时任务 quartz 时间配置规则

    万次阅读 2015-10-13 17:03:13
    quartz 时间配置规则 格式: [秒] [分] [小时] [日] [月] [周] [年]  序号 说明  是否必填  允许填写的值 允许的通配符  1  秒  是  0-59   , - * /  2  分  是  0-59  , - * /  3 小时 ...
  • spring定时任务quartz使用xml配置文件

    千次阅读 2018-05-21 13:22:55
    1. 实现写一个*.xml文件,该文件在spring初始文件中引入该文件。例如在application.xml中引入该文件。...2. 然后在在定时任务文件中配置3个步骤: &lt;bean id="InsuranceAssociationTas...
  • 初识 spring整合定时任务Quartz+mybatis

    千次阅读 2017-08-15 15:52:29
    1.指定具体的自定义的 定时任务类(自定义对象) 2.触发器收入此定时任务对象 3.调度器收入触发器 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop=...
  • Spring 注解式定时任务quartz的使用

    千次阅读 2018-05-01 14:55:30
    quartz) 二、在spring的配置文件中完成相关配置(包扫描,启用注解式定时任务,配置定时任务连接池),如下栗子: &lt;!-- 配置包扫描 --&gt; &lt;context:component-scan base-package="...
  • Spring中定时任务Quartz集群配置学习

    万次阅读 2013-09-01 16:50:17
    Spring中定时任务Quartz集群配置学习 原来配置的Quartz是通过spring配置文件生效的,发现在非集群式的服务器上运行良好,但是将工程部署到水平集群服务器上去后改定时功能不能正常运行,没有任何错误日志,于是从...
  • spring boot下定时任务quartz的集群使用

    千次阅读 2017-11-14 09:52:49
    单机模式下的定时任务调用很简单,有很多可实现的方案,这里不多说了。 这里说一下集群部署的情况下,定时任务的使用。这种情况下,quartz是一个比较好的选择。简单,稳定。 想象一下,现在有 A , B , C 3...
  • 一、关于Quartz ...在java企业级应用中,Quartz是使用最广泛的定时调度框架。 在Quartz中的主要概念: Scheduler:调度任务的主要API ScheduleBuilder:用于构建Scheduler,例如其简单实现类Simpl...
  • 谈到处理定时任务quartz应该是目前比较成熟,使用较为广泛的java任务调度框架了,功能强大配置灵活,在企业应用中占重要地位。现在就跟大家一起学习下如何在项目中使用quartz。 首先了解下Quartz的背景  Quartz...
  • Cron表达式简介  Cron表达式是一个字符串,字符串以5或6个空格隔开,分为6或7个域,每一个域代表一个含义,Cron有如下两种语法格式:  (1) Seconds Minutes Hours DayofMonth Month DayofWeek Year ...
  • 若依后台管理框架-定时任务quartz使用 最近使用了quartz定时任务,小结一下。基于若依后台管理框架ruoyi-quartz模块,这也为我们以后定时任务方面的处理提供了思路,比如引入ruoyi-quartz模块,方便的用页面管理...
  • 根据网上的解决方法,我已经关闭了定时任务Scheduler,关闭了开启定时任务的线程池,也关闭了数据源。为什么还是报错? 我的代码 package com.yz.robot.spring; import ...
  • 请问内存泄露的情况有哪些,比如ftp连接打开后没有关闭,还有其他什么场景吗,比如多线程TimerTask中什么情况会出现内存泄露 如何测试,或者怎么知道在这里出现内存泄露了呢,
  • 定时任务quartz中的job注入spring bean时null的问题 在使用quartz作定时任务的时候难免会注入spring中的管理的bean,如果不作处理,就会出现java.lang.NullPointerException的异常 序言 我们知道quartz中实现一...
  • 这段时间做某项目,每天都有大量的生产数据,需要统计到,每天,每个月,每年的总数,这个可以在明天凌晨,下个月1号凌晨,下一年度1曰1号统计,而当天,当月,当年,则需要实时统计了。 这里我之前下载了个例子,...
  • 我要设置定时任务,每年的6月31日执行。 按照论坛上说的,cron可以设置6位或7位域。 仿照规则,有表达式:@Scheduled(cron="0 0 0 31 6 ? 2014-2099") 可是一直启动报错,提示必须6位域? 网上都说可以6位或7...
  • 前言: 在quartz框架中,Job 是通过反射出来的实例,不受spring的管理。Scheduler现在交给Spring生成,在Spirng-context-support jar包下org.springframework.scheduling.quartz包中有个SpringBeanJobFactory的类...
  • 环境:springboot 排查问题过程: 1:确认不是serialVersionUID版本问题 2:确认不是序列化工具(Jackson)问题 3:写了一个测试方法:将对象put到JobDataMap中,再取出来强转,并无问题 解决方法:去掉spring-...
  • 在jfinal项目中使用定时任务quartz,后台会一直抛异常:com.jfinal.plugin.activerecord.ActiveRecordException: com.alibaba.druid.pool.DataSourceClosedException: dataSource already closed at Tue S

空空如也

1 2 3 4 5 ... 20
收藏数 91,323
精华内容 36,529
关键字:

定时任务