java定時任務quartz

1. 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();
   
   
   }
   
   }
   

2. 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秒執行一次。

3. 用quartzi給一個java程序做定時任務，怎樣傳遞參數

java定時任務Timer
關於定時任務，似乎跟時間操作的聯系並不是很大

4. Java中定時任務quartz如何將歷史數據寫入新表

我建議的做法是在資料庫中建一些Quartz的表，MySQL的建、刪表腳本，最主要的修改是quartz.properties，如果你使用的是其他資料庫，可以下載Quartz的distribution，在\docs\dbTables下。然後我們可以啟動Bootstrap類，注冊、運行定時任務。你可以發現MySQL的表中已經有此定時任務的記錄了。
然後你可以停止Bootstrap類，將Bootstrap類中關於注冊、啟動定時任務的代碼刪除或注釋，然後啟動Bootstrap類，看上一次操作注冊的定時任務會不會繼續運行。
如無意外，看上一次操作注冊的定時任務會繼續運行。

5. java 定時任務quarz 怎麼解決掃描隊列時速度慢

到quartz官網下載相應的jar包。
2
解壓jar包，將資料庫sql執行腳本引入到自己的資料庫中
3
解壓jar包，將quartz相關jar包引入程序中，並將測試用例也引入程序中，啟動tomcat連接資料庫進行測試即可

6. 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秒執行一次進入測試");

}
}

7. 如何監控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>望採納，謝謝。

8. Quartz的定時任務。我要每隔24小時執行一次。Quartz怎麼設置。

1、首先新建一個控制台程序，利用Nuget引入Quartz的程序包，同時會自動引入日誌庫，用於輸入日誌，如下圖所示。

9. java中quartz定時任務的執行如何避免並發

只要在detail的參數里加上一句話就行了，把這個job設置成有狀態的job
<property name="concurrent" value="false" />

擴展：通過concurrent屬性指定任務的類型，默認情況下封裝為無狀態的任務，如果希望目標封裝為有狀態的任務，僅需要將concurrent設置為false就可以了。Spring通過名為concurrent的屬性指定任務的類型，能夠更直接地描述到任務執行的方式（有狀態的任務不能並發執行，無狀態的任務可並發執行）

10. java：如何使用 quartz定時執行任務，例如定時執行System.out.pintln("aa")；看清楚用quartz

}
importstaticorg.quartz.CronScheleBuilder.cronSchele;
importstaticorg.quartz.JobBuilder.newJob;
importstaticorg.quartz.TriggerBuilder.newTrigger;

importjava.text.SimpleDateFormat;
importjava.util.Date;

importorg.quartz.CronTrigger;
importorg.quartz.JobDetail;
importorg.quartz.Scheler;
importorg.quartz.SchelerFactory;
importorg.quartz.impl.StdSchelerFactory;

publicclassTest{
publicvoidgo()throwsException{
//首先，必需要取得一個Scheler的引用
SchelerFactorysf=newStdSchelerFactory();
Schelersched=sf.getScheler();
//jobs可以在scheled的sched.start()方法前被調用

//job1將每隔30分鍾執行一次
JobDetailjob=newJob(myJob.class).withIdentity("job1","group1").build();
CronTriggertrigger=newTrigger().withIdentity("trigger1","group1").withSchele(cronSchele("00/30***?")).build();
Dateft=sched.scheleJob(job,trigger);
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ssSSS");
System.out.pintln("aa")；


//開始執行，start()方法被調用後，計時器就開始工作，計時調度中允許放入N個Job
sched.start();
try{
//主線程等待一分鍾
Thread.sleep(60L*1000L);
}catch(Exceptione){}	
//關閉定時調度，定時器不再工作
sched.shutdown(true);
}

publicstaticvoidmain(String[]args)throwsException{

Testtest=newTest();
test.go();
}

}