java quartz 代码_java quarter_1

java quartz 代码_java quarter

       大家好，今天我想和大家讲解一下“java quartz 代码”的工作原理。为了让大家更好地理解这个问题，我将相关资料进行了分类，现在就让我们一起来学习吧。

1.Spring+quartz 做定时任务时，每5分种执行一次，怎么写法

2.java写一个定时器，定时对一个变量赋不同值，这个程序代码怎么写

3.java quartz job 执行时间配置

4.java在servlet里设置个定时器，让其在tomcat一运行时，自动每隔几个小时执行一个任务？

5.java定时执行问题： 我想让一个Java代码在每小时的第25分钟执行一次的，这个怎么实现？

6.用java的Quartz包定时调用方法，我想实现每隔半小时调用一次方法，那个配置文件中时间的配置符号咋写的了

Spring+quartz 做定时任务时，每5分种执行一次，怎么写法

       写法如下：

       <beanid="StaticPageQuartz"class="com.test.quartz.pageconvertor.StaticPageConvertor"

       />

       <beanid="BuildStaticPageTask"

       class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"

       <propertyname="targetObject"ref="StaticPageQuartz"/>

       <propertyname="targetMethod"value="doHTMLConvertor"/>

       <propertyname="concurrent"value="false"/>

       </bean>

       <beanid="BuildStaticPageTrigger"

       class="org.springframework.scheduling.quartz.CronTriggerBean">

       <propertyname="jobDetail"ref="BuildStaticPageTask"/>

       <propertyname="cronExpression"value="00/5***?"/><!--每五分钟执行一次--

       </bean>

扩展资料：

       Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

       Spring是于2003年兴起的一个轻量级的Java开发框架，由RodJohnson创建。简单来说，Spring是一个分层的JavaSE/EE?full-stack(一站式)?轻量级开源框架。

       

       Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。

       Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或EJBs。Quartz的最新版本为Quartz2.3.0。

参考资料：

百度百科：spring

参考资料：

百度百科：quartz

java写一个定时器，定时对一个变量赋不同值，这个程序代码怎么写

       1.需要的jar包

        实现定时任务 需要quartz-1.5.1.jar和commons-logging-1.1.jar。

       2.定义定时任务配置类

        该类主要进行定时任务时间的设置和设置对应的定时任务类。

       import org.quartz.CronTrigger;

       import org.quartz.JobDetail;

       import org.quartz.Scheduler;

       import org.quartz.impl.StdSchedulerFactory;

       public class Test{

        /**

        * 定时任务

        */

        public static void cleanUpJob() {

        try {

        JobDetail jobDetail = new JobDetail();

        jobDetail.setName("cleanup");

        jobDetail.setJobClass(PrintJob.class);

        CronTrigger trigger = new CronTrigger();

        trigger.setName("cleanupTrigger");

        trigger.setJobName("cleanup");

        trigger.setCronExpression("0/5 * * * * ?");

        Scheduler sch = StdSchedulerFactory.getDefaultScheduler();

        sch.scheduleJob(jobDetail, trigger);

        sch.start();

        } catch (Exception e) {

        e.printStackTrace();

        }

        }

        /**

        * 修改定时任务时间

        */

        public static void modifyJobTime(String triggerName, String time) {

        System.out.println("modify~~~~~~~~~~~~~~~~");

        try {

        Scheduler sched = StdSchedulerFactory.getDefaultScheduler();

        System.out.println("triggerName " + triggerName);

        CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);

        if(trigger == null) {

        return;

        }

        String oldTime = trigger.getCronExpression();

        System.out.println("oldTime " + oldTime);

        if (!oldTime.equalsIgnoreCase(time)) {

        System.out.println("time " + time);

        // 修改时间

        trigger.setCronExpression(time);

        }

        } catch (Exception e) {

        e.printStackTrace();

        throw new RuntimeException(e);

        }

        }

        public static void main(String[] args) {

        cleanUpJob();

        modifyJobTime("cleanupTrigger", "0/2 * * * * ?");

        }

       }

       3.定时任务类

        该类主要定义定时任务执行的内容。

       import java.text.SimpleDateFormat;

       import java.util.Date;

       import org.quartz.Job;

       import org.quartz.JobExecutionContext;

       import org.quartz.JobExecutionException;

       public class PrintJob implements Job{

        @Override

        public void execute(JobExecutionContext arg0) throws JobExecutionException {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

        String time = sdf.format(new Date());

        System.out.println("print job" + time);

        }

       }

       4.输出结果

       modify~~~~~~~~~~~~~~~~

       triggerName cleanupTrigger

       oldTime 0/5 * * * * ?

       time 0/2 * * * * ?

       print job2014-12-03 17:06:40.031

       print job2014-12-03 17:06:42.015

       print job2014-12-03 17:06:44.016

       print job2014-12-03 17:06:46.019

       print job2014-12-03 17:06:48.019

       print job2014-12-03 17:06:50.020

       从输出的结果中可以看到，原本的定时任务为每5秒执行一次，但是由于后面对定时任务表达式做了修改，所以后来安照修改后的每2秒执行一次。

java quartz job 执行时间配置

       import?java.util.Random;

       import?java.util.Timer;

       import?java.util.TimerTask;

       public?class?MainEntry?{

private?int?a;

public?void?setVal(){

Timer?timer?=?new?Timer();

//每隔一秒生成一个[1,100)内的随机整数，赋给成员a

timer.schedule(new?TimerTask()?{?

       @Override

       public?void?run()?{

       Random?rand?=?new?Random();

       setA(rand.nextInt(100));

       }

},?1000);

}

public?void?setA(int?a)?{

this.a?=?a;

}

public?int?getA()?{

return?a;

}

public?static?void?main(String[]?args)?{

MainEntry?me?=?new?MainEntry();

me.setVal();

}

       }

java在servlet里设置个定时器，让其在tomcat一运行时，自动每隔几个小时执行一个任务？

       第一步：引包

       要使用Quartz，必须要引入以下这几个包：

       1、log4j-1.2.16

       2、quartz-2.1.7

       3、slf4j-api-1.6.1.jar

       4、slf4j-log4j12-1.6.1.jar

       这些包都在下载的Quartz包里面包含着，因此没有必要为寻找这几个包而头疼。

       第二步：创建要被定执行的任务类

       这一步也很简单，只需要创建一个实现了org.quartz.Job接口的类，并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：

       import java.text.SimpleDateFormat;

       import java.util.Date;

       import org.quartz.Job;

       import org.quartz.JobExecutionContext;

       import org.quartz.JobExecutionException;

       public class myJob implements Job {

        @Override

        public void execute(JobExecutionContext arg0) throws JobExecutionException {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

        System.out.println(sdf.format(new Date()));

        }

       }

       import java.text.SimpleDateFormat;

       import java.util.Date;

       import org.quartz.Job;

       import org.quartz.JobExecutionContext;

       import org.quartz.JobExecutionException;

       public class myJob implements Job {

        @Override

        public void execute(JobExecutionContext arg0) throws JobExecutionException {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

        System.out.println(sdf.format(new Date()));

        }

       }

       这个例子很简单，就不用解说了。

       第三步：创建任务调度，并执行

       这一步应该算是最难的一步的，但其实是非常简单的，直接上代码

       import static org.quartz.CronScheduleBuilder.cronSchedule;

       import static org.quartz.JobBuilder.newJob;

       import static org.quartz.TriggerBuilder.newTrigger;

       import java.text.SimpleDateFormat;

       import java.util.Date;

       import org.quartz.CronTrigger;

       import org.quartz.JobDetail;

       import org.quartz.Scheduler;

       import org.quartz.SchedulerFactory;

       import org.quartz.impl.StdSchedulerFactory;

       public class Test {

        public void go() throws Exception {

        // 首先，必需要取得一个Scheduler的引用

        SchedulerFactory sf = new StdSchedulerFactory();

        Scheduler sched = sf.getScheduler();

        //jobs可以在scheduled的sched.start()方法前被调用

        //job 1将每隔20秒执行一次

        JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();

        CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

        Date ft = sched.scheduleJob(job, trigger);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

        System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: " + trigger.getCronExpression());

        // job 2将每2分钟执行一次（在该分钟的第15秒)

        job = newJob(myJob.class).withIdentity("job2", "group1").build();

        trigger = newTrigger().withIdentity("trigger2", "group1").withSchedule(cronSchedule("15 0/2 * * * ?")).build();

        ft = sched.scheduleJob(job, trigger);

        System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: "+ trigger.getCronExpression());

        // 开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job

        sched.start();

        try {

        //主线程等待一分钟

        Thread.sleep(60L * 1000L);

        } catch (Exception e) {}

        //关闭定时调度，定时器不再工作

        sched.shutdown(true);

       }

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

        Test test = new Test();

        test.go();

        }

       }

       import static org.quartz.CronScheduleBuilder.cronSchedule;

       import static org.quartz.JobBuilder.newJob;

       import static org.quartz.TriggerBuilder.newTrigger;

       import java.text.SimpleDateFormat;

       import java.util.Date;

       import org.quartz.CronTrigger;

       import org.quartz.JobDetail;

       import org.quartz.Scheduler;

       import org.quartz.SchedulerFactory;

       import org.quartz.impl.StdSchedulerFactory;

       public class Test {

        public void go() throws Exception {

        // 首先，必需要取得一个Scheduler的引用

        SchedulerFactory sf = new StdSchedulerFactory();

        Scheduler sched = sf.getScheduler();

        //jobs可以在scheduled的sched.start()方法前被调用

        //job 1将每隔20秒执行一次

        JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();

        CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

        Date ft = sched.scheduleJob(job, trigger);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

        System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: " + trigger.getCronExpression());

        // job 2将每2分钟执行一次（在该分钟的第15秒)

        job = newJob(myJob.class).withIdentity("job2", "group1").build();

        trigger = newTrigger().withIdentity("trigger2", "group1").withSchedule(cronSchedule("15 0/2 * * * ?")).build();

        ft = sched.scheduleJob(job, trigger);

        System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: "+ trigger.getCronExpression());

        // 开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job

        sched.start();

        try {

        //主线程等待一分钟

        Thread.sleep(60L * 1000L);

        } catch (Exception e) {}

        //关闭定时调度，定时器不再工作

        sched.shutdown(true);

       }

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

        Test test = new Test();

        test.go();

        }

       }

       OK了，Job1和Job2就会被安排为定时执行了。此时程序是可以执行的了，但是可能会输出WARN级别日志，这是因为没有加log4j的配置文件，加上配置文件，就OK了。这里需要说明的地方只有一个，其它的可以直接Copy到您的项目里面。看代码：

       CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

       CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

java定时执行问题： 我想让一个Java代码在每小时的第25分钟执行一次的，这个怎么实现？

       看你要求 如果复杂的定时 可以使用 定时框架 quartz，如果简单的定时可以使用

package?test;

       import?java.util.Timer;

       public?class?TimeTaskTest?{

       public?static?void?main(String[]?args){

Timer?timer?=?new?Timer();?

timer.schedule(new?Task(),?60?*?1000);

       }

       }

       package?test;

       import?java.util.TimerTask;

       public?class?Task?extends?TimerTask?{

       public?void?run()

{

       System.out.println("定时任务执行");

}

       }

用java的Quartz包定时调用方法，我想实现每隔半小时调用一次方法，那个配置文件中时间的配置符号咋写的了

       用spring quartz

       public class MyJob{

        //这里如果你定义实例变量，可用spring依赖注入,例如

        private String job;

        public void setJob(String job){

        this.job = job;

        }

        //你要执行的操作

        public void execute(){

        }

       }

       spring 配置文件

       beans-config.xml

       <?xml version="1.0" encoding="UTF-8"?>

       <beans xmlns="http://www.springframework.org/schema/beans"

        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

        xsi:schemaLocation="http://www.springframework.org/schema/beans

       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

        <bean id = "myJob" class="MyJob">

        <!--如果有注入属性在这里写 <property name = "job" value="hihi"></property> -->

        </bean>

        <bean id = "myjobDetail" class = "org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

        <property name="targetObject" ref="myJob">

        </property>

        <property name="targetMethod" value="execute"></property>

        </bean>

        <bean id ="triggerBean" class="org.springframework.scheduling.quartz.CronTriggerBean">

        <property name="jobDetail" ref="myjobDetail"/>

        <!-- 秒 分 小时 天 月 年-->

        <property name="cronExpression" value="0 25 * * * ?"/>

        </bean>

        <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

        <property name="triggers">

        <list><ref bean = "triggerBean"/></list>

        </property>

        </bean>

       </beans>

       在主类中读取定义文件，任务计划自动运行。

       public class Test(){

        public void static main(String[] args){

        ApplicationContext context = new ClassPathXmlApplicationContext("beans-config.xml");

       }

       }

       将配置文件放在该项目的classpath下，一般你放在src目录下即可。也可以自己创建路径放置，在项目的.classpath中可配置下此路径。

       最后导入spring的jar包就可以了。

       <!-- 常用的corn表达式

       *隔5秒执行一次：*/5 * * * * ?

       *隔1分钟执行一次：0 */1 * * * ?

       *23点执行一次：0 0 23 * * ?

       *晨1点执行一次：0 0 1 * * ?

       *月1号凌晨1点执行一次：0 0 1 1 * ?

       *月最后一天23点执行一次：0 0 23 L * ?

       *周星期天凌晨1点实行一次：0 0 1 ? * L

       *在26分、29分、33分执行一次：0 26,29,33 * * * ?

       *的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

       -->

       这是spring调用时，的符号公式

       好了，关于“java quartz 代码”的话题就讲到这里了。希望大家能够对“java quartz 代码”有更深入的了解，并且从我的回答中得到一些启示。