springboot 에서 quartz 를 사용 하여 정시 작업 을 진행 합 니 다.

장면:정시 퀘 스 트 를 사용 하여 결산 작업 을 진행 하려 면 크로스 서비스 가 필요 합 니 다.기술:정시 임 무 는 여러 가지 가 있 습 니 다.데이터 양 이 적 고 분포 식 작업 과 관련 되 지 않 기 때문에 무 거 운 프레임 워 크 를 사용 할 준비 가 되 어 있 지 않 습 니 다.하지만 정시 미 션 이 수 동 으로 켜 졌 으 면 좋 겠 기 때문에 spring boot 자체 의 정시 미 션 은 적합 하지 않 습 니 다.최종 적 으로 quartz 를 사용 하기 로 결정 했다.
quartz 소개:
job:인터페이스,안에 execute 방법 이 있어 야 합 니 다.그 중에서 매개 변수 JobExecution Context 는 job 와 관련 된 정 보 를 봉인 했다.
JobDetail:Use aJobKeywith the given name and group to identify the JobDetail 은 name 처럼 group 이 다 르 더 라 도 같은 정시 작업 이 아 닙 니 다.job 보다 인자 group 이 하나 더 많 습 니 다.
Trigger:Use a TriggerKey with the given name and group to identify the Trigger 역시 name 과 group 을 통 해 유일한 표 지 를 하지만 TriggerBuilder 가 trigger 를 구축 할 때 사용 하지 않 았 다 면withIdentity(name,group)일반적인 trigger 를 사용 합 니 다.
Scheduler:스 케 쥴 러 용기,Job 과 Trigger 는 모두 용기 에 등록 하고 용기 에 의 해 통일 적 으로 관리 되 어야 합 니 다.scheduler 에 job 의 기본 동작 이 있 습 니 다.예 를 들 어 일시 정지 삭제 등 이 있 습 니 다.
quartz springboot 도입:
인입 가방

       
            org.quartz-scheduler
            quartz
            2.2.1
        
        
            org.springframework
            spring-context-support
             

시작 시 tomcat 정보

2018-11-22 11:26:57 localhost-startStop-1 INFO Scheduler meta-data: Quartz Scheduler (v2.2.1) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 5 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.

quartz 저장 방식 이 많 습 니 다.저 는 편리 하도록 메모리 에 직접 존재 하고 데이터 베 이 스 를 존재 할 수 있 습 니 다.설정 파일 을 resource 아래 에 직접 복사 하면 됩 니 다.springboot 는 설정 정 보 를 자동 으로 읽 습 니 다.

#     org.quartz
#     scheduler、threadPool、jobStore、plugin   
#
#
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

#    ThreadPool ，       SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# threadCount threadPriority  setter     ThreadPool  
#     
org.quartz.threadPool.threadCount = 5
#    
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

org.quartz.jobStore.misfireThreshold = 5000

#         
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

#   ，        
#org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

#org.quartz.jobStore.tablePrefix = QRTZ_

#org.quartz.jobStore.dataSource = qzDS

#org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver

#org.quartz.dataSource.qzDS.URL =

#org.quartz.dataSource.qzDS.user = 

#org.quartz.dataSource.qzDS.password = 

#org.quartz.dataSource.qzDS.maxConnections = 10

여기에 구 덩이 를 기록 하고 job 실현 류 에서@Autowiredservices 를 주입 하여 데이터 베 이 스 를 조작 하거나 다른 것 을 하면 빈 포인터 이상 을 알 립 니 다.즉,jobinstancespring 에 대리 되 지 않 았 으 며,JobFactory에서 사용AutowireCapableBeanFactory하여 수 동 으로 주입 해 야 한 다 는 것 이다.

@Component
public class JobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //       
        Object jobInstance = super.createJobInstance(bundle);
        //    
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

설정 정보:

@Configuration
public class SchedulerConfig {

	@Autowired   
	private JobFactory jobFactory;
	
    @Bean(name="SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
    	SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        return factory;

    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        // quartz.properties                 
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /*
     * quartz      
     */
    @Bean
    public QuartzInitializerListener executorListener() {
       return new QuartzInitializerListener();
    }

    /*
     *   SchedulerFactoryBean  Scheduler   
     */
    @Bean(name="Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

}

@RestContorller을 사용 하여 정시 퀘 스 트 의 오픈 정지 등 작업 을 진행 합 니 다.

@RestController
@RequestMapping(value="/job")
public class JobController 
{
	
	
	//  Qulifier  ，      bean
	@Autowired @Qualifier("Scheduler")
	private Scheduler scheduler;	

	@PostMapping(value="/addjob")
	public void addjob(@RequestBody Map paraMap) throws Exception
	{			
		addJob(paraMap.get("jobClassName"), paraMap.get("jobGroupName"), paraMap.get("cronExpression"));
	}
	
	public void addJob(String jobClassName, String jobGroupName, String cronExpression)throws Exception{
        
        //        
		scheduler.start(); 
		
		//  job  
		JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).build();
		
		//        (        )
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //   cronExpression         trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
            .withSchedule(scheduleBuilder).build();
        
        try {
        	scheduler.scheduleJob(jobDetail, trigger);
            
        } catch (SchedulerException e) {
            System.out.println("        "+e);
            throw new Exception("        ");
        }
	}
 

	@PostMapping(value="/pausejob")
	public void pausejob(@RequestBody Map paraMap) throws Exception
	{			 
		jobPause(paraMap.get("jobClassName"), paraMap.get("jobGroupName"));
	}
	
	public void jobPause(String jobClassName, String jobGroupName) throws Exception
	{	
		scheduler.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
	}
	

	@PostMapping(value="/resumejob")
	public void resumejob(@RequestBody Map paraMap) throws Exception
	{			
		jobresume(paraMap.get("jobClassName"), paraMap.get("jobGroupName"));
	}
	
	public void jobresume(String jobClassName, String jobGroupName) throws Exception
	{
		scheduler.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
	}
	
	
	@PostMapping(value="/reschedulejob")
	public void rescheduleJob(@RequestBody Map paraMap) throws Exception
	{			
		jobreschedule(paraMap.get("jobClassName"), paraMap.get("jobGroupName"), paraMap.get("cronExpression"));
	}
	
	public void jobreschedule(String jobClassName, String jobGroupName, String cronExpression) throws Exception
	{				
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
			//         
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

			//    cronExpression       trigger
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

			//    trigger    job  
			scheduler.rescheduleJob(triggerKey, trigger);
		} catch (SchedulerException e) {
			System.out.println("        "+e);
			throw new Exception("        ");
		}
	}
	
	
	@PostMapping(value="/deletejob")
	public void deletejob(@RequestBody Map paraMap) throws Exception
	{			
		jobdelete(paraMap.get("jobClassName"), paraMap.get("jobGroupName"));
	}
	
	public void jobdelete(String jobClassName, String jobGroupName) throws Exception
	{		
		scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
		scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
		scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));				
	}
	
	@PostMapping(value="/getalljob")
	public List getalljob() throws Exception
	{			
		return getAllJobs();
	}
	public List getAllJobs(){
        try {                    
        	List list = new ArrayList();
            for (String groupName : scheduler.getJobGroupNames()) {
                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                    String jobName = jobKey.getName();
                    String jobGroup = jobKey.getGroup();
                    //get job's trigger
                    List triggers = (List) scheduler.getTriggersOfJob(jobKey);
                    Date nextFireTime = triggers.get(0).getNextFireTime();
                    list.add(("[jobName] : " + jobName + " [groupName] : "
                        + jobGroup + " - " + nextFireTime));
                    
                }
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
		return null;
    }
	
	
	public static BaseJob getClass(String classname) throws Exception 
	{
		Class> class1 = Class.forName(classname);
		return (BaseJob)class1.newInstance();
	}
	
	
}

import org.quartz.Job;

public interface BaseJob extends Job {

}