Java定时任务详解

定时任务在项目中经常会使用到，本文主要根据博主自己使用定时的经验分如下几点介绍定时任务：

1、quartz定时任务简介及spring配置quartz定时任务

2、schedulerfactory对定时任务进行增删改查

3、总结

quartz定时任务简介：

quartz是项目中经常用到的定时任务之一，是一个完全由java编写的开源作业调度框架，可以与j2ee与j2se应用程序相结合也可以单独使用，其主要组成部分包括job、scheduler、cronexpression，这里就不一一介绍了，下面介绍spring如何配置quartz。

配置quartz需要明白的一点是配置quartz即配置job、scheduler和cronexpression，这三部分配置完成后，就是一个完整的定时任务，配置如下：

<bean id= "testjobdetail" class="org.springframework.scheduling.quartz.jobdetailbean"> 
　　<property name="jobclass" value="xx.testquartzjob"/>
　　<!-- 可以封装各种数据到jobexecutioncontext里，包括接口、类，其中testserviceimpl是spring管理的bean，需要什么声明 --> 
　　<property name="jobdataasmap"> 
　　　　<map> 
　　　　　　<entry key="test" value="test"/>
　　　　　　<entry key ="testserviceimpl" value-ref="testserviceimpl"/>
　　　　</map> 
　　</property> 
</bean>

<bean id= "testtrigger" class="org.springframework.scheduling.quartz.crontriggerbean"> 
　　<property name="jobdetail" ref="testjobdetail" /> 
　　<property name="cronexpression" value="0 0/1 * * * ?" />
</bean>

<bean id= "testschedulerfactorybean" class="org.springframework.scheduling.quartz.schedulerfactorybean"> 
　　<property name="triggers" > 
　　　　<list> 
　　　　　　<ref bean="testtrigger" /> 
　　　　</list> 
　　</property> 
</bean>
<bean id="testserviceimpl" class="xx.service.impl.testserviceimpl">

配置完成后，就是增加一个为你执行一个任务的java类。每一个quartz job必须有一个 实现了org.quartz.job接口的具体类，代码如下：

public class testquartzjob extends quartzjobbean {
　　@override
　　protected void executeinternal(jobexecutioncontext arg0) throws jobexecutionexception
　　{
　　　　// 获取job配置的接口
　　　　testserviceimpl testserviceimpl = (testserviceimpl) arg0.getjobdetail().getjobdatamap().get("testserviceimpl");
　　　　// 执行业务方法
　　　　quartzstart();
　　}
　　public void quartzstart(){
　　　　// 业务方法...
　　}
}

当然，在job中其实不用特意的配置接口，使用spring的注入即可，这里只是把这个配置接口的方法进行说明。

到这里，简单的配置quartz定时任务已经完成，下面附加一个我在项目中使用quartz的情形：cronexpression表达式从数据库读取。

当时，我解决这个问题的方法是继承org.springframework.scheduling.quartz.crontriggerbean，设置cronexpression，具体代码如下：

trigger的配置要改：

<bean id="testtrigger" class="xx.initcrontriggerfactorybean">
　　<property name="jobdetail" ref="testjobdetail" />
　　<property name="key" value="key" />
</bean>

xx.initcrontriggerfactorybean代码：

public class initcrontriggerfactorybean extends crontriggerfactorybean implements serializable {

　　private static final long serialversionuid = 1l;

　　@resource
　　private sysparamservice sysparamservice;

　　private string key;

　　public void setkey(string key)
　　{
　　　　this.key = key;

　　　　setcronexpression(getcronexpressionfromdb());
　　}

　　private string getcronexpressionfromdb()
　　{
　　　　if(stringutils.isempty(key))
　　　　　　return "0 0/5 * * * ?";

　　　　sysparam sysparam = new sysparam();

　　　　try
　　　　{
　　　　　　sysparam = sysparamservice.getnamebykey(key);
　　　　}
　　　　catch (exception e)
　　　　{
　　　　　　e.printstacktrace();
　　　　}

　　　　if(sysparam != null && !stringutils.isempty(sysparam.getparamvalue()))
　　　　　　return sysparam.getparamvalue();

　　　　return "0 0/5 * * * ?";
　　}
}

其中，sysparamservice是根据key到数据库查询对应的cronexpression表达式的接口，这个接口除了使用spring注入，也可以使用set方法设置，如下：

<bean id="testtrigger" class="xx.initcrontriggerfactorybean">
　　<property name="jobdetail" ref="testjobdetail" />
　　<property name="key" value="key" />
　　<property name="sysparamservice" ref="sysparamservice" />
</bean>
<bean id="sysparamservice" class="xx.service.impl.sysparamserviceimpl">

这样，在xx.initcrontriggerfactorybean就要加入sysparamservice的set方法，此时的xx.initcrontriggerfactorybean代码为：

public class initcrontriggerfactorybean extends crontriggerfactorybean implements serializable {
　　private static final long serialversionuid = 1l;
　　private sysparamserviceimpl sysparamservice;
　　private string key;
　　public void setkey(string key)
　　{
　　　　this.key = key;
　　}
　　public void setsysparamservice(sysparamserviceimpl sysparamservice)
　　{
　　　　this.sysparamservice = sysparamservice;
　　　　setcronexpression(getcronexpressionfromdb());
　　}
　　private string getcronexpressionfromdb()
　　{
　　　　if(stringutils.isempty(key))
　　　　　　return "0 0 0/1 * * ?";
　　　　sysparam sysparam = new sysparam();
　　　　try
　　　　{
　　　　　　sysparam = sysparamserviceimpl.getnamebykey(key);
　　　　}
　　　　catch (exception e)
　　　　{
　　　　　　e.printstacktrace();
　　　　}
　　　　if(sysparam != null && !stringutils.isempty(sysparam.getparamvalue()))
　　　　　　return sysparam.getparamvalue();
　　　　return "0 0 0/1 * * ?";
　　}
}

quartz定时任务到这里就差不多了，基本的配置和使用就是上面将的，想要深入了解quartz可以在网上查找更多的资料，并在实践中使用。接下来将讲解在项目中使用的可以随时对定时任务进行增删改查操作的实例。

定时任务的增删改查，其实可以看做是对数据进行增删改查。不过，定时任务的增删改查是操作job和trigger，具体代码如下：

定时任务管理器代码：

public class quartzmanager {

　　private static final logger logger = logpresident.getrootlogger();

　　private static schedulerfactory schedulerfactory = new stdschedulerfactory();

　　private static map<string, jobkey> jobkeymap = new hashmap<string, jobkey>();

　　/**
　　* 增加一个定时任务
　　* @author zhiyuan.wu
　　* @date 2017年3月30日
　　* @param jobname
　　* @param triggername
　　* @param cls
　　* @param date
　　*/
　　@suppresswarnings({ "rawtypes", "unchecked" })
　　public static void addjob(string jobname, string triggername, class cls, date date)
　　{
　　　　try
　　　　{
　　　　　　scheduler scheduler = schedulerfactory.getscheduler();

　　　　　　// job
　　　　　　jobdetail jobdetail = jobbuilder.newjob(cls).withidentity(jobname, scheduler.default_group).build();

　　　　　　// 触发器
　　　　　　simpletrigger trigger = (simpletrigger) triggerbuilder.newtrigger().withidentity(triggername, scheduler.default_group).startat(date).build();

　　　　　　scheduler.schedulejob(jobdetail, trigger);

　　　　　　// 启动
　　　　　　scheduler.start();

　　　　　　jobkeymap.put(jobdetail.getkey().getname(), jobdetail.getkey());
　　　　}
　　　　catch (exception e)
　　　　{
　　　　　　logger.error("--------添加定时任务出错：" + e.getmessage(), e);
　　　　}
　　}

/**
* 删除对应的定时任务
* @author zhiyuan.wu
* @date 2017年3月29日
* @param jobkey
*/
public static void removejob(jobkey jobkey)
{
　　scheduler scheduler;
　　try
　　{
　　　　scheduler = schedulerfactory.getscheduler();
　　　　scheduler.deletejob(jobkey);

　　　　　　jobkeymap.remove(jobkey.getname());
　　　　}
　　　　catch (schedulerexception e)
　　　　{
　　　　　　logger.error("--------删除定时任务出错：" + e.getmessage(), e);
　　　　}
　　}

/**
* 启动所有定时任务
* @author zhiyuan.wu
* @date 2017年3月29日
*/
public static void startjobs()
{
　　try
　　{
　　　　scheduler sched = schedulerfactory.getscheduler();
　　　　sched.start();
　　}
　　catch (exception e)
　　{
　　　　logger.error("--------启动所有定时任务出错：" + e.getmessage(), e);
　　}
}

/**
* 停止所有定时任务
* @author zhiyuan.wu
* @date 2017年3月29日
*/
public static void shutdownjobs()
{
　　try
　　{
　　　　scheduler sched = schedulerfactory.getscheduler();

　　　　if (!sched.isshutdown())
　　　　{
　　　　　　sched.shutdown();
　　　　}
　　}
　　catch (exception e)
　　{
　　　　logger.error("--------停止所有定时任务出错：" + e.getmessage(), e);
　　}
}

/**
* 修改定时任务
* @author zhiyuan.wu
* @date 2017年3月29日
* @param jobkey
* @param jobname
* @param triggername
* @param cls
* @param date
*/
@suppresswarnings("rawtypes")
public static void modifyjobtime(jobkey jobkey, string jobname, string triggername, class cls, date date)
{
　　try
　　{
　　　　removejob(jobkey);

　　　　addjob(jobname, triggername, cls, date);
　　}
　　catch (exception e)
　　{
　　　　logger.error("--------修改定时任务出错：" + e.getmessage(), e);
　　}
}

/**
* 打印当前定时任务的jobname
* @author zhiyuan.wu
* @date 2017年3月29日
* @throws schedulerexception
*/
public static void printjobname() throws schedulerexception
{
　　for (string jobname : jobkeymap.keyset())
　　{
　　　　logger.info("--------jobname:" + jobname);
　　}
}
}

job代码：

public class testjob implements job {

　　private static final logger logger = logpresident.getrootlogger();

　　public void execute(jobexecutioncontext context) throws jobexecutionexception
　　{
　　　　jobkey jobkey = context.getjobdetail().getkey();

　　　　logger.info("--------定时任务开始执行：" + jobkey.getname());

　　　　// 业务方法...
　　　　// 移除定时任务
　　　　quartzmanager.removejob(jobkey);
　　}
}

增加一个定时任务代码：

quartzmanager.addjob(jobname, triggername , testjob.class, date);

这样，在到达时间date时，定时任务将会执行。不过这样增加的任务是保存在内存中，项目重启将会丢失定时任务，所以，最好增加一个类，在项目启动时将会扫描数据库，将未执行的定时任务重新加载到内存中去。

定时任务在项目中运用需要根据业务具体调整，但只要弄清楚定时任务的原理和实现，那么就可以在项目中灵活运它用来具体的业务，希望这篇文章可以让大家快速了解和运用定时任务，并运用到实践中。

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持!