Java - Quarz 定时任务_使用注意点

Java - Quarz 定时任务_使用注意点

前言

在开发过程中，我们会用定时任务来执行一些操作，例如定时去捞取流水重试业务、定时去消息中间件获取消息等等相关需求

简单的定时任务实现可以借助Spring提供的 @Scheduled 注解 详细看 Spring 原理之 Scheduled

如果涉及到 定时任务的动态管理就需要使用到其他技术，下面介绍一下Quartz

Quartz是一个开源的任务日程管理系统， 由 OpenSymphony开源，同时它是一个功能丰富的任务调用系统，可创建简单或者复杂的几十、几百、甚至成千上万的job。除此之外，quartz调度器还支持JTA事务和集群。

Maven 的pom.xml文件引入相关依赖包

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

Quarz使用注意点

本篇博客接着上篇 Java - Quarz 定时任务，上篇主要介绍一下Quartz 的基本使用，内容也挺多了

这篇主要说一下 Quartz 使用的一些注意点

1、Job 的使用

1.1 自定义 Job 需要无参构造方法（必须）

在上篇说到，在 Scheduler 的 scheduleJob （配置定时任务） 方法中，设置了相关的 JobDetail 实例

而在创建JobDetail时，将 要执行的job的类名 传给了JobDetail，所以scheduler就知道了要执行何种类型的job，例如：

// quartzJob 是与数据库相关的DO，用其id来构造JobKey保证唯一性
private JobDetail createJobDetail(QuartzJob quartzJob){
      String JOB_NAME = "TASK_"; // JobKey的名称前缀
      return JobBuilder.newJob(ExecuteJob.class). // 指定Job 的JobBuilder 
                withIdentity(JOB_NAME + quartzJob.getId()).build(); // 创建
}

这里的ExecuteJob类为自定义的Job，实现Job接口，如下：

public class ExecuteJob implements Job {

    // context 里面包含了很多方法，常用的如下
    // getScheduler：获取Scheduler
    // getTrigger：获取触发器Trigger
    //getJobDetail：获取JobDetail
    //getJobInstance：获取到Job
    // getMergedJobDataMap：获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集，但是如果存在相同的数据，则后者会覆盖前者的值
    public void execute(JobExecutionContext context)
            throws JobExecutionException {

        // 获取 JobDetail 的 JobKey
        JobKey key = context.getJobDetail().getKey();
        // 获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集
        JobDataMap dataMap = context.getMergedJobDataMap();
        // 获取创建 JobDetail 设置的值
        String AString = dataMap.getString("AString");
        Float BFloatValue = dataMap.getFloat("BFloatValue");
        System.out.println("Instance " + key + " of AString : " + AString + ", and BFloatValue is: " + BFloatValue);
    }
}

那么每次当 scheduler 执行job时，就会调用 execute(…) 方法执行相应的业务逻辑

注意：在调用其 execute(…) 方法之前会创建该类的一个新的实例，处理逻辑如下：

// org.quartz.simpl.SimpleJobFactory#newJob

public Job newJob(TriggerFiredBundle bundle, Scheduler Scheduler) throws SchedulerException {
    JobDetail jobDetail = bundle.getJobDetail();
    // 获取这个 Job 的class
    Class<? extends Job> jobClass = jobDetail.getJobClass();
    try {
        if(log.isDebugEnabled()) {
            log.debug( "Producing instance of Job '" + jobDetail.getKey() +  "', class=" + jobClass.getName());
        }
        // 创建实例
        return jobClass.newInstance();
    } catch (Exception e) {
        SchedulerException se = new SchedulerException("Problem instantiating class '" + jobDetail.getJobClass().getName() + "'", e);
        throw se;
    }
}

可以看到，其是通过 jobClass.newInstance(); 来实例化对象的，那么 必须要有无参构造方法 ，如果 ExecuteJob 没有 有参构造方法 时，其会默认有一个无参构造方法，所以上面的代码不会出现问题

如果ExecuteJob 变为这样：

public class ExecuteJob implements Job {

    private String a;
	// 有参构造方法，那么这个ExecuteJob 就不会有无参构造方法
    ExecuteJob(String s) {
        this.a = s;
    }
	public void execute(JobExecutionContext context)
            throws JobExecutionException {
		.....与上面相同....
    }
}

再次运行的时候，就会报以下错误：（大家可以试试）

org.quartz.SchedulerException: Problem instantiating class ‘com.study.DO.ExecuteJob’

1.2 自定义 Job 定义的有状态的数据属性值不会保留（注意点）

在job的多次执行中，这些属性的值不会保留

这个根据1.1 的解释 很通俗易懂了把，因为执行每次都是通过 newInstance 方法创建一个新的实例，所以你之前的Job 的属性值肯定不可能保留

如果多次执行Job 想跟踪Job的状态，可以借助 JobDataMap，JobDetail对象的一部分，设置一个Map来存储

1.3 JobDataMap 设置 Job 的数据属性值（便捷使用点）

在 ExecuteJob 中，我们通过 JobDataMap 设置了我们想追踪的Key值，然后在execute 方法中来获取到进行相应的处理，例如：

public class ExecuteJob implements Job {

    // context 里面包含了很多方法，常用的如下
    // getScheduler：获取Scheduler
    // getTrigger：获取触发器Trigger
    //getJobDetail：获取JobDetail
    //getJobInstance：获取到Job
    // getMergedJobDataMap：获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集，但是如果存在相同的数据，则后者会覆盖前者的值
    public void execute(JobExecutionContext context)
            throws JobExecutionException {

        // 获取 JobDetail 的 JobKey
        JobKey key = context.getJobDetail().getKey();
        // 获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集
        JobDataMap dataMap = context.getMergedJobDataMap();
        // 获取创建 JobDetail 设置的值
        String AString = dataMap.getString("AString");
        Float BFloatValue = dataMap.getFloat("BFloatValue");
        System.out.println("Instance " + key + " of AString : " + AString + ", and BFloatValue is: " + BFloatValue);
    }
}
// 创建时候传入
private JobDetail createJobDetail(QuartzJob quartzJob) {
        String JOB_NAME = "TASK_";
        return JobBuilder.newJob(ExecuteJob.class).
                withIdentity(JOB_NAME + quartzJob.getId())
                .usingJobData("AString", "i am a string ")
                .usingJobData("BFloatValue", 0F)
                .build();
    }

除了上面那种方式，我们还可以简化 execute 中的代码，通过 set 方法来获取

public class ExecuteJob implements Job {

    private String aString;

    private Float bFloatValue;

    // context 里面包含了很多方法，常用的如下
    // getScheduler：获取Scheduler
    // getTrigger：获取触发器Trigger
    //getJobDetail：获取JobDetail
    //getJobInstance：获取到Job
    // getMergedJobDataMap：获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集，但是如果存在相同的数据，则后者会覆盖前者的值
    public void execute(JobExecutionContext context)
            throws JobExecutionException {

        // 获取 JobDetail 的 JobKey
        JobKey key = context.getJobDetail().getKey();
        // 获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集
        JobDataMap dataMap = context.getMergedJobDataMap();
        // 获取创建 JobDetail 设置的值
//        String aString = dataMap.getString("AString");
//        Float bFloatValue = dataMap.getFloat("BFloatValue");
        System.out.println("Instance " + key + " of AString : " + aString + ", and BFloatValue is: " + bFloatValue);
    }

    public void setAString(String aString) {
        this.aString = aString;
    }

    public void setBFloatValue(Float bFloatValue) {
        this.bFloatValue = bFloatValue;
    }
}

这样的好处是，如果 execute 中有大量获取 JobDataMap 中的代码，我们都可以省略。（有人可能说了，这里的代码不还是多了嘛~）

这里多的代码无非是 set 相关的代码，我们完全可以借助 lombok，关于 lombok可以查看另外一篇博客：lombok 的使用，这样的话，不就大大减少了代码量嘛~

package com.study.DO;

import lombok.Data;
import lombok.Setter;
import org.quartz.*;

//@Data
@Setter
public class ExecuteJob implements Job {
    private String aString;
    private Float bFloatValue;
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        // 获取 JobDetail 的 JobKey
        JobKey key = context.getJobDetail().getKey();
        // 获取 JobDetail中的JobDataMap和Trigger中的JobDataMap的并集
        JobDataMap dataMap = context.getMergedJobDataMap();
        // 获取创建 JobDetail 设置的值
//        String aString = dataMap.getString("AString");
//        Float bFloatValue = dataMap.getFloat("BFloatValue");

        System.out.println("Instance " + key + " of AString : " + aString + ", and BFloatValue is: " + bFloatValue);
    }

}

其原理是：（Quartz的默认JobFactory实现在job被实例化的时候会自动调用这些set方法，这样你就不需要在execute()方法中显式地从map中取数据了），源码如下：

// org.quartz.simpl.PropertySettingJobFactory

public class PropertySettingJobFactory extends SimpleJobFactory {
    private boolean warnIfNotFound = false;
    private boolean throwIfNotFound = false;
    
    @Override
    public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {
		// 创建Job newInstance()
        Job job = super.newJob(bundle, scheduler);
        
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.putAll(scheduler.getContext());
        jobDataMap.putAll(bundle.getJobDetail().getJobDataMap());
        jobDataMap.putAll(bundle.getTrigger().getJobDataMap());
		// 设置属性值，通过set方法
        setBeanProps(job, jobDataMap);
        
        return job;
    }
    // 设置属性值，通过set方法  
    // 很常见的实现逻辑
    // 根据class 获取到所有的参数，然后根据参数查找是否有set方法，如果有，就根据set方法设置值  
    protected void setBeanProps(Object obj, JobDataMap data) throws SchedulerException {
        BeanInfo bi = null;
        try {
            bi = Introspector.getBeanInfo(obj.getClass());
        } catch (IntrospectionException e) {
            handleError("Unable to introspect Job class.", e);
        }
        
        PropertyDescriptor[] propDescs = bi.getPropertyDescriptors();
        
        for (Iterator<?> entryIter = data.getWrappedMap().entrySet().iterator(); entryIter.hasNext();) {
            Map.Entry<?,?> entry = (Map.Entry<?,?>)entryIter.next();
            
            String name = (String)entry.getKey();
            String c = name.substring(0, 1).toUpperCase(Locale.US);
            String methName = "set" + c + name.substring(1);
       
            java.lang.reflect.Method setMeth = getSetMethod(methName, propDescs);
        
            Class<?> paramType = null;
            Object o = null;
            
            try {
                if (setMeth == null) {
                    handleError( "No setter on Job class " + obj.getClass().getName() +  " for property '" + name + "'");
                    continue;
                }
                
                paramType = setMeth.getParameterTypes()[0];
                o = entry.getValue();
                
                Object parm = null;
                if (paramType.isPrimitive()) {
                    if (o == null) {
                        handleError(  "Cannot set primitive property '" + name +    "' on Job class " + obj.getClass().getName() +  " to null.");
                        continue;
                    }

                    if (paramType.equals(int.class)) {
                        if (o instanceof String) {                            
                            parm = Integer.valueOf((String)o);
                        } else if (o instanceof Integer) {
                            parm = o;
                        }
                    } else if (paramType.equals(long.class)) {
                        if (o instanceof String) {
                            parm = Long.valueOf((String)o);
                        } else if (o instanceof Long) {
                            parm = o;
                        }
                    } else if (paramType.equals(float.class)) {
                        if (o instanceof String) {
                            parm = Float.valueOf((String)o);
                        } else if (o instanceof Float) {
                            parm = o;
                        }
                    } else if (paramType.equals(double.class)) {
                        if (o instanceof String) {
                            parm = Double.valueOf((String)o);
                        } else if (o instanceof Double) {
                            parm = o;
                        }
                    } else if (paramType.equals(boolean.class)) {
                        if (o instanceof String) {
                            parm = Boolean.valueOf((String)o);
                        } else if (o instanceof Boolean) {
                            parm = o;
                        }
                    } else if (paramType.equals(byte.class)) {
                        if (o instanceof String) {
                            parm = Byte.valueOf((String)o);
                        } else if (o instanceof Byte) {
                            parm = o;
                        }
                    } else if (paramType.equals(short.class)) {
                        if (o instanceof String) {
                            parm = Short.valueOf((String)o);
                        } else if (o instanceof Short) {
                            parm = o;
                        }
                    } else if (paramType.equals(char.class)) {
                        if (o instanceof String) {
                            String str = (String)o;
                            if (str.length() == 1) {
                                parm = Character.valueOf(str.charAt(0));
                            }
                        } else if (o instanceof Character) {
                            parm = o;
                        }
                    }
                } else if ((o != null) && (paramType.isAssignableFrom(o.getClass()))) {
                    parm = o;
                }
                
                // If the parameter wasn't originally null, but we didn't find a 
                // matching parameter, then we are stuck.
                if ((o != null) && (parm == null)) {
                    handleError(
                        "The setter on Job class " + obj.getClass().getName() + 
                        " for property '" + name + 
                        "' expects a " + paramType + 
                        " but was given " + o.getClass().getName());
                    continue;
                }
                                
                setMeth.invoke(obj, new Object[]{ parm });
            } catch (NumberFormatException nfe) {
                handleError(
                    "The setter on Job class " + obj.getClass().getName() + 
                    " for property '" + name + 
                    "' expects a " + paramType + 
                    " but was given " + o.getClass().getName(), nfe);
            } catch (IllegalArgumentException e) {
                handleError(
                    "The setter on Job class " + obj.getClass().getName() + 
                    " for property '" + name + 
                    "' expects a " + paramType + 
                    " but was given " + o.getClass().getName(), e);
            } catch (IllegalAccessException e) {
                handleError(
                    "The setter on Job class " + obj.getClass().getName() + 
                    " for property '" + name + 
                    "' could not be accessed.", e);
            } catch (InvocationTargetException e) {
                handleError(
                    "The setter on Job class " + obj.getClass().getName() + 
                    " for property '" + name + 
                    "' could not be invoked.", e);
            }
        }
    }
}

1.4 Job状态与并发（建议两个注解同时使用）

关于job的状态数据（即JobDataMap）和并发性，有一些地方需要注意，我们可以在job类上可以加入一些注解，这些注解会影响job的状态和并发性

Job 与 JobDetail 是 1对多 的关系，即我们创建了一个 Job，可以基于这个 Job 创建出多个 JobDetail，每一个 JobDetail 都有自己的属性集和JobDataMap，最后，将所有的实例都加到scheduler中进行执行。一个 Job 的多个 JobDetail 实例 涉及到了 并发 的问题

• @DisallowConcurrentExecution：将该注解加到 job类 上，告诉 Quartz 不要并发地执行同一个 Job 的多个 JobDetail 实例。所以该限制是针对JobDetail的，而不是job类的。但是应该将该注解放在job类上，因为 job类 的改变经常会导致其行为发生变化。
• @PersistJobDataAfterExecution：将该注解加在job类上，告诉 Quartz 在成功执行了 job类 的 execute方法 后（没有发生任何异常），更新JobDetail中JobDataMap的数据，使得该job（即JobDetail）在下一次执行的时候，JobDataMap中是更新后的数据，而不是更新前的旧数据。尽管注解是加在job类上的，但其限制作用是针对job实例的，而不是 job类 的

在 JobDetail 中，有以下两个方法来判断是否你加了注解：

/**
 * @see PersistJobDataAfterExecution
 * @return whether the associated Job class carries the {@link PersistJobDataAfterExecution} annotation.
 */
public boolean isPersistJobDataAfterExecution();

/**
 * @see DisallowConcurrentExecution
 * @return whether the associated Job class carries the {@link DisallowConcurrentExecution} annotation.
 */
public boolean isConcurrentExectionDisallowed();

建议 若使用了@PersistJobDataAfterExecution注解，要同时使用@DisallowConcurrentExecution注解。因为当同一个job（JobDetail）的两个实例被并发执行时，由于竞争，JobDataMap中存储的数据很可能是不确定的（JobDataMap底层是HashMap，HashMap是线程不安全的）

总结

这里说明了几点关于Quartz 使用的注意点，在使用的过程中需要注意，关于 Quartz 的 整个原理与过程会再额外整理一下~