quartz定时任务以及自动创建订单

基本概述

Quartz是一个完全由java编写的开源任务调度的框架，通过触发器设置作业定时运行规则，控制作业的运行时间
Quartz框架主要核心组件包括调度器、触发器、作业。调度器作为作业的总指挥，触发器作为作业的操作者，作业为应用的功能模块。其关系如下图所示

Job为作业的接口，为任务调度的对象；JobDetail用来描述Job的实现类及其它相关的静态信息；Trigger为作业的定时管理工具，一个Trigger只能对应一个作业实例，而一个作业实例可对应多个触发器；Scheduler为定时任务容器，为quartz最上层的东西，它提携了所有触发器和作业，使它们协调工作，每个Scheduler都存有JobDetail和Trigger的注册，一个Scheduler中可以注册多个JobDetail和多个Trigger。

简单实现定时任务

先创建一个job类，job类包含具体的业务实现，再创建一个测试类，测试类中包含Trigger触发器和scheduler调度器

public class FirstJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail jobDetail = context.getJobDetail();
        //获取工作的名称
        String name = jobDetail.getKey().getName();//任务名
        String group = jobDetail.getKey().getGroup();//任务组
        String data = jobDetail.getJobDataMap().getString("data");//任务中的数据
        //业务
        System.out.println("job执行,job名："+name+"job组："+group+"数据："+data+new Date());
    }
}

public class QuartzTest {
    public static void main(String[] args) {
        try{
            //创建scheduler调度器
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            //定义一个Trigger，触发条件类
            TriggerBuilder triggerBuilder = TriggerBuilder.newTrigger();
            triggerBuilder.withIdentity("trigger1","group1")//定义name和group
                          .startNow()//一旦加入scheduler立即生效
                          .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                                             .withIntervalInSeconds(1)//每隔一秒执行一次
                                                             .repeatForever());//一直执行，直到结束时间
                          //可以设置结束时间，如果不设置，则一直执行
                          //.endAt(new GregorianCalendar(2020,4,25,12,0,0).getTime());
            Trigger trigger = triggerBuilder.build();
            //定义一个Jobdetail
            //定义job类为Firstjob类，业务逻辑所在
            JobDetail jobDetail = JobBuilder.newJob(FirstJob.class)
                    .withIdentity("测试任务1","test")//定义name和group
                    .usingJobData("data","jobdata")//定义属性，存储数据
                    .build();
            //调度器中加入任务和触发器
            scheduler.scheduleJob(jobDetail,trigger);
            //启动任务调度
            scheduler.start();
            //睡一会
            Thread.sleep(6000);
            //关闭任务调度器
            scheduler.shutdown();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试结果

Spring整合quartz

<!-- 1.配置Job作业 -->
<bean id="appJob01"  class="com.offcn.jobs.AppJob01"></bean>

 <!--2.配置JobDetailed -->
<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
	<property name="targetObject" ref="appJob01" />
	<property name="targetMethod" value="printHelloWord" />
</bean>

<!--3.配置trigger触发器 -->
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
	<!-- see the example of method invoking job above -->
	<property name="jobDetail" ref="jobDetail" />
	<!-- 10 seconds -->
	<property name="startDelay" value="10000" />
	<!-- repeat every 50 seconds -->
	<property name="repeatInterval" value="50000" />
</bean>

<!-- 4.配置 sheduler容器-->
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	<property name="triggers">
		<list>
			<ref bean="simpleTrigger" />
		</list>
	</property>
</bean>

加载spring的配置文件：在main方法里面加载配置文件：

 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext-quartz.xml");

执行main方法，调度器开始执行

实现自动创建订单功能

使用quartz，但是不使用spring容器管理。
1、创建一个job，需要注入service类（前提需要加上一段代码SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);）参考自添加链接描述

@Component
public class OrderJob implements Job {
    @Autowired
    private OrderService orderService;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("测试数据！");
        try {
            SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
            orderService.AutoCreateOrder();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

2、创建一个controller

@Controller
public class QuartzController {

    private Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

    //无参构造器
    public QuartzController() throws SchedulerException {
        scheduler.start();
    }
    @RequestMapping("/admin/order/auto")
    @ResponseBody
    public String startAuto() throws SchedulerException {
        addOrderJob();
        return "OK";
    }
    @RequestMapping("/admin/order/close")
    @ResponseBody
    public String closeAuto() throws SchedulerException {
        scheduler.pauseTrigger(TriggerKey.triggerKey("trigger1","group1"));
        scheduler.deleteJob(JobKey.jobKey("autoCreateOrder","order"));
        //scheduler.shutdown();
        return "OK";
    }
    public void addOrderJob() throws SchedulerException {
        //定义一个Trigger，触发条件类
        TriggerBuilder triggerBuilder = TriggerBuilder.newTrigger();
        triggerBuilder.withIdentity("trigger1","group1")//定义name和group
                .startNow()//一旦加入scheduler立即生效
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(3)//每隔一秒执行一次
                        .repeatForever());//一直执行，直到结束时间
        //可以设置结束时间，如果不设置，则一直执行
        //.endAt(new GregorianCalendar(2020,4,25,12,0,0).getTime());
        Trigger trigger = triggerBuilder.build();
        //定义一个Jobdetail
        //定义job类为Firstjob类，业务逻辑所在
        JobDetail jobDetail =JobBuilder.newJob(OrderJob.class)
                .withIdentity("autoCreateOrder","order")//定义name和group
                .build();
        //调度器中加入任务和触发器
        scheduler.scheduleJob(jobDetail,trigger);
    }
}

注意：

• 开启与关闭自动创建订单是通过添加/删除job来实现的，start与shutdown并不能实现多次的开启与关闭，只能实现一次开启/关闭，第二次就会报出异常
• scheduler的开启是通过无参构造器开启的，当这个类被初始化的时候，scheduler就已经开启了
• scheduler.pauseTrigger(TriggerKey.triggerKey(“trigger1”,“group1”));暂停触发器
• scheduler.deleteJob(JobKey.jobKey(“autoCreateOrder”,“order”));删除指定job