Spring Boot 2 통합 QuartJob 타이머 실시 간 관리 기능 구현

1.QuartJob 소개
1.한 마디 설명
Quartz 는 완전히 자바 가 작성 한 오픈 소스 작업 스케줄 링 프레임 워 크 로 형식 이 간단 하고 기능 이 강하 다.
2.핵심 API
(1)、Scheduler
Quartz 를 대표 하 는 독립 실행 용 기 는 Scheduler 가 Trigger 를 특정 JobDetail 에 연결 하면 Trigger 가 트리거 할 때 해당 하 는 Job 이 배 치 됩 니 다.
(2)、Trigger
Job 이 실행 하 는 시간 트리거 규칙 을 설명 합 니 다.주로 Simple Trigger 와 CronTrigger 두 가지 키 가 있 는데 하나의 TriggerKey 를 통 해 유일한 표 지 를 통과 합 니 다.
(3)、Job
임 무 를 정의 하고 임 무 를 수행 할 때의 행 위 를 규정 합 니 다.JobExecutionContext 는 스케줄 러 의 컨 텍스트 정 보 를 제공 합 니 다.Job 의 데 이 터 는 JobDataMap 에서 얻 을 수 있 습 니 다.
(4)、JobDetail
Quartz 는 Job 을 실행 할 때마다 Job 인 스 턴 스 를 다시 만 들 기 때문에 Job 의 인 스 턴 스 를 직접 받 아들 이지 않 고 Job 구현 클래스 를 받 습 니 다.Job 의 실현 클래스 와 다른 정적 정 보 를 설명 합 니 다.예 를 들 어 Job 이름,설명 등 입 니 다.
2.SpringBoot 2.0 과 통합
1.프로젝트 구조

버 전 설명
spring-boot:2.1.3.RELEASE
quart-job:2.3.0
2.타이머 설정

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import javax.sql.DataSource;
import java.util.Properties;
@Configuration
public class ScheduleConfig {
 @Bean
 public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) {
 // Quartz    
 Properties prop = new Properties();
 // Schedule        
 prop.put("org.quartz.scheduler.instanceName", "HuskyScheduler");
 //    AUTO   ,     org.quartz.scheduler.SimpleInstanceGenerator             。
 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  :Scheduler             
 // JDBCJobStore JobStoreTX           Schedule     。
 // JobStoreTX           commit  rollback     。
 prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
 //     :                  true
 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_");
 //   LOCKS                SQL   
 prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?");

 //        
 SchedulerFactoryBean factory = new SchedulerFactoryBean();
 factory.setDataSource(dataSource);
 factory.setQuartzProperties(prop);
 factory.setSchedulerName("HuskyScheduler");
 factory.setStartupDelay(30);
 factory.setApplicationContextSchedulerContextKey("applicationContextKey");
 //   ,QuartzScheduler          Job
 factory.setOverwriteExistingJobs(true);
 //       ,   true
 factory.setAutoStartup(true);
 return factory;
 }
}
3.타이머 관리 도구

import com.quart.job.entity.ScheduleJobBean;
import org.quartz.*;
/**
 *       
 */
public class ScheduleUtil {
 private ScheduleUtil (){}
 private static final String SCHEDULE_NAME = "HUSKY_" ;
 /**
 *     KEY
 */
 public static TriggerKey getTriggerKey(Long jobId){
 return TriggerKey.triggerKey(SCHEDULE_NAME+jobId) ;
 }
 /**
 *     Key
 */
 public static JobKey getJobKey (Long jobId){
 return JobKey.jobKey(SCHEDULE_NAME+jobId) ;
 }
 /**
 *       
 */
 public static CronTrigger getCronTrigger (Scheduler scheduler,Long jobId){
 try {
  return (CronTrigger)scheduler.getTrigger(getTriggerKey(jobId)) ;
 } catch (SchedulerException e){
  throw new RuntimeException("getCronTrigger Fail",e) ;
 }
 }
 /**
 *      
 */
 public static void createJob (Scheduler scheduler, ScheduleJobBean scheduleJob){
 try {
  //      
  JobDetail jobDetail = JobBuilder.newJob(TaskJobLog.class).withIdentity(getJobKey(scheduleJob.getJobId())).build() ;
  CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
   .cronSchedule(scheduleJob.getCronExpression())
   .withMisfireHandlingInstructionDoNothing() ;
  CronTrigger trigger = TriggerBuilder.newTrigger()
   .withIdentity(getTriggerKey(scheduleJob.getJobId()))
   .withSchedule(scheduleBuilder).build() ;
  jobDetail.getJobDataMap().put(ScheduleJobBean.JOB_PARAM_KEY,scheduleJob);
  scheduler.scheduleJob(jobDetail,trigger) ;
  //             
  if (scheduleJob.getStatus() == 1){
  pauseJob(scheduler,scheduleJob.getJobId()) ;
  }
 } catch (SchedulerException e){
  throw new RuntimeException("createJob Fail",e) ;
 }
 }
 /**
 *       
 */
 public static void updateJob(Scheduler scheduler, ScheduleJobBean scheduleJob) {
 try {
  //      
  TriggerKey triggerKey = getTriggerKey(scheduleJob.getJobId());
  CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
   .withMisfireHandlingInstructionDoNothing();
  CronTrigger trigger = getCronTrigger(scheduler, scheduleJob.getJobId());
  trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
  trigger.getJobDataMap().put(ScheduleJobBean.JOB_PARAM_KEY, scheduleJob);
  scheduler.rescheduleJob(triggerKey, trigger);
  //             
  if(scheduleJob.getStatus() == 1){
  pauseJob(scheduler, scheduleJob.getJobId());
  }
 } catch (SchedulerException e) {
  throw new RuntimeException("updateJob Fail",e) ;
 }
 }
 /**
 *      
 */
 public static void pauseJob (Scheduler scheduler,Long jobId){
 try {
  scheduler.pauseJob(getJobKey(jobId));
 } catch (SchedulerException e){
  throw new RuntimeException("pauseJob Fail",e) ;
 }
 }
 /**
 *      
 */
 public static void resumeJob (Scheduler scheduler,Long jobId){
 try {
  scheduler.resumeJob(getJobKey(jobId));
 } catch (SchedulerException e){
  throw new RuntimeException("resumeJob Fail",e) ;
 }
 }
 /**
 *      
 */
 public static void deleteJob (Scheduler scheduler,Long jobId){
 try {
  scheduler.deleteJob(getJobKey(jobId));
 } catch (SchedulerException e){
  throw new RuntimeException("deleteJob Fail",e) ;
 }
 }
 /**
 *      
 */
 public static void run (Scheduler scheduler, ScheduleJobBean scheduleJob){
 try {
  JobDataMap dataMap = new JobDataMap() ;
  dataMap.put(ScheduleJobBean.JOB_PARAM_KEY,scheduleJob);
  scheduler.triggerJob(getJobKey(scheduleJob.getJobId()),dataMap);
 } catch (SchedulerException e){
  throw new RuntimeException("run Fail",e) ;
 }
 }
}
4.타이머 실행 과 로그

import com.quart.job.entity.ScheduleJobBean;
import com.quart.job.entity.ScheduleJobLogBean;
import com.quart.job.service.ScheduleJobLogService;
import org.quartz.JobExecutionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.lang.reflect.Method;
import java.util.Date;
/**
 *          
 */
public class TaskJobLog extends QuartzJobBean {
 private static final Logger LOG = LoggerFactory.getLogger(TaskJobLog.class) ;
 @Override
 protected void executeInternal(JobExecutionContext context) {
 ScheduleJobBean jobBean = (ScheduleJobBean)context.getMergedJobDataMap().get(ScheduleJobBean.JOB_PARAM_KEY) ;
 ScheduleJobLogService scheduleJobLogService = (ScheduleJobLogService)SpringContextUtil.getBean("scheduleJobLogService") ;
 //        
 ScheduleJobLogBean logBean = new ScheduleJobLogBean () ;
 logBean.setJobId(jobBean.getJobId());
 logBean.setBeanName(jobBean.getBeanName());
 logBean.setParams(jobBean.getParams());
 logBean.setCreateTime(new Date());
 long beginTime = System.currentTimeMillis() ;
 try {
  //           run   
  Object target = SpringContextUtil.getBean(jobBean.getBeanName());
  Method method = target.getClass().getDeclaredMethod("run", String.class);
  method.invoke(target, jobBean.getParams());
  long executeTime = System.currentTimeMillis() - beginTime;
  logBean.setTimes((int)executeTime);
  logBean.setStatus(0);
  LOG.info("    === >> "+jobBean.getJobId()+"    ,   === >> " + executeTime);
 } catch (Exception e){
  //     
  long executeTime = System.currentTimeMillis() - beginTime;
  logBean.setTimes((int)executeTime);
  logBean.setStatus(1);
  logBean.setError(e.getMessage());
 } finally {
  scheduleJobLogService.insert(logBean) ;
 }
 }
}
3.타이머 서비스 패키지
1.타이머 초기 화

@Service
public class ScheduleJobServiceImpl implements ScheduleJobService {

 @Resource
 private Scheduler scheduler ;
 @Resource
 private ScheduleJobMapper scheduleJobMapper ;

 /**
 *       
 */
 @PostConstruct
 public void init (){
 ScheduleJobExample example = new ScheduleJobExample() ;
 List<ScheduleJobBean> scheduleJobBeanList = scheduleJobMapper.selectByExample(example) ;
 for (ScheduleJobBean scheduleJobBean : scheduleJobBeanList) {
  CronTrigger cronTrigger = ScheduleUtil.getCronTrigger(scheduler,scheduleJobBean.getJobId()) ;
  if (cronTrigger == null){
  ScheduleUtil.createJob(scheduler,scheduleJobBean);
  } else {
  ScheduleUtil.updateJob(scheduler,scheduleJobBean);
  }
 }
 }
}

2.타이머 추가

@Override
@Transactional(rollbackFor = Exception.class)
public int insert(ScheduleJobBean record) {
 ScheduleUtil.createJob(scheduler,record);
 return scheduleJobMapper.insert(record);
}

3.타이머 즉시 실행

@Override
@Transactional(rollbackFor = Exception.class)
public void run(Long jobId) {
 ScheduleJobBean scheduleJobBean = scheduleJobMapper.selectByPrimaryKey(jobId) ;
 ScheduleUtil.run(scheduler,scheduleJobBean);
}

4.타이머 업데이트

@Override
@Transactional(rollbackFor = Exception.class)
public int updateByPrimaryKeySelective(ScheduleJobBean record) {
 ScheduleUtil.updateJob(scheduler,record);
 return scheduleJobMapper.updateByPrimaryKeySelective(record);
}

5.타이머 정지

@Override
@Transactional(rollbackFor = Exception.class)
public void pauseJob(Long jobId) {
 ScheduleJobBean scheduleJobBean = scheduleJobMapper.selectByPrimaryKey(jobId) ;
 ScheduleUtil.pauseJob(scheduler,jobId);
 scheduleJobBean.setStatus(1);
 scheduleJobMapper.updateByPrimaryKeySelective(scheduleJobBean) ;
}

6.복구 타이머

@Override
@Transactional(rollbackFor = Exception.class)
public void resumeJob(Long jobId) {
 ScheduleJobBean scheduleJobBean = scheduleJobMapper.selectByPrimaryKey(jobId) ;
 ScheduleUtil.resumeJob(scheduler,jobId);
 scheduleJobBean.setStatus(0);
 scheduleJobMapper.updateByPrimaryKeySelective(scheduleJobBean) ;
}
7.타이머 삭제

@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long jobId) {
 ScheduleUtil.deleteJob(scheduler, jobId);
 scheduleJobMapper.deleteByPrimaryKey(jobId) ;
}

4.테스트 타이머 설정
1.정시 인터페이스 패키지

public interface TaskService {
 void run(String params);
}
2.테스트 타이머

@Component("getTimeTask")
public class GetTimeTask implements TaskService {
 private static final Logger LOG = LoggerFactory.getLogger(GetTimeTask.class.getName()) ;
 private static final SimpleDateFormat format =
  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
 @Override
 public void run(String params) {
 LOG.info("Params === >> " + params);
 LOG.info("    ::::"+format.format(new Date()));
 }
}

소스 코드
GitHub:웃 어 봐
https://github.com/cicadasmile/middle-ware-parent

총결산
위 에서 말씀 드 린 것 은 편집장 님 께 서 소개 해 주신 Spring Boot 2 는 QuartJob 을 통합 하여 타이머 실시 간 관리 기능 을 실현 하 는 것 입 니 다.여러분 께 도움 이 되 기 를 바 랍 니 다.궁금 한 점 이 있 으 시 면 메 시 지 를 남 겨 주세요.편집장 님 께 서 바로 답 해 드 리 겠 습 니 다.여기 서도 저희 사이트 에 대한 여러분 의 지지 에 감 사 드 립 니 다!
만약 당신 이 본문 이 당신 에 게 도움 이 된다 고 생각한다 면,전 재 를 환영 합 니 다.번 거 로 우 시 겠 지만 출처 를 밝 혀 주 십시오.감사합니다!

좋은 웹페이지 즐겨찾기