quartzjava定时

1. java定时器Java定时器怎么实现一个任务多个时间点，给别人用时间可以改动的

1. java中quartz框架设置定时任务时，是可以设置各种时间启动的

   每天什么时候执行:

   <value>0 59 23 * * ?</value>: 如下为每天23:59:00开始执行

   <value>0 1,2,3 11,12 * * ? </value>: 每天11:01,11:02,11:03; 12:01,12:02,12:03分执行任务

2. 至于你说的别人虚搜肢可以漏滑改时间，你可以把这个时间参数差世提取处理，放到一个页面或者数据库存起来，然后别人通过页面或者链接数据库修改就行了。
   

2. java的几种定时任务

java定时任务有三种：

- JDK自带 ：JDK自带的Timer以及JDK1.5+ 新增的ScheledExecutorService；

- Quartz ：简单却强大的JAVA作业调度框架

- Spring3.0以后自带的task ：可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多；

代码参考：

1. JDK 自带的定时器实现

   schele(TimerTask task, Date time) 特定时间执行

   
   public static void main(String[] args) {

   
   for (int i = 0; i < 10; ++i) {

   
   new Timer("timer - " + i).schele(new TimerTask() {

   
   @Override
   public void run() {

   
   println(Thread.currentThread().getName() + " run ");

   
   }

   
   }, new Date(System.currentTimeMillis() + 2000));

   
   }
   }

2. Quartz 定时器实现

   2.1 通过maven引入依赖（这里主要介绍2.3.0） 注意：shiro-scheler中依赖的是1.x版本 如果同时使用会冲突

   <!-- https://mvnrepository.com/artifact/org.quartz-scheler/quartz -->

   
   <dependency>

   
   <groupId>org.quartz-scheler</groupId>

   
   <artifactId>quartz</artifactId>

   
   <version>2.3.0</version>

   
   </dependency>

   2.2创建Job类

   public class TestJob implements Job{

   
   @Override
   public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

   
   println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());

   
   }
   }

   2.3调度任务

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

   
   Scheler scheler = new StdSchelerFactory().getScheler();

   
   // 开始

   
   scheler.start();

   
   // job 唯一标识 test.test-1

   
   JobKey jobKey = new JobKey("test" , "test-1");

   
   JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();

   
   Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("test" , "test")

// 延迟一秒执行

.startAt(new Date(System.currentTimeMillis() + 1000))

// 每隔一秒执行 并一直重复

.withSchele(SimpleScheleBuilder.simpleSchele().withIntervalInSeconds(1).repeatForever())
.build();

scheler.scheleJob(jobDetail , trigger);

Thread.sleep(5000);
// 删除job

scheler.deleteJob(jobKey);

}

3.Spring 相关的任务调度

3.1 配置文件实现

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

<task:scheled-tasks scheler="myScheler">

<task:scheled ref="job" method="test" cron="0 * * * * ?"/>

</task:scheled-tasks>

3.2注解实现

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

// 启用注解

<task:annotation-driven scheler="myScheler"/>

@Component
public class Task{

@Scheled(cron="0/5 * * * * ? ") //每5秒执行一次
public void execute(){

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

System.out.println(sdf.format(DateTime.now().toDate())+"*********B任务每5秒执行一次进入测试");

}
}

3. java中quartz定时任务的执行如何避免并发

只要在detail的参数里加上一句话就行了，把这个job设置成有状态的job
<property name="concurrent" value="false" />

扩展：通过concurrent属性指定任务的类型喊团，默认情况下封装为无状态的任务，如果扮裂希望目标封装为有状态的任务，仅需要将concurrent设置为false就可以了。Spring通过名为concurrent的属性指定任务的类型厅渗闭，能够更直接地描述到任务执行的方式（有状态的任务不能并发执行，无状态的任务可并发执行）

4. 如何监控java quartz定时器中的所有定时任务

定时器的实现：
1、首先实现一个用于被执行的类，这个类并差用于被定时器调度，这个类不需要继承任何类或者接口，代码如下：
publicTestQuartz{
public void doSomething(){ //TODO } }
2、spring配置文件，具体配置
<册蔽兆!-- 被执行类 -->
<beanid="testQuarzt"class="test.testQuarzt"/>
<!-- 将testQuarzt注入到job中 -->
<beanid="testQuartzJob"class="org.springframework.scheling.quartz.">
<property name="targetObject" ref="testQuarzt" /> <property name="targetMethod" value="doSomething" />州租 <property name="concurrent" value="false" /> </bean>
<!-- 将job注入到定时触发器 -->
<beanid="testTrigger"class="org.springframework.scheling.quartz.CronTriggerBean"> <property name="jobDetail" ref="testQuartzJob" /> <property name="cronExpression"> <value>0 0 6 * * ?<value> <property> <bean>
<!-- 将定时触发器注入任务工程 -->
<beanclass="org.springframework.scheling.quartz.SchelerFactoryBean"> <property name="triggers"> <list>望采纳，谢谢。

5. springMVc框架中java quartz设定在每日8:00-19:00，每五分钟执行一次

这么写就可以了，使用spring的定时任务实现很简单，代码如下：

importorg.springframework.scheling.annotation.Scheled;
importorg.springframework.stereotype.Component;

@Component
publicclassScheleTask{

旦改顷@Scheled(cron="00/58-19**模陆?*")
publicvoiddoSomething(){
歼枯//TODO
}

}

6. java如何利用第三方Quartz实现定时任务

给你一个简单的案例加详细注解

1. /*
   * job是一个接口，只有一个方法void execute(JobExecutionContext context)，
   * 被调度的作业（类）需实现该接口中execute()方法，
   * JobExecutionContext类提供了调度上下文的各种信息。每次执行该Job均重新创建一个Job实例
   */
   public class MyJob implements Job {
   //MyJob类为需要定时执行的类，execute为定时执行的方法。一个定时任务对应一个Job实现类。
   @Override
   public void execute(JobExecutionContext arg0) throws JobExecutionException {
   // TODO Auto-generated method stub
   perform();
   }
   public void perform(){ //执行报表统计入口函数
   //业务逻辑
   System.out.println("执行时间："+new Date());
   }
   
   
   }

2. public class QuartzTest5 {
   
   public static void main(String[] args) throws Exception {
   //SchelerFactory 是一个接口，用于Scheler的创建和管理
   SchelerFactory factory = new StdSchelerFactory();
   //从工厂里面拿到一个scheler实例
   //计划表(可能翻译的不太贴切)，现在我们有了要做的内容，
   //与调度程序交互的主要API
   /*
   * Scheler的生命绝团期，从SchelerFactory创建它时开始，
   到Scheler调用shutdown()方法时结束；Scheler被创建后，
   可以增加、删除和列举Job和Trigger，以及执行其它与调度相关的操作
   （如暂停Trigger）。但是，Scheler只有在调用start()方法后，
   才会真正地触发trigger（即执行job）
   */
   Scheler scheler = factory.getScheler();
   //具体任务.
   //用于定义作业的实例
   //JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。
   JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
   
   
   //Trigger（即触发并燃橘器） - 定义执行给段逗定作业的计划的组件
   //TriggerBuilder - 用于定义/构建触发器实例
   CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
   .withSchele(CronScheleBuilder.cronSchele("0/1 * * * * ?")).build();
   scheler.scheleJob(job, trigger);
   scheler.start();
   
   
   }
   
   }
   

7. Java中定时任务quartz如何将历史数据写入新表

我建议的做法是在数据库中建一些Quartz的表，MySQL的建、删表脚本，最主要的修改是quartz.properties，如果你使用的是其他数据库，可以下载Quartz的distribution，在\docs\dbTables下。然后我们可以启动Bootstrap类，注册、运行定时任务。你可以发现MySQL的表中已经有此定时任务的记录了。
然后你可以停止Bootstrap类，将Bootstrap类中关于注册、启动定时任务的代码删除或注释，然后启动Bootstrap类，看上一次操作注册的定时任务会不会继续运行。
如无意外，看上一次操作注册的定时任务会继续运行。

8. java quartz 定时需要的包

1.需要的jar包

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

2.定义定时任务配置类
该类主要进行定时任务时间的设置和设置对应的定时任务类。
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheler;
import org.quartz.impl.StdSchelerFactory;

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 * * * * ?");

Scheler sch = StdSchelerFactory.getDefaultScheler();
sch.scheleJob(jobDetail, trigger);
sch.start();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 修改定时任务时间
*/
public static void modifyJobTime(String triggerName, String time) {
System.out.println("modify~~~~~~~~~~~~~~~~");
try {
Scheler sched = StdSchelerFactory.getDefaultScheler();
System.out.println("triggerName "稿让型 + triggerName);
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, Scheler.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秒执行一次。