回転するxの統合タイミングタスク編

24031 ワード
【Spring Boot】
1 springbootデフォルトのタイミングタスク処理
公式ドキュメントを表示するには、次の手順に従います.http://spring.io/guides/gs/scheduling-tasks/ここでは公式ドキュメントに基づいて、どのように使用するかを説明します.
spirngbootが持参したタスクスケジューリングを使用するには、合計2ステップかかります.
1クラス宣言の開始@EnableScheduling
2 spring beanメソッドで@Scheduledを宣言し、注記で起動するルールを指定します.
ダイレクトコード
package cn.lijunkui;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class SpringbootlearnApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringbootlearnApplication.class, args);
	}
}
package cn.lijunkui.task.own;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
 *
 * @author lijunkui
 *
 */
@Component
public class SchedulerTask {
	
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
	//            5     
    @Scheduled(fixedRate = 5000)
    public void reportCurrentTimeFixedRate() {
    	try {
			Thread.sleep(6*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
        log.info("reportCurrentTimeFixedRate The time is now {}", dateFormat.format(new Date()));
    }
}

テスト効果
fixedRate:タスク実行時間は3秒でタスク間隔を5秒に設定し実際に5秒ごとに実行する

fixedRate:タスク実行時間は6秒でタスク間隔を5秒に設定して実際に6秒ごとに実行する

 
次に、Scheduled注釈のよく使用されるパラメータ設定項目について重点的に説明します.
fixedRate:一定の時間実行、つまり何秒に1回実行しますか.これは私たちの上のコードで紹介しました.
fixedDelay:実行完了後5秒後に実行
initialDelay:起動後何秒遅延した後に実行するかは単独では使用できません.
次に、fixedDelayとinitialDelayの設定項目のdemoケースを見てみましょう.
package cn.lijunkui;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

import cn.lijunkui.task.own.SchedulerTask;

@SpringBootApplication
@EnableScheduling
public class SpringbootlearnApplication {
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss"); 
	public static void main(String[] args) {
		SpringApplication.run(SpringbootlearnApplication.class, args);
		 log.info("reportCurrentTimeInitialDelay fixedRate The time is start {}", dateFormat.format(new Date()));
	}
}

package cn.lijunkui.task.own;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
 * 
 * @author jrrry
 *
 */
@Component
public class SchedulerTask {
	
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

    @Scheduled(initialDelay=0, fixedDelay=5000)
    public void reportCurrentTimeInitialDelay() {
    	try {
			Thread.sleep(6*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
        log.info("reportCurrentTimeInitialDelay fixedRate The time is now {}", dateFormat.format(new Date()));
    }
	
}

テスト結果:
fixedDelay:タスク実行時間は3秒ですタスク時間間隔を5秒に設定して実際に8秒ごとに実行します

fixedDelay:タスク実行時間は6秒ですタスク時間間隔を5秒に設定して実際に11秒ごとに実行します
 
同時にScheduledはCron式もサポートしています
package cn.lijunkui.task.own;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class SchedulerTaskForCron {
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
	/**
	 *    14:00     
	 */
	@Scheduled(cron="0 0 14 * * ?")
	private void cron() {
		 log.info("cron The time is now {}", dateFormat.format(new Date()));
	}
	
	/**
	 *  5     
	 */
	@Scheduled(cron="0/5 * * * * ?")
	private void cron2() {
		try {
			Thread.sleep(6*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		log.info("cron2 The time is now {}", dateFormat.format(new Date()));
	}
}

テスト結果:
タスク実行時間は3秒ですタスク時間間隔を5秒に設定して実際に5秒ごとに実行します

タスク実行時間は6秒設定タスク間隔5秒実際に11秒ごとに実行
 
cronの使用ルールについては、次のようなオンライン生成ツールがたくさんあります.http://www.bejson.com/othertools/cron/
2 springboot使用JDKタイミングタスク処理
2.1 Timer  
package cn.lijunkui.task.jdk;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cn.lijunkui.task.own.SchedulerTask;

public class DemoTask extends TimerTask{
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
	@Override
	public void run() {
		try {
			Thread.sleep(4*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		 log.info("DemoTask The time is now {}", dateFormat.format(new Date()));
	}

}
package cn.lijunkui.task.jdk;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;

public class TimerTest {
	
	private DemoTask demoTask;
	
	public TimerTest(DemoTask demoTask) {
		this.demoTask = demoTask;
	}
	public void run() throws ParseException {
		Timer timer = new Timer();
		long delay = 0;
		long intevalPeriod = 1 * 1000;
		//timer.scheduleAtFixedRate(demoTask, delay, intevalPeriod);//      
		//timer.scheduleAtFixedRate(demoTask, 1000, intevalPeriod);//           
		String datetimeStr = "2018-10-16 15:00:00";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date firstTime = sdf.parse(datetimeStr);
		timer.schedule(demoTask, firstTime, intevalPeriod);//3             
	}
}

  
package cn.lijunkui.task.jdk;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Order(value = 1)
public class DemoTaskRunner implements ApplicationRunner{

	@Override
	public void run(ApplicationArguments args) throws Exception {
		TimerTest test = new TimerTest(new DemoTask());
		test.run();
	}
}

schedule:タスク実行時間は2秒設定の間隔は3秒です.私たちのタスクは3秒ごとに実行します.

schedule:タスク実行時間は4秒設定の間隔は3秒です.私たちのタスクは4秒ごとに実行します.
 
scheduleAtFixedRate:タスク実行時間は2秒設定の時間間隔は3秒です私たちのタスクは3秒ごとに実行します

scheduleAtFixedRate:タスク実行時間は4秒設定の時間間隔は3秒です.私たちのタスクは4秒ごとに実行します.

 
2.2  ScheduledExecutorService
Java SE5 java.util.concurrentでは、ScheduledExecutorServiceが新しいタスクスケジューリングを提供しています.彼はスレッドプール方式で実行され、Timer構文よりも簡単です.     
package cn.lijunkui.task.jdk.scheduledExecutorService;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cn.lijunkui.task.own.SchedulerTask;

public class ScheduledExecutorTask implements Runnable{
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
	@Override
	public void run() {
		try {
			Thread.sleep(4*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		 log.info("scheduledExecutorTask The time is now {}", dateFormat.format(new Date()));
	}
}
package cn.lijunkui.task.jdk.scheduledExecutorService;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorTest {
	private ScheduledExecutorTask task;
	public ScheduledExecutorTest(ScheduledExecutorTask task) {
		this.task = task;
	}
	public void run() {
		ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); 
		
		 //                        
		//                 ，                ！
	   //service.scheduleAtFixedRate(task, 0, 3, TimeUnit.SECONDS);//     
	    //            +       
	    //service.scheduleWithFixedDelay(task,0, 3, TimeUnit.SECONDS);//     
		//                 +       
	    service.schedule(task, 3, TimeUnit.SECONDS);
	}
}
package cn.lijunkui.task.jdk.timer;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import cn.lijunkui.task.jdk.scheduledExecutorService.ScheduledExecutorTask;
import cn.lijunkui.task.jdk.scheduledExecutorService.ScheduledExecutorTest;
@Component
@Order(value = 1)
public class DemoTaskRunner implements ApplicationRunner{

	@Override
	public void run(ApplicationArguments args) throws Exception {
		//TimerTest test = new TimerTest(new DemoTask());
		//test.run();
		ScheduledExecutorTest test = new ScheduledExecutorTest(new ScheduledExecutorTask());
		test.run();
	}
}

テスト結果:
scheduleAtFixedRate:タスク実行時間は2秒設定の時間間隔は3秒です私たちのタスクは3秒ごとに実行します
 
玩转springboot2.x之整合定时任务篇_第1张图片
scheduleAtFixedRate:タスク実行時間は4秒設定の時間間隔は3秒です.私たちのタスクは4秒ごとに実行します.

scheduleWithFixedDelay:タスク実行時間は2秒設定の間隔は3秒です.私たちのタスクは5秒ごとに実行します.

scheduleWithFixedDelay:タスク実行時間は4秒設定の間隔は3秒です.私たちのタスクは7秒ごとに実行します.

schedule:タスク実行時間は2秒設定の間隔は3秒です.私たちのタスクは5秒ごとに実行します.

schedule:タスク実行時間は4秒設定の間隔は3秒です.私たちのタスクは7秒ごとに実行します.

scheduleAtFixedRateとscheduleWithFixedDelayを上記のテストでテストしました.彼の時間間隔がより合理的であるため、scheduleAtFixedRateを使用することをお勧めします.
3 springboot統合quartz
Springboot 2.0にはすでにquartzのstart依存があり、quartzのstart依存を直接導入してquartzを使用することができます.
まずquartz start依存性を導入します
		
		   org.springframework.boot
		   spring-boot-starter-quartz

quartzのjobを定義する
package cn.lijunkui.task.quartz.simple;

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

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;

import cn.lijunkui.task.own.SchedulerTask;
import cn.lijunkui.task.quartz.simple.service.OrderService;

public class SimpleJob  extends QuartzJobBean{
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
	@Autowired
	private OrderService  orderService;//  service
	private String serviceCode;//  code
	

	public String getServiceCode() {
		return serviceCode;
	}
	public void setServiceCode(String serviceCode) {
		this.serviceCode = serviceCode;
	}

	@Override
	protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
		
		System.out.println(serviceCode);
		 log.info("quartz simple The time is now {}", dateFormat.format(new Date()));
		orderService.delete();
	}

}

quartzのコンフィグを作成するJobDetailとトリガTriggerを同時に定義する
package cn.lijunkui.task.quartz.simple;

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

@Configuration
public class SimpleJobConfig {
	@Bean
	public JobDetail simpleJobDetail() {
		
		return JobBuilder.newJob(SimpleJob.class).withIdentity("myJob").storeDurably()
				 	.usingJobData("serviceCode","delete overdue orders")
	                .build();
	}
	@Bean
	public Trigger simpleJobTrigger() {
		//         
		SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever();
		//     
		return TriggerBuilder.newTrigger().forJob(simpleJobDetail()).withIdentity("myJobTrigger").withSchedule(simpleScheduleBuilder).build();
	}
}

注入されたジョブのサービスの定義
package cn.lijunkui.task.quartz.simple.service;

import org.springframework.stereotype.Service;

@Service
public class OrderService {
	public void delete() {
		try {
			Thread.sleep(6*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("delete data sucess....");
	}
}

テストログ:
orderService遅延2秒タスクは3秒ごとに実行されます
  玩转springboot2.x之整合定时任务篇_第2张图片
orderService遅延6秒タスクは3秒ごとに実行されます
玩转springboot2.x之整合定时任务篇_第3张图片
quartz cron式の使用
cron式の動作方式は上記と基本的に一致していますが、私たちのjobは継承方式ではなくjobを実現する必要があります.ここでは、2つの内容が一致するjobの具体的なコードを定義します.
package cn.lijunkui.task.quartz.cron;

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

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import cn.lijunkui.task.own.SchedulerTask;
import cn.lijunkui.task.quartz.cron.service.LiveReminderService;

public class CronJob implements Job{
	private static final Logger log = LoggerFactory.getLogger(SchedulerTask.class);
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
	@Autowired
	private LiveReminderService  liveReminderService;//     
	private String serviceCode;//  code Live lesson reminder

	public String getServiceCode() {
		return serviceCode;
	}
	public void setServiceCode(String serviceCode) {
		this.serviceCode = serviceCode;
	}
    @Override  
    public void execute(JobExecutionContext context) throws JobExecutionException {
    	log.info("quartz cron The time is now {}", dateFormat.format(new Date()));
    	System.out.println("CronJob"+serviceCode);
    	liveReminderService.sendmessage();
    } 
}

  
package cn.lijunkui.task.quartz.cron;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;

import cn.lijunkui.task.quartz.cron.service.LiveReminderService;

public class CronJob2 implements Job{
	@Autowired
	private LiveReminderService  liveReminderService;//     
	private String serviceCode;//  code Live lesson reminder

	public String getServiceCode() {
		return serviceCode;
	}
	public void setServiceCode(String serviceCode) {
		this.serviceCode = serviceCode;
	}
    @Override  
    public void execute(JobExecutionContext context) throws JobExecutionException {
    	System.out.println("CronJob2"+serviceCode);
    	liveReminderService.sendmessage();
    } 
}

定義cron式統合JobDetailとトリガTriggerのmangerクラスは、上記で定義したConfig原理と同じです.
package cn.lijunkui.task.quartz.cron;

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.TriggerBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

@Component
public class CronSchedulerJobManger {
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    
    public void scheduleJobs() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        scheduleJob1(scheduler);
        //scheduleJob2(scheduler);   
    }  
    
    private void scheduleJob1(Scheduler scheduler) throws SchedulerException{
        JobDetail jobDetail = JobBuilder.newJob(CronJob.class) .withIdentity("job1", "group1")
        		.usingJobData("serviceCode","Live lesson reminder1").build();
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1") .withSchedule(scheduleBuilder).build();
        scheduler.scheduleJob(jobDetail,cronTrigger);   
    }  
      
    private void scheduleJob2(Scheduler scheduler) throws SchedulerException{
        JobDetail jobDetail = JobBuilder.newJob(CronJob2.class) .withIdentity("job2", "group2")
        		.usingJobData("serviceCode","Live lesson reminder2").build();
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/10 * * * * ?");
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger2", "group2") .withSchedule(scheduleBuilder).build();
        scheduler.scheduleJob(jobDetail,cronTrigger);  
    } 
}

生放送レッスンのアラートのサービスの定義
package cn.lijunkui.task.quartz.cron.service;

import org.springframework.stereotype.Service;

@Service
public class LiveReminderService {
	public void sendmessage() {
		try {
			Thread.sleep(10*1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("xiaoming xiaoliu xiaoli has 3:00 Live broadcast lesson");
	}
}

開始クラスを定義して、プロジェクトが開始されるとCronSchedulerJobMangerのタイミングタスクを実行します.
package cn.lijunkui.task.quartz.cron;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class CronSchedulerRunner implements CommandLineRunner {
	@Autowired
	public CronSchedulerJobManger manger;
	@Override
	public void run(String... args) throws Exception {
		manger.scheduleJobs();
	}

}

テスト結果:
タスク実行時間4秒タイミングタスク設定時間5秒間隔実際の実行効果は5秒ごとに
玩转springboot2.x之整合定时任务篇_第4张图片
タスク実行時間10秒タイミングタスク設定時間5秒間隔実際の実行効果は5秒ごとに
玩转springboot2.x之整合定时任务篇_第5张图片
demoツールとバージョンの説明:
開発ツール:Spring Tool Suite(STS)
jdkバージョン:1.8.0_144
Springbootバージョン:2.0.5.RELEASE
 
ソースの表示
ThinkPHP+uploadify+upload+PHPExcelによるインポートデータのリフレッシュなし
jqueryの下でjavascriptコードを組織する(js関数化)