public class HelloJob implements Job {

    @Override

    public void execute(JobExecutionContext context) throws JobExecutionException {

        Object tv1 = context.getTrigger().getJobDataMap().get("t1");

        Object tv2 = context.getTrigger().getJobDataMap().get("t2");

        Object jv1 = context.getJobDetail().getJobDataMap().get("j1");

        Object jv2 = context.getJobDetail().getJobDataMap().get("j2");

        Object sv = null;

        try {

            sv = context.getScheduler().getContext().get("skey");

        } catch (SchedulerException e) {

            e.printStackTrace();

        }

        System.out.println(tv1+":"+tv2);

        System.out.println(jv1+":"+jv2);

        System.out.println(sv);

        System.out.println("hello:"+LocalDateTime.now());

    }

}

public class Test {

    public static void main(String[] args) throws SchedulerException {

        //创建一个scheduler

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        scheduler.getContext().put("skey", "svalue");

        //创建一个Trigger

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "group1")

                .usingJobData("t1", "tv1")

                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3)

                        .repeatForever()).build();

        trigger.getJobDataMap().put("t2", "tv2");

        //创建一个job

        JobDetail job = JobBuilder.newJob(HelloJob.class)

                    .usingJobData("j1", "jv1")

                    .withIdentity("myjob", "mygroup").build();

        job.getJobDataMap().put("j2", "jv2");

        //注册trigger并启动scheduler

        scheduler.scheduleJob(job,trigger);

        scheduler.start();

    }

}

####################RAMJob的配置##################

#在集群中每个实例都必须有一个唯一的instanceId，但是应该有一个相同的instanceName【默认“QuartzScheduler”】【非必须】

org.quartz.scheduler.instanceName = MyScheduler

#Scheduler实例ID，全局唯一，【默认值NON_CLUSTERED】，或者可以使用“SYS_PROP”通过系统属性设置id。【非必须】

org.quartz.scheduler.instanceId=AUTO

# 线程池的实现类（定长线程池，几乎可满足所有用户的需求）【默认null】【必须】

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# 指定线程数，至少为1（无默认值）(一般设置为1-100直接的整数合适)【默认-1】【必须】

org.quartz.threadPool.threadCount = 25

# 设置线程的优先级（最大为java.lang.Thread.MAX_PRIORITY 10，最小为Thread.MIN_PRIORITY 1）【默认Thread.NORM_PRIORITY (5)】【非必须】

org.quartz.threadPool.threadPriority = 5

#misfire设置的时间默认为一分钟

org.quartz.jobStore.misfireThreshold=60000

# 将schedule相关信息保存在RAM中，轻量级，速度快，遗憾的是应用重启时相关信息都将丢失。

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

# 建议设置为“org.terracotta.quartz.skipUpdateCheck=true”不会在程序运行中还去检查quartz是否有版本更新。【默认false】【非必须】

org.quartz.scheduler.skipUpdateCheck = true

###################jdbcJobStore############################

org.quartz.scheduler.instanceName=MyScheduler

org.quartz.scheduler.instanceId=AUTO

org.quartz.threadPool.threadCount=3

# 所有的quartz数据例如job和Trigger的细节信息被保存在内存或数据库中,有两种实现：JobStoreTX(自己管理事务)

#和JobStoreCMT（application server管理事务，即全局事务JTA）

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

# 类似于Hibernate的dialect，用于处理DB之间的差异，StdJDBCDelegate能满足大部分的DB

org.quartz.jobStore.driverDelegateClass =org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#数据库表的前缀

org.quartz.jobStore.tablePrefix=QRTZ_

#配置数据源的名称

org.quartz.jobStore.dataSource=myDS

#为了指示JDBCJobStore所有的JobDataMaps中的值都是字符串，并且能以“名字-值”对的方式存储而不是以复杂对象的序列化形式存储在BLOB字段中，应该设置为true(缺省方式)

org.quartz.jobStore.useProperties = true

# 检入到数据库中的频率(毫秒)。检查是否其他的实例到了应当检入的时候未检入这能指出一个失败的实例，

#且当前Scheduler会以此来接管执行失败并可恢复的Job通过检入操作，Scheduler也会更新自身的状态记录

org.quartz.jobStore.clusterCheckinInterval=20000

# 是否集群、负载均衡、容错，如果应用在集群中设置为false会出错

org.quartz.jobStore.isClustered=false

#misfire时间设置

org.quartz.jobStore.misfireThreshold=60000

# 连接超时重试连接的间隔。使用 RamJobStore时，该参数并没什么用【默认15000】【非必须】

#org.quartz.scheduler.dbFailureRetryInterval = 15000

#下面是数据库链接相关的配置

org.quartz.dataSource.myDS.driver=com.mysql.jdbc.Driver

org.quartz.dataSource.myDS.URL=jdbc:mysql://localhost:3306/zproject?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=UTC

org.quartz.dataSource.myDS.user=root

org.quartz.dataSource.myDS.password=root

org.quartz.dataSource.myDS.maxConnections=5

@DisallowConcurrentExecution

public class MyJob implements Job {

    @Override

    public void execute(JobExecutionContext arg0) throws JobExecutionException {

        String name = arg0.getJobDetail().getKey().getName();

        System.out.println(name+"这是第一个定时任务"+LocalDateTime.now());

    }

}

public class Test {

    public static void main(String[] args) throws SchedulerException, InterruptedException {

        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("MyJob","Group1").build();

        JobDetail jobDetail2 = JobBuilder.newJob(MyJob.class).withIdentity("MyJob2","Group2").build();

        JobDetail jobDetail3 = JobBuilder.newJob(MyJob.class).withIdentity("MyJob3","Group3").build();

        JobDetail jobDetail4 = JobBuilder.newJob(MyJob.class).withIdentity("MyJob4","Group4").build();

        Calendar cal1 = Calendar.getInstance();

        cal1.set(Calendar.MINUTE, 28);

        cal1.set(Calendar.SECOND, 0);

        Calendar cal2 = Calendar.getInstance();

        cal2.set(Calendar.MINUTE, 29);

        cal2.set(Calendar.SECOND, 0);

        DailyCalendar dailyCalendar = new DailyCalendar(cal1, cal2);

        scheduler.addCalendar("dailyCalendar", dailyCalendar, false, false);

        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("tigger1","TGroup1")

        .withSchedule(CronScheduleBuilder.cronSchedule("/2 * * * * ?")).build();

        SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger().withIdentity("trigger2","TGroup2")

                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(5, 10)).build();

        CalendarIntervalTrigger citrigger = TriggerBuilder.newTrigger().withIdentity("trigger3","TGroup3")

                .withSchedule(CalendarIntervalScheduleBuilder.calendarIntervalSchedule()

                        .withIntervalInSeconds(10)).modifiedByCalendar("dailyCalendar").build();

        DailyTimeIntervalTrigger dtiTrigger = TriggerBuilder.newTrigger().withIdentity("trigger4","TGroup4")

                .withSchedule(DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule()

                        .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 43))

                        .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 44))

                        .withIntervalInSeconds(5)

                        .withRepeatCount(20))

                .build();

        scheduler.scheduleJob(jobDetail, cronTrigger);

        scheduler.scheduleJob(jobDetail2, simpleTrigger);

        scheduler.scheduleJob(jobDetail3, citrigger);

        scheduler.scheduleJob(jobDetail4, dtiTrigger);

        scheduler.start();

    }

}