玩转 quartz quartz 教程 quartz 实现 quartz 封装

玩转 quartz quartz 教程 quartz 实现 quartz 封装 收藏
转载请表明出处，作者 keyboardsun

http://blog.csdn.net/keyboardsun/archive/2009/07/09/4335333.aspx

需要源代码，发邮件到[e-mail]

代码可以直接使用。

代码下载地址：

http://download.csdn.net/source/1477754

最近在开发JDF项目。项目中需要用到任务调度，自动任务等功能，想自己开发一个，但是看看 quartz    那么强劲，自己开发，开发加调试，可能需要些时日。如果用quartz可能一天就可以搞定，只需要配置点数据就可以了。

下面步入正题。讲解quartz的封装使用。

这里我把任务，以及任务的表达式配置到数据库里面。

如图：



如上图所示，配置了三个任务。

表结构介绍：


view plaincopy to clipboardprint?
01.-- ----------------------------  
02.-- Table structure for job_task  
03.-- ----------------------------  
04.CREATE TABLE `job_task` (  
05.  `TASK_ID` int(11) NOT NULL,   
06.  `TASK_CODE` varchar(255) default NULL,  
07.  `TASK_TYPE` varchar(255) default NULL,  
08.  `TASK_IMPL_CLASS` varchar(255) default NULL,  
09.  `TASK_EXPRESS` varchar(50) default NULL,  
10.  `STATE_DATE` datetime default NULL,  
11.  `STATE` varchar(2) default NULL COMMENT 'U 使用中 O已结束',  
12.  `PARMS` varchar(500) default NULL,  
13.  `REMARK` varchar(2000) default NULL,  
14.  `CREATE_DATE` datetime default NULL,  
15.  PRIMARY KEY  (`TASK_ID`)  
16.) ENGINE=InnoDB DEFAULT CHARSET=gbk; 
-- ----------------------------
-- Table structure for job_task
-- ----------------------------
CREATE TABLE `job_task` (
  `TASK_ID` int(11) NOT NULL,
  `TASK_CODE` varchar(255) default NULL,
  `TASK_TYPE` varchar(255) default NULL,
  `TASK_IMPL_CLASS` varchar(255) default NULL,
  `TASK_EXPRESS` varchar(50) default NULL,
  `STATE_DATE` datetime default NULL,
  `STATE` varchar(2) default NULL COMMENT 'U 使用中 O已结束',
  `PARMS` varchar(500) default NULL,
  `REMARK` varchar(2000) default NULL,
  `CREATE_DATE` datetime default NULL,
  PRIMARY KEY  (`TASK_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

字段介绍：

TASK_ID 任务的主键

TASK_CODE 任务编码 ，这里启动任务的时候，作为qz任务的名称

TASK_TYPE_CODE 任务类型，这里启动任务的时候，作为qz任务的分组

TASK_IMPL_CLASS 任务的类。

TASK_EXPRESS 任务执行表达式

STATE_DATE 任务更新时间，这里在任务运行中，如果需要使运行中的任务修改立马生效，需要把这个字段的值设置大于当前时间。

STATE 任务状态

PARMS 任务初始化参数，任务运行的时候，可以从JobDataMap对象中获取该字段的值。

CREATE_DATE 创建日期，没有什么实际意义。

下面需要记录任务执行的日志，如下图所示



如上图所示，log编号是12 的任务正在执行中... STATE是R =run

字段解释

view plaincopy to clipboardprint?
01.-- ----------------------------  
02.-- Table structure for task_log  
03.-- ----------------------------  
04.CREATE TABLE `task_log` (  
05.  `TASK_LOG_ID` int(8) NOT NULL,  
06.  `TASK_ID` int(8) default NULL,  
07.  `STATE` varchar(2) default NULL COMMENT 'O结束，R运行中，E异常结束',  
08.  `START_DATE` datetime default NULL,  
09.  `FINISH_DATE` datetime default NULL,  
10.  `REMARKS` varchar(2000) default NULL,  
11.  PRIMARY KEY  (`TASK_LOG_ID`)  
12.) ENGINE=InnoDB DEFAULT CHARSET=gbk; 
-- ----------------------------
-- Table structure for task_log
-- ----------------------------
CREATE TABLE `task_log` (
  `TASK_LOG_ID` int(8) NOT NULL,
  `TASK_ID` int(8) default NULL,
  `STATE` varchar(2) default NULL COMMENT 'O结束，R运行中，E异常结束',
  `START_DATE` datetime default NULL,
  `FINISH_DATE` datetime default NULL,
  `REMARKS` varchar(2000) default NULL,
  PRIMARY KEY  (`TASK_LOG_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

TASK_LOG_ID 任务日志编号

TASK_ID 任务编号

STATE 执行状态，如果是E 的，说明异常了，异常信息会放在REMARKS字段中

START_DATE 执行开始时间

FINISH_DATE 执行结束时间

REMARKS 备注。

下面要开始贴代码啦：如下图所示，一共包括如下这么多的JAVA文件。



一共包括文件为：

ITask.java 业务系统需要实现的接口方法。

JDBC.java 简单的数据库操作类

JobEngine 用于修改运行中的job的信息，定时扫描JOB_TASK配置表的改变信息。

JobTaskBean.java 表JOB_TASK对应的bean

Mouse.java 入口类，启动qz引擎。

Task.java 抽象类，用于记录qz 任务的日志，业务系统的任务需要继承这个类。

TaskLogBean.java 任务日志表TASK_LOG对应的Bean.

Test.java 测试任务。

下面开始贴代码啦：

ITask.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.util.HashMap;  
04. 
05./** 
06. * 业务系统需要实现的接口方法。 
07. *  
08. * @author keyboardsun 
09. */ 
10.public interface ITask{  
11.  /** 
12.   * 这里留了一个execute接口给业务系统使用，业务系统写任务的时候，只需要继承Task类就可以了。 
13.   *  
14.   * @param map 这里的map功能可强劲了噢，因为很多任务执行可能需要传入参数，这个参数可以配置在JOB_TASK表的PARMS字段里面 
15.   * 比如配置  
16.   * <item> 
17.   * <key>sss</key> 
18.   * <value>vvv</value> 
19.   * </item> 
20.   * <item> 
21.   * <key>ss</key> 
22.   * <value>vv</value> 
23.   * </item> 
24.   * 这里在程序运行中，启动业务系统job的时候，会吧上面的记录已MAP的形式传递过去。 
25.   * 这个在PARMS字段里面，那么在业务系统实现这个方法的时候，可以通过 
26.   * map.get("ss") 获得 vv 值 
27.   */ 
28.  public void execute( HashMap map );  
29.} 
package net.chinacsharp.jdf.quartz;

import java.util.HashMap;

/**
* 业务系统需要实现的接口方法。
*
* @author keyboardsun
*/
public interface ITask{
  /**
   * 这里留了一个execute接口给业务系统使用，业务系统写任务的时候，只需要继承Task类就可以了。
   *
   * @param map 这里的map功能可强劲了噢，因为很多任务执行可能需要传入参数，这个参数可以配置在JOB_TASK表的PARMS字段里面
   * 比如配置
   * <item>
   * <key>sss</key>
   * <value>vvv</value>
   * </item>
   * <item>
   * <key>ss</key>
   * <value>vv</value>
   * </item>
   * 这里在程序运行中，启动业务系统job的时候，会吧上面的记录已MAP的形式传递过去。
   * 这个在PARMS字段里面，那么在业务系统实现这个方法的时候，可以通过
   * map.get("ss") 获得 vv 值
   */
  public void execute( HashMap map );
}


JDBC.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.io.StringReader;  
04.import java.sql.Connection;  
05.import java.sql.DriverManager;  
06.import java.sql.PreparedStatement;  
07.import java.sql.ResultSet;  
08.import java.sql.SQLException;  
09.import java.sql.Time;  
10.import java.sql.Timestamp;  
11.import java.util.ArrayList;  
12.import java.util.HashMap;  
13.import java.util.List;  
14./** 
15. * 简单的数据库操作类 
16. * @author keyboardsun 
17. * 
18. */ 
19.public class JDBC{  
20.      
21.  /** 
22.   * 获取数据库连接，这里的例子是用mysql的 
23.   * @return 
24.   * @throws Exception 
25.   */ 
26.  public static Connection getConnection()throws Exception {  
27.    try {  
28.      Class.forName("com.mysql.jdbc.Driver").newInstance();  
29.      Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/qz", "root", "admin");     
30.      conn.setAutoCommit(true);  
31.      return conn;  
32.    } catch (Exception e) {  
33.      throw e;  
34.    }  
35.  }  
36.    
37.  /** 
38.   * 插入操作日志，返回操作日志的主键的值。 
39.   * 这里用了同步，可能执行过程中会影响效率，当然这里可以选择用static变量都是可以了，反正这是一个解决办法而已，随便你怎么搞， 
40.   * 这个只是一个超级简单的例子，能看明白怎么回事就好了。 
41.   * @param sql 
42.   * @param map 
43.   * @return 
44.   * @throws Exception 
45.   */ 
46.  public synchronized static TaskLogBean insert(String sql,HashMap map) throws Exception{  
47.    Connection con = getConnection();  
48.    String sql_ = "SELECT MAX(TASK_LOG_ID)+1 FROM TASK_LOG"; //获取最大的值+1 作为主键，这里方法比较土。  
49.    PreparedStatement ps = con.prepareStatement(sql_);  
50.    ResultSet rs = ps.executeQuery();  
51.    rs.next();  
52.    map.put("TASK_LOG_ID",new Long(rs.getLong(1)));  
53.    rs.close();  
54.    ps = execStatementValues(con,sql,map);  
55.    ps.executeUpdate();  
56.    sql_= "SELECT * FROM TASK_LOG WHERE TASK_LOG_ID=:TASK_LOG_ID";  
57.    TaskLogBean[] bean = getTaskLogBean(con,sql_, map);  
58.    return bean[0];      
59.  }  
60.    
61.  /** 
62.   * 获取JOB的任务列表。 
63.   * @param sql 
64.   * @param map 
65.   * @return 
66.   * @throws Exception 
67.   */ 
68.  public static JobTaskBean[] getJobTaskBean(String sql,HashMap map) throws Exception{  
69.    Connection con = getConnection();  
70.    PreparedStatement ps = execStatementValues(con,sql,map);  
71.    ResultSet rs = ps.executeQuery();  
72.    List list = new ArrayList();  
73.    while(rs.next()){  
74.      JobTaskBean bean = new JobTaskBean();  
75.      bean.setCreateDate(rs.getTimestamp("CREATE_DATE"));  
76.      bean.setParms(rs.getString("PARMS"));  
77.      bean.setRemark(rs.getString("REMARK"));  
78.      bean.setState(rs.getString("STATE"));  
79.      bean.setStateDate(rs.getTimestamp("STATE_DATE"));  
80.      bean.setTaskCode(rs.getString("TASK_CODE"));  
81.      bean.setTaskExpress(rs.getString("TASK_EXPRESS"));  
82.      bean.setTaskId(rs.getLong("TASK_ID"));  
83.      bean.setTaskImplClass(rs.getString("TASK_IMPL_CLASS"));  
84.      bean.setTaskType(rs.getString("TASK_TYPE"));  
85.      list.add(bean);  
86.    }  
87.    rs.close();  
88.    con.close();  
89.    return list.size()==0?null:(JobTaskBean[])list.toArray(new JobTaskBean[0]);  
90.  }  
91.    
92.  /** 
93.   * 获取任务日志记录 
94.   * @param con 
95.   * @param sql 
96.   * @param map 
97.   * @return 
98.   * @throws Exception 
99.   */ 
100.  public static TaskLogBean[] getTaskLogBean(Connection con,String sql,HashMap map) throws Exception{  
101.    if(con==null)  
102.     con = getConnection(); //这里连接可以传空，无所谓的。  
103.    PreparedStatement ps = execStatementValues(con,sql,map);  
104.    ResultSet rs = ps.executeQuery();  
105.    List list = new ArrayList();  
106.    while(rs.next()){  
107.      TaskLogBean bean = new TaskLogBean();  
108.      bean.setFinishDate(rs.getTimestamp("FINISH_DATE"));  
109.      bean.setRemarks(rs.getString("REMARKS"));  
110.      bean.setStartDate(rs.getTimestamp("START_DATE"));  
111.      bean.setState(rs.getString("STATE"));       
112.      bean.setTaskId(rs.getLong("TASK_ID"));  
113.      bean.setTaskLogId(rs.getLong("TASK_LOG_ID"));  
114.      list.add(bean);  
115.    }  
116.    rs.close();  
117.    con.close();  
118.    return list.size()==0?null:(TaskLogBean[])list.toArray(new TaskLogBean[0]);  
119.  }  
120.    
121.  /** 
122.   * 以下方法用于绑定变量的，没啥技术含量。 
123.   * 可以参看我的另外的数据库绑定变量的blog。 
124.   * 更多代码可以去sourceforge下载jdf项目看看。 
125.   * @param con 数据库连接 
126.   * @param sql 绑定变量类型的sql 
127.   * @param map 绑定值和绑定名字 
128.   * @return 赋值初始化好的 
129.   * @throws SQLException 
130.   */ 
131.  public static PreparedStatement execStatementValues(Connection con,String sql,HashMap map) throws Exception{  
132.      
133.    PreparedStatement stmt = null;  
134.    ArrayList clumBandNameList = new ArrayList(); //存放绑定变量的名字  
135.    sql = sql + " ";  
136.    String [] temp = sql.split(":"); //这里把变量的名字给取出来  
137.    for (int i = 1; i < temp.length; i++) {  
138.      try{  
139.      clumBandNameList.add(temp[i].substring(0,temp[i].indexOf(" ")));    
140.      } catch(StringIndexOutOfBoundsException exception){  
141.        clumBandNameList.add(temp[i]);    
142.      }  
143.    }     
144.    sql = sql.replaceAll(":(.*?)\\s","?");//把绑定变量的名字:XXX 取出为 ?,生成标准SQL  
145.      
146.    stmt = con.prepareStatement(sql);  
147.    
148.    int index = 0;  
149.      
150.    for (int i = 0; i < clumBandNameList.size(); i++) {  
151.      if(map==null||map.size()<1){          
152.        throw new SQLException("有的变量的值没有赋，请确定每个绑定的都有值了："+sql+"\n"+map.toString());  
153.      }  
154.      Object value = null;  
155.      try{  
156.        value = map.get(clumBandNameList.get(i));  
157.//      log.debug("邦定变量的值:"+clumBandNameList.get(i)+"="+value.toString());      
158.      }catch(Exception e){  
159.        throw new Exception("变量："+clumBandNameList.get(i)+" 没有对应绑定的值");  
160.      }  
161.            
162.      String type = value.getClass().getName().substring(value.getClass().getName().lastIndexOf(".")); //获取绑定的类型  
163.      index = i+1; //绑定的索引      
164.       if (type.equalsIgnoreCase("String")) {  
165.            String content = value.toString();  
166.            if (content.length() > 2000) {  
167.              stmt.setCharacterStream(index, new StringReader(content), content.length());  
168.            } else  {  
169.              stmt.setString(index, content);  
170.            }  
171.          }  else if (type.equalsIgnoreCase("Short")) {             
172.            stmt.setShort(index, Short.parseShort(value.toString()));             
173.          } else if (type.equalsIgnoreCase("Integer")) {   
174.            stmt.setInt(index, Integer.parseInt(value.toString()));  
175.          }  else if (type.equalsIgnoreCase("Float")) {   
176.            stmt.setFloat(index, Float.parseFloat(value.toString()));  
177.          } else if (type.equalsIgnoreCase("Byte")) {   
178.            stmt.setByte(index, Byte.parseByte(value.toString()));  
179.          } else if (type.equalsIgnoreCase("Char")) {   
180.            stmt.setString(index, value.toString());              
181.          }   else if (type.equalsIgnoreCase("Long")) {   
182.            stmt.setLong(index, Long.parseLong(value.toString()));  
183.          } else if (type.equalsIgnoreCase("Double")) {   
184.            stmt.setDouble(index, Double.parseDouble(value.toString()));  
185.          }else if (type.equalsIgnoreCase("Boolean")) {  
186.            stmt.setBoolean(index, Boolean.getBoolean(value.toString()));  
187.          } else if (type.equalsIgnoreCase("Date")) {  
188.            if (value instanceof java.sql.Date)  
189.              stmt.setDate(index, (java.sql.Date)value);  
190.            else 
191.              stmt.setDate(index, java.sql.Date.valueOf(value.toString()));  
192.          } else if (type.equalsIgnoreCase("Time")) {  
193.            if (value instanceof Time)  
194.              stmt.setTime(index, (Time)value);  
195.            else 
196.              stmt.setTime(index, Time.valueOf(value.toString()));  
197.          } else if (type.equalsIgnoreCase("DateTime")) {  
198.            if (value instanceof Timestamp)  
199.              stmt.setTimestamp(index, (Timestamp)value);  
200.            else if (value instanceof java.sql.Date)  
201.              stmt.setTimestamp(index, new Timestamp(((java.sql.Date)value).getTime()));  
202.            else 
203.              stmt.setTimestamp(index, Timestamp.valueOf(value.toString()));  
204.          }  
205.          else if(type.equalsIgnoreCase("Timestamp")){  
206.            stmt.setTimestamp(index, (Timestamp)value);  
207.          }  
208.          else if (value instanceof Character) {  
209.            stmt.setString(index, value.toString());  
210.          } else {  
211.            stmt.setObject(index, value);  
212.          }  
213.    }  
214. 
215.    return stmt;  
216.          
217.  }  
218.    
219.    
220.} 
package net.chinacsharp.jdf.quartz;

import java.io.StringReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* 简单的数据库操作类
* @author keyboardsun
*
*/
public class JDBC{
   
  /**
   * 获取数据库连接，这里的例子是用mysql的
   * @return
   * @throws Exception
   */
  public static Connection getConnection()throws Exception {
    try {
      Class.forName("com.mysql.jdbc.Driver").newInstance();
      Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/qz", "root", "admin");  
      conn.setAutoCommit(true);
      return conn;
    } catch (Exception e) {
      throw e;
    }
  }
 
  /**
   * 插入操作日志，返回操作日志的主键的值。
   * 这里用了同步，可能执行过程中会影响效率，当然这里可以选择用static变量都是可以了，反正这是一个解决办法而已，随便你怎么搞，
   * 这个只是一个超级简单的例子，能看明白怎么回事就好了。
   * @param sql
   * @param map
   * @return
   * @throws Exception
   */
  public synchronized static TaskLogBean insert(String sql,HashMap map) throws Exception{
    Connection con = getConnection();
    String sql_ = "SELECT MAX(TASK_LOG_ID)+1 FROM TASK_LOG"; //获取最大的值+1 作为主键，这里方法比较土。
    PreparedStatement ps = con.prepareStatement(sql_);
    ResultSet rs = ps.executeQuery();
    rs.next();
    map.put("TASK_LOG_ID",new Long(rs.getLong(1)));
    rs.close();
    ps = execStatementValues(con,sql,map);
    ps.executeUpdate();
    sql_= "SELECT * FROM TASK_LOG WHERE TASK_LOG_ID=:TASK_LOG_ID";
    TaskLogBean[] bean = getTaskLogBean(con,sql_, map);
    return bean[0];   
  }
 
  /**
   * 获取JOB的任务列表。
   * @param sql
   * @param map
   * @return
   * @throws Exception
   */
  public static JobTaskBean[] getJobTaskBean(String sql,HashMap map) throws Exception{
    Connection con = getConnection();
    PreparedStatement ps = execStatementValues(con,sql,map);
    ResultSet rs = ps.executeQuery();
    List list = new ArrayList();
    while(rs.next()){
      JobTaskBean bean = new JobTaskBean();
      bean.setCreateDate(rs.getTimestamp("CREATE_DATE"));
      bean.setParms(rs.getString("PARMS"));
      bean.setRemark(rs.getString("REMARK"));
      bean.setState(rs.getString("STATE"));
      bean.setStateDate(rs.getTimestamp("STATE_DATE"));
      bean.setTaskCode(rs.getString("TASK_CODE"));
      bean.setTaskExpress(rs.getString("TASK_EXPRESS"));
      bean.setTaskId(rs.getLong("TASK_ID"));
      bean.setTaskImplClass(rs.getString("TASK_IMPL_CLASS"));
      bean.setTaskType(rs.getString("TASK_TYPE"));
      list.add(bean);
    }
    rs.close();
    con.close();
    return list.size()==0?null:(JobTaskBean[])list.toArray(new JobTaskBean[0]);
  }
 
  /**
   * 获取任务日志记录
   * @param con
   * @param sql
   * @param map
   * @return
   * @throws Exception
   */
  public static TaskLogBean[] getTaskLogBean(Connection con,String sql,HashMap map) throws Exception{
    if(con==null)
     con = getConnection(); //这里连接可以传空，无所谓的。
    PreparedStatement ps = execStatementValues(con,sql,map);
    ResultSet rs = ps.executeQuery();
    List list = new ArrayList();
    while(rs.next()){
      TaskLogBean bean = new TaskLogBean();
      bean.setFinishDate(rs.getTimestamp("FINISH_DATE"));
      bean.setRemarks(rs.getString("REMARKS"));
      bean.setStartDate(rs.getTimestamp("START_DATE"));
      bean.setState(rs.getString("STATE"));    
      bean.setTaskId(rs.getLong("TASK_ID"));
      bean.setTaskLogId(rs.getLong("TASK_LOG_ID"));
      list.add(bean);
    }
    rs.close();
    con.close();
    return list.size()==0?null:(TaskLogBean[])list.toArray(new TaskLogBean[0]);
  }
 
  /**
   * 以下方法用于绑定变量的，没啥技术含量。
   * 可以参看我的另外的数据库绑定变量的blog。
   * 更多代码可以去sourceforge下载jdf项目看看。
   * @param con 数据库连接
   * @param sql 绑定变量类型的sql
   * @param map 绑定值和绑定名字
   * @return 赋值初始化好的
   * @throws SQLException
   */
  public static PreparedStatement execStatementValues(Connection con,String sql,HashMap map) throws Exception{
   
    PreparedStatement stmt = null;
    ArrayList clumBandNameList = new ArrayList(); //存放绑定变量的名字
    sql = sql + " ";
    String [] temp = sql.split(":"); //这里把变量的名字给取出来
    for (int i = 1; i < temp.length; i++) {
      try{
      clumBandNameList.add(temp[i].substring(0,temp[i].indexOf(" "))); 
      } catch(StringIndexOutOfBoundsException exception){
        clumBandNameList.add(temp[i]); 
      }
    }  
    sql = sql.replaceAll(":(.*?)\\s","?");//把绑定变量的名字:XXX 取出为 ?,生成标准SQL
   
    stmt = con.prepareStatement(sql);
 
    int index = 0;
   
    for (int i = 0; i < clumBandNameList.size(); i++) {
      if(map==null||map.size()<1){       
        throw new SQLException("有的变量的值没有赋，请确定每个绑定的都有值了："+sql+"\n"+map.toString());
      }
      Object value = null;
      try{
        value = map.get(clumBandNameList.get(i));
//      log.debug("邦定变量的值:"+clumBandNameList.get(i)+"="+value.toString());   
      }catch(Exception e){
        throw new Exception("变量："+clumBandNameList.get(i)+" 没有对应绑定的值");
      }
         
      String type = value.getClass().getName().substring(value.getClass().getName().lastIndexOf(".")); //获取绑定的类型
      index = i+1; //绑定的索引   
       if (type.equalsIgnoreCase("String")) {
            String content = value.toString();
            if (content.length() > 2000) {
              stmt.setCharacterStream(index, new StringReader(content), content.length());
            } else  {
              stmt.setString(index, content);
            }
          }  else if (type.equalsIgnoreCase("Short")) {          
            stmt.setShort(index, Short.parseShort(value.toString()));          
          } else if (type.equalsIgnoreCase("Integer")) {
            stmt.setInt(index, Integer.parseInt(value.toString()));
          }  else if (type.equalsIgnoreCase("Float")) {
            stmt.setFloat(index, Float.parseFloat(value.toString()));
          } else if (type.equalsIgnoreCase("Byte")) {
            stmt.setByte(index, Byte.parseByte(value.toString()));
          } else if (type.equalsIgnoreCase("Char")) {
            stmt.setString(index, value.toString());           
          }   else if (type.equalsIgnoreCase("Long")) {
            stmt.setLong(index, Long.parseLong(value.toString()));
          } else if (type.equalsIgnoreCase("Double")) {
            stmt.setDouble(index, Double.parseDouble(value.toString()));
          }else if (type.equalsIgnoreCase("Boolean")) {
            stmt.setBoolean(index, Boolean.getBoolean(value.toString()));
          } else if (type.equalsIgnoreCase("Date")) {
            if (value instanceof java.sql.Date)
              stmt.setDate(index, (java.sql.Date)value);
            else
              stmt.setDate(index, java.sql.Date.valueOf(value.toString()));
          } else if (type.equalsIgnoreCase("Time")) {
            if (value instanceof Time)
              stmt.setTime(index, (Time)value);
            else
              stmt.setTime(index, Time.valueOf(value.toString()));
          } else if (type.equalsIgnoreCase("DateTime")) {
            if (value instanceof Timestamp)
              stmt.setTimestamp(index, (Timestamp)value);
            else if (value instanceof java.sql.Date)
              stmt.setTimestamp(index, new Timestamp(((java.sql.Date)value).getTime()));
            else
              stmt.setTimestamp(index, Timestamp.valueOf(value.toString()));
          }
          else if(type.equalsIgnoreCase("Timestamp")){
            stmt.setTimestamp(index, (Timestamp)value);
          }
          else if (value instanceof Character) {
            stmt.setString(index, value.toString());
          } else {
            stmt.setObject(index, value);
          }
    }

    return stmt;
       
  }
 
 
}


JobEngine.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.io.ByteArrayInputStream;  
04.import java.sql.Connection;  
05.import java.sql.PreparedStatement;  
06.import java.util.Date;  
07.import java.util.HashMap;  
08.import java.util.Iterator;  
09.import java.util.List;  
10. 
11.import org.dom4j.Document;  
12.import org.dom4j.Element;  
13.import org.dom4j.io.SAXReader;  
14.import org.quartz.CronTrigger;  
15.import org.quartz.Job;  
16.import org.quartz.JobDataMap;  
17.import org.quartz.JobDetail;  
18.import org.quartz.JobExecutionContext;  
19.import org.quartz.JobExecutionException;  
20.import org.quartz.Scheduler;  
21. 
22./** 
23. * 这只是一个简单的JOB而已，名字貌似很NB，这个任务用于实时的检测任务列表的状态，用于更新JOB。 
24. * 这样你改了个配置，可以立马生效的噢。 
25. * 这个类用于在JOB运行期间，使得修改立马生效。 
26. * @author keyboardsun 
27. * 
28. */ 
29.public class JobEngine  
30.    implements Job{  
31. 
32.  public void execute( JobExecutionContext arg0 ) throws JobExecutionException{  
33. 
34.    try{  
35.      Scheduler inScheduler = arg0.getScheduler();  
36.      JobDetail job = null;  
37.      JobDataMap map = null;  
38.      CronTrigger trigger = null;  
39.      /** 
40.       * 这里根据状态U使用的，以及STATE_DATE日期大于当前日期，判断这个任务是刚更新的，如果你想使得修改的JOB立马生效。你需要吧JOB_TASK的字段的值改得大于当前日期，那样这里就会更新到了噢。 
41.       */        
42.      JobTaskBean[] bean = JDBC.getJobTaskBean( "SELECT * FROM JOB_TASK WHERE STATE='U' AND STATE_DATE>now()", new HashMap() );  
43.      if( bean == null )  
44.        return;  
45.      for( int i = 0; i < bean.length; i++ ){  
46.        //这里使得修改的job更新，为了避免重复更新，需要吧STATE_DATE日期改过来。  
47.        String update = "UPDATE JOB_TASK SET STATE_DATE=now() WHERE TASK_ID=:TASK_ID";  
48.        Connection con = JDBC.getConnection();  
49.        HashMap m = new HashMap();  
50.        m.put( "TASK_ID", new Long( bean[i].getTaskId() ) );  
51.        PreparedStatement ps = JDBC.execStatementValues( con, update, m );  
52.        ps.executeUpdate();  
53.        con.close();  
54.        map = new JobDataMap();  
55.        map.put( "TASK_ID", new Long( bean[i].getTaskId() ) );//这里把任务ID放到map里面，用于记录执行日志的时候使用。  
56.        if( bean[i].getParms() != null && !bean[i].getParms().equals( "" ) ){  
57.            
58.          /******************把业务系统配置的变量读出来,放到job的上下文里面**/ 
59.          SAXReader saxReader = new SAXReader();  
60.          Document document = saxReader.read( new ByteArrayInputStream( ("<root>" + bean[i].getParms() + "</root>").getBytes() ) );  
61.          List l = document.selectNodes( "/root/item" );  
62.          Iterator iter = l.iterator();  
63.          while (iter.hasNext()){  
64.            Element element = (Element) iter.next();  
65.            Iterator iterator = element.elementIterator( "key" );  
66.            String key = "";  
67.            String value = "";  
68.            while (iterator.hasNext()){  
69.              key = ((Element) iterator.next()).getTextTrim();  
70.            }  
71.            iterator = element.elementIterator( "value" );  
72.            while (iterator.hasNext()){  
73.              value = ((Element) iterator.next()).getTextTrim();  
74.            }  
75.            map.put( key, value );  
76.          }  
77.        }  
78.        /******************把业务系统配置的变量读出来**/ 
79.        try{  
80.        /******************把老的任务给停止，然后删除**/ 
81.        inScheduler.unscheduleJob( bean[i].getTaskCode() + "trigger", bean[i].getTaskType() + "trigger" );  
82.        inScheduler.deleteJob( bean[i].getTaskCode(), bean[i].getTaskType() );  
83.        /******************把老的任务给停止，然后删除**/ 
84.        } catch(Exception e){  
85.          //这里如果是在运行过程中，添加新的任务，而不是修改任务，这里会出错的噢，你说对不对，新加的任务怎么能删除呢？呵呵。  
86.        }  
87.        /******************重新添加任务**/ 
88.        job = new JobDetail( bean[i].getTaskCode(), bean[i].getTaskType(), Class.forName( bean[i].getTaskImplClass() ) );  
89.        job.setJobDataMap( map );  
90.        trigger = new CronTrigger( bean[i].getTaskCode() + "trigger", bean[i].getTaskType() + "trigger", bean[i].getTaskCode(), bean[i]  
91.          .getTaskType(), bean[i].getTaskExpress() );  
92.        inScheduler.addJob( job, true );  
93.        inScheduler.scheduleJob( trigger );  
94.        /******************重新添加任务**/ 
95.      }  
96.    }catch( Exception e ){  
97.      e.printStackTrace();  
98.    }  
99. 
100.  }  
101. 
102.} 
package net.chinacsharp.jdf.quartz;

import java.io.ByteArrayInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;

/**
* 这只是一个简单的JOB而已，名字貌似很NB，这个任务用于实时的检测任务列表的状态，用于更新JOB。
* 这样你改了个配置，可以立马生效的噢。
* 这个类用于在JOB运行期间，使得修改立马生效。
* @author keyboardsun
*
*/
public class JobEngine
    implements Job{

  public void execute( JobExecutionContext arg0 ) throws JobExecutionException{

    try{
      Scheduler inScheduler = arg0.getScheduler();
      JobDetail job = null;
      JobDataMap map = null;
      CronTrigger trigger = null;
      /**
       * 这里根据状态U使用的，以及STATE_DATE日期大于当前日期，判断这个任务是刚更新的，如果你想使得修改的JOB立马生效。你需要吧JOB_TASK的字段的值改得大于当前日期，那样这里就会更新到了噢。
       */     
      JobTaskBean[] bean = JDBC.getJobTaskBean( "SELECT * FROM JOB_TASK WHERE STATE='U' AND STATE_DATE>now()", new HashMap() );
      if( bean == null )
        return;
      for( int i = 0; i < bean.length; i++ ){
        //这里使得修改的job更新，为了避免重复更新，需要吧STATE_DATE日期改过来。
        String update = "UPDATE JOB_TASK SET STATE_DATE=now() WHERE TASK_ID=:TASK_ID";
        Connection con = JDBC.getConnection();
        HashMap m = new HashMap();
        m.put( "TASK_ID", new Long( bean[i].getTaskId() ) );
        PreparedStatement ps = JDBC.execStatementValues( con, update, m );
        ps.executeUpdate();
        con.close();
        map = new JobDataMap();
        map.put( "TASK_ID", new Long( bean[i].getTaskId() ) );//这里把任务ID放到map里面，用于记录执行日志的时候使用。
        if( bean[i].getParms() != null && !bean[i].getParms().equals( "" ) ){
         
          /******************把业务系统配置的变量读出来,放到job的上下文里面**/
          SAXReader saxReader = new SAXReader();
          Document document = saxReader.read( new ByteArrayInputStream( ("<root>" + bean[i].getParms() + "</root>").getBytes() ) );
          List l = document.selectNodes( "/root/item" );
          Iterator iter = l.iterator();
          while (iter.hasNext()){
            Element element = (Element) iter.next();
            Iterator iterator = element.elementIterator( "key" );
            String key = "";
            String value = "";
            while (iterator.hasNext()){
              key = ((Element) iterator.next()).getTextTrim();
            }
            iterator = element.elementIterator( "value" );
            while (iterator.hasNext()){
              value = ((Element) iterator.next()).getTextTrim();
            }
            map.put( key, value );
          }
        }
        /******************把业务系统配置的变量读出来**/
        try{
        /******************把老的任务给停止，然后删除**/
        inScheduler.unscheduleJob( bean[i].getTaskCode() + "trigger", bean[i].getTaskType() + "trigger" );
        inScheduler.deleteJob( bean[i].getTaskCode(), bean[i].getTaskType() );
        /******************把老的任务给停止，然后删除**/
        } catch(Exception e){
          //这里如果是在运行过程中，添加新的任务，而不是修改任务，这里会出错的噢，你说对不对，新加的任务怎么能删除呢？呵呵。
        }
        /******************重新添加任务**/
        job = new JobDetail( bean[i].getTaskCode(), bean[i].getTaskType(), Class.forName( bean[i].getTaskImplClass() ) );
        job.setJobDataMap( map );
        trigger = new CronTrigger( bean[i].getTaskCode() + "trigger", bean[i].getTaskType() + "trigger", bean[i].getTaskCode(), bean[i]
          .getTaskType(), bean[i].getTaskExpress() );
        inScheduler.addJob( job, true );
        inScheduler.scheduleJob( trigger );
        /******************重新添加任务**/
      }
    }catch( Exception e ){
      e.printStackTrace();
    }

  }

}


JobTaskBean.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.sql.Timestamp;  
04. 
05.public class JobTaskBean{  
06.  private long taskId = -1;  
07.  private String taskCode = "";  
08.  private String taskType = "";  
09.  private String taskImplClass = "";  
10.  private String taskExpress = "";  
11.  private Timestamp stateDate = null;  
12.  private String state = "";  
13.  private String parms = "";  
14.  private String remark = "";  
15.  private Timestamp createDate = null;  
16. 
17.  public Timestamp getCreateDate(){  
18.    return createDate;  
19.  }  
20. 
21.  public String getParms(){  
22.    return parms;  
23.  }  
24. 
25.  public String getRemark(){  
26.    return remark;  
27.  }  
28. 
29.  public String getState(){  
30.    return state;  
31.  }  
32. 
33.  public Timestamp getStateDate(){  
34.    return stateDate;  
35.  }  
36. 
37.  public String getTaskCode(){  
38.    return taskCode;  
39.  }  
40. 
41.  public String getTaskExpress(){  
42.    return taskExpress;  
43.  }  
44. 
45.  public long getTaskId(){  
46.    return taskId;  
47.  }  
48. 
49.  public String getTaskImplClass(){  
50.    return taskImplClass;  
51.  }  
52. 
53.  public String getTaskType(){  
54.    return taskType;  
55.  }  
56. 
57.  public void setCreateDate( Timestamp createDate ){  
58.    this.createDate = createDate;  
59.  }  
60. 
61.  public void setParms( String parms ){  
62.    this.parms = parms;  
63.  }  
64. 
65.  public void setRemark( String remark ){  
66.    this.remark = remark;  
67.  }  
68. 
69.  public void setState( String state ){  
70.    this.state = state;  
71.  }  
72. 
73.  public void setStateDate( Timestamp stateDate ){  
74.    this.stateDate = stateDate;  
75.  }  
76. 
77.  public void setTaskCode( String taskCode ){  
78.    this.taskCode = taskCode;  
79.  }  
80. 
81.  public void setTaskExpress( String taskExpress ){  
82.    this.taskExpress = taskExpress;  
83.  }  
84. 
85.  public void setTaskId( long taskId ){  
86.    this.taskId = taskId;  
87.  }  
88. 
89.  public void setTaskImplClass( String taskImplClass ){  
90.    this.taskImplClass = taskImplClass;  
91.  }  
92. 
93.  public void setTaskType( String taskType ){  
94.    this.taskType = taskType;  
95.  }  
96. 
97.} 
package net.chinacsharp.jdf.quartz;

import java.sql.Timestamp;

public class JobTaskBean{
  private long taskId = -1;
  private String taskCode = "";
  private String taskType = "";
  private String taskImplClass = "";
  private String taskExpress = "";
  private Timestamp stateDate = null;
  private String state = "";
  private String parms = "";
  private String remark = "";
  private Timestamp createDate = null;

  public Timestamp getCreateDate(){
    return createDate;
  }

  public String getParms(){
    return parms;
  }

  public String getRemark(){
    return remark;
  }

  public String getState(){
    return state;
  }

  public Timestamp getStateDate(){
    return stateDate;
  }

  public String getTaskCode(){
    return taskCode;
  }

  public String getTaskExpress(){
    return taskExpress;
  }

  public long getTaskId(){
    return taskId;
  }

  public String getTaskImplClass(){
    return taskImplClass;
  }

  public String getTaskType(){
    return taskType;
  }

  public void setCreateDate( Timestamp createDate ){
    this.createDate = createDate;
  }

  public void setParms( String parms ){
    this.parms = parms;
  }

  public void setRemark( String remark ){
    this.remark = remark;
  }

  public void setState( String state ){
    this.state = state;
  }

  public void setStateDate( Timestamp stateDate ){
    this.stateDate = stateDate;
  }

  public void setTaskCode( String taskCode ){
    this.taskCode = taskCode;
  }

  public void setTaskExpress( String taskExpress ){
    this.taskExpress = taskExpress;
  }

  public void setTaskId( long taskId ){
    this.taskId = taskId;
  }

  public void setTaskImplClass( String taskImplClass ){
    this.taskImplClass = taskImplClass;
  }

  public void setTaskType( String taskType ){
    this.taskType = taskType;
  }

}


Mouse.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.io.ByteArrayInputStream;  
04.import java.util.Collection;  
05.import java.util.Date;  
06.import java.util.HashMap;  
07.import java.util.Iterator;  
08.import java.util.List;  
09. 
10.import org.apache.commons.configuration.XMLConfiguration;  
11.import org.dom4j.Document;  
12.import org.dom4j.Element;  
13.import org.dom4j.io.SAXReader;  
14.import org.quartz.CronTrigger;  
15.import org.quartz.JobDataMap;  
16.import org.quartz.JobDetail;  
17.import org.quartz.Scheduler;  
18.import org.quartz.SchedulerFactory;  
19.import org.quartz.impl.StdSchedulerFactory;  
20./** 
21. * 入口类啊，业务系统如果需要启动的job引擎的话， 
22. * 只需要调用这个类的run接口就行了。 
23. * 简单无比。 
24. * @author keyboardsun 
25. * 
26. */ 
27.public class Mouse{  
28. 
29.  public static void run() throws Exception{  
30.    SchedulerFactory sf = new StdSchedulerFactory();  
31.    Scheduler sched = sf.getScheduler();  
32.    JobDetail job = null;  
33.    JobDataMap map=null;  
34.    CronTrigger trigger =null;  
35.    /** 
36.     把所有需要处理的启动的任务读出来噢。根据状态。 
37.     */ 
38.    JobTaskBean[] bean = JDBC.getJobTaskBean("SELECT * FROM JOB_TASK WHERE STATE='U'",new HashMap());  
39.    if(bean==null)return;  
40.    for( int i = 0; i < bean.length; i++ ){  
41.      map = new JobDataMap();      
42.      map.put("TASK_ID",new Long(bean[i].getTaskId()));//这里把任务ID放到map里面，用于记录执行日志的时候使用。  
43.      /****************把JOB_TASK表的配置的变量传入JOB引擎***********************/ 
44.      if(bean[i].getParms()!=null&&!bean[i].getParms().equals("")){  
45.        SAXReader saxReader = new SAXReader();  
46.        Document document = saxReader  
47.          .read(new ByteArrayInputStream( ("<root>"+bean[i].getParms()+"</root>").getBytes()) );  
48.        List l = document.selectNodes( "/root/item" );  
49.        Iterator iter = l.iterator();  
50.        while (iter.hasNext()){  
51.          Element element = (Element) iter.next();  
52.          Iterator iterator = element.elementIterator( "key" );  
53.          String key="";  
54.          String value="";  
55.          while (iterator.hasNext()){  
56.            key = ((Element) iterator.next()).getTextTrim();          
57.          }  
58.          iterator = element.elementIterator( "value" );  
59.          while (iterator.hasNext()){  
60.            value = ((Element) iterator.next()).getTextTrim();  
61.          }  
62.          map.put(key,value);  
63.        }          
64.      }     
65.      /****************把JOB_TASK表的配置的变量传入JOB引擎***********************/ 
66.      job = new JobDetail(bean[i].getTaskCode(),bean[i].getTaskType(), Class.forName(bean[i].getTaskImplClass()));  
67.      job.setJobDataMap(map);  
68.      trigger = new CronTrigger(bean[i].getTaskCode()+"trigger", bean[i].getTaskType()+"trigger", bean[i].getTaskCode(),  
69.        bean[i].getTaskType(),bean[i].getTaskExpress() );  
70.      sched.addJob(job, true);  
71.      sched.scheduleJob(trigger);  
72.    }     
73.    //启动咯。开始  
74.    sched.start();  
75.  }  
76.    
77.  public static void main(String args[]) throws Exception{  
78.    run();  
79.  }  
80. 
81.} 
package net.chinacsharp.jdf.quartz;

import java.io.ByteArrayInputStream;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.configuration.XMLConfiguration;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
/**
* 入口类啊，业务系统如果需要启动的job引擎的话，
* 只需要调用这个类的run接口就行了。
* 简单无比。
* @author keyboardsun
*
*/
public class Mouse{

  public static void run() throws Exception{
    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();
    JobDetail job = null;
    JobDataMap map=null;
    CronTrigger trigger =null;
    /**
     把所有需要处理的启动的任务读出来噢。根据状态。
     */
    JobTaskBean[] bean = JDBC.getJobTaskBean("SELECT * FROM JOB_TASK WHERE STATE='U'",new HashMap());
    if(bean==null)return;
    for( int i = 0; i < bean.length; i++ ){
      map = new JobDataMap();   
      map.put("TASK_ID",new Long(bean[i].getTaskId()));//这里把任务ID放到map里面，用于记录执行日志的时候使用。
      /****************把JOB_TASK表的配置的变量传入JOB引擎***********************/
      if(bean[i].getParms()!=null&&!bean[i].getParms().equals("")){
        SAXReader saxReader = new SAXReader();
        Document document = saxReader
          .read(new ByteArrayInputStream( ("<root>"+bean[i].getParms()+"</root>").getBytes()) );
        List l = document.selectNodes( "/root/item" );
        Iterator iter = l.iterator();
        while (iter.hasNext()){
          Element element = (Element) iter.next();
          Iterator iterator = element.elementIterator( "key" );
          String key="";
          String value="";
          while (iterator.hasNext()){
            key = ((Element) iterator.next()).getTextTrim();       
          }
          iterator = element.elementIterator( "value" );
          while (iterator.hasNext()){
            value = ((Element) iterator.next()).getTextTrim();
          }
          map.put(key,value);
        }       
      }  
      /****************把JOB_TASK表的配置的变量传入JOB引擎***********************/
      job = new JobDetail(bean[i].getTaskCode(),bean[i].getTaskType(), Class.forName(bean[i].getTaskImplClass()));
      job.setJobDataMap(map);
      trigger = new CronTrigger(bean[i].getTaskCode()+"trigger", bean[i].getTaskType()+"trigger", bean[i].getTaskCode(),
        bean[i].getTaskType(),bean[i].getTaskExpress() );
      sched.addJob(job, true);
      sched.scheduleJob(trigger);
    }  
    //启动咯。开始
    sched.start();
  }
 
  public static void main(String args[]) throws Exception{
    run();
  }

}



Task.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.sql.Connection;  
04.import java.sql.PreparedStatement;  
05.import java.util.HashMap;  
06.import java.util.Iterator;  
07. 
08.import org.quartz.Job;  
09.import org.quartz.JobDataMap;  
10.import org.quartz.JobExecutionContext;  
11.import org.quartz.JobExecutionException;  
12. 
13./** 
14. * 这个类是用来包装一下JOB接口的，用于记录日志用的噢，呵呵。 
15. * @author keyboardsun 
16. * 
17. */ 
18.public abstract class Task  
19.    implements ITask,Job{  
20. 
21.  /** 
22.   * 这个类是用来记录日志用的噢，呵呵。 
23.   * 如果你嫌弃这样的实现不爽，那你可以用个监听器，很简单的。 
24.   * 通过实现下面的这两个方法，同样可以实现这样的效果，不过个人觉得，没我搞的这么透明，用着爽。 
25.   *  
26.   * public void jobToBeExecuted(JobExecutionContext inContext)这个监听方法是任务执行前 //只需要把任务信息放到JobDataMap里面，这里获取搞就行了 
27.   * public void jobWasExecuted(JobExecutionContext inContext, 
28.            JobExecutionException inException) 这个监听方法是任务执行后 
29.            唯一的缺点是异常了，貌似不好记录。 
30.   * @param arg0 
31.   * @throws JobExecutionException 
32.   */ 
33.  public void execute( JobExecutionContext arg0 ) throws JobExecutionException{  
34.    TaskLogBean b = null;  
35.    try{  
36.      HashMap map = new HashMap();  
37.      JobDataMap qzMap = arg0.getJobDetail().getJobDataMap();  
38.      Iterator i = qzMap.keySet().iterator();  
39.      while (i.hasNext()){  
40.        Object key = i.next();  
41.        map.put( key, qzMap.get( key ) );  
42.      }  
43.      //任务执行前，先记录个日志噢。   
44.      String insert = "INSERT INTO TASK_LOG(TASK_LOG_ID,TASK_ID,REMARKS,START_DATE,STATE) VALUES(:TASK_LOG_ID , :TASK_ID , '执行中' , now() , 'R' )";  
45.      HashMap clumMap = new HashMap();  
46.      clumMap.put( "TASK_ID", map.get( "TASK_ID" ) );  
47.      b = JDBC.insert( insert, clumMap );  
48.      execute( map ); //任务执行啦，执行啦  
49.      Connection con = JDBC.getConnection();  
50.      //执行完成更新下任务日志  
51.      String sql = "UPDATE TASK_LOG SET STATE='O',REMARKS='执行完成',FINISH_DATE=now() WHERE TASK_LOG_ID=:TASK_LOG_ID ";  
52.      HashMap m = new HashMap();  
53.      m.put( "TASK_LOG_ID", new Long( b.getTaskLogId() ) );  
54.      PreparedStatement ps = JDBC.execStatementValues( con, sql, m );  
55.      ps.executeUpdate();  
56.      con.close();  
57.    }catch( Exception e ){  
58.      e.printStackTrace();  
59.      Connection con;  
60.      try{  
61.        //异常了，更新下任务日志，说明是一场的  
62.        con = JDBC.getConnection();  
63.        String sql = "UPDATE TASK_LOG SET STATE='E',FINISH_DATE=now(),REMARKS=:REMARKS WHERE TASK_LOG_ID=:TASK_LOG_ID ";  
64.        HashMap m = new HashMap();  
65.        m.put( "TASK_LOG_ID", new Long( b.getTaskLogId() ) );  
66.        m.put( "REMARKS", e.getMessage() ); //这里可以把堆栈放进去，我这里就省略了，简单搞搞而已，后期需要增强  
67.        PreparedStatement ps = JDBC.execStatementValues( con, sql, m );  
68.        ps.executeUpdate();  
69.        con.close();  
70.      }catch( Exception e1 ){  
71.        e1.printStackTrace();  
72.      }  
73. 
74.    }  
75. 
76.  }  
77. 
78.} 
package net.chinacsharp.jdf.quartz;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.HashMap;
import java.util.Iterator;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
* 这个类是用来包装一下JOB接口的，用于记录日志用的噢，呵呵。
* @author keyboardsun
*
*/
public abstract class Task
    implements ITask,Job{

  /**
   * 这个类是用来记录日志用的噢，呵呵。
   * 如果你嫌弃这样的实现不爽，那你可以用个监听器，很简单的。
   * 通过实现下面的这两个方法，同样可以实现这样的效果，不过个人觉得，没我搞的这么透明，用着爽。
   *
   * public void jobToBeExecuted(JobExecutionContext inContext)这个监听方法是任务执行前 //只需要把任务信息放到JobDataMap里面，这里获取搞就行了
   * public void jobWasExecuted(JobExecutionContext inContext,
            JobExecutionException inException) 这个监听方法是任务执行后
            唯一的缺点是异常了，貌似不好记录。
   * @param arg0
   * @throws JobExecutionException
   */
  public void execute( JobExecutionContext arg0 ) throws JobExecutionException{
    TaskLogBean b = null;
    try{
      HashMap map = new HashMap();
      JobDataMap qzMap = arg0.getJobDetail().getJobDataMap();
      Iterator i = qzMap.keySet().iterator();
      while (i.hasNext()){
        Object key = i.next();
        map.put( key, qzMap.get( key ) );
      }
      //任务执行前，先记录个日志噢。
      String insert = "INSERT INTO TASK_LOG(TASK_LOG_ID,TASK_ID,REMARKS,START_DATE,STATE) VALUES(:TASK_LOG_ID , :TASK_ID , '执行中' , now() , 'R' )";
      HashMap clumMap = new HashMap();
      clumMap.put( "TASK_ID", map.get( "TASK_ID" ) );
      b = JDBC.insert( insert, clumMap );
      execute( map ); //任务执行啦，执行啦
      Connection con = JDBC.getConnection();
      //执行完成更新下任务日志
      String sql = "UPDATE TASK_LOG SET STATE='O',REMARKS='执行完成',FINISH_DATE=now() WHERE TASK_LOG_ID=:TASK_LOG_ID ";
      HashMap m = new HashMap();
      m.put( "TASK_LOG_ID", new Long( b.getTaskLogId() ) );
      PreparedStatement ps = JDBC.execStatementValues( con, sql, m );
      ps.executeUpdate();
      con.close();
    }catch( Exception e ){
      e.printStackTrace();
      Connection con;
      try{
        //异常了，更新下任务日志，说明是一场的
        con = JDBC.getConnection();
        String sql = "UPDATE TASK_LOG SET STATE='E',FINISH_DATE=now(),REMARKS=:REMARKS WHERE TASK_LOG_ID=:TASK_LOG_ID ";
        HashMap m = new HashMap();
        m.put( "TASK_LOG_ID", new Long( b.getTaskLogId() ) );
        m.put( "REMARKS", e.getMessage() ); //这里可以把堆栈放进去，我这里就省略了，简单搞搞而已，后期需要增强
        PreparedStatement ps = JDBC.execStatementValues( con, sql, m );
        ps.executeUpdate();
        con.close();
      }catch( Exception e1 ){
        e1.printStackTrace();
      }

    }

  }

}


TaskLogBean.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.sql.Timestamp;  
04./** 
05. * TASK_LOG 任务日志表对应的Bean 
06. * @author keyboardsun 
07. * 
08. */ 
09.public class TaskLogBean{  
10.  private long taskLogId=-1;  
11.  private long taskId=-1;  
12.  private String state="";  
13.  private Timestamp startDate=null;  
14.  private Timestamp finishDate=null;  
15.  private String remarks="";  
16.  public Timestamp getFinishDate(){  
17.    return finishDate;  
18.  }  
19.  public String getRemarks(){  
20.    return remarks;  
21.  }  
22.  public Timestamp getStartDate(){  
23.    return startDate;  
24.  }  
25.  public String getState(){  
26.    return state;  
27.  }  
28.  public long getTaskId(){  
29.    return taskId;  
30.  }  
31.  public long getTaskLogId(){  
32.    return taskLogId;  
33.  }  
34.  public void setFinishDate( Timestamp finishDate ){  
35.    this.finishDate = finishDate;  
36.  }  
37.  public void setRemarks( String remarks ){  
38.    this.remarks = remarks;  
39.  }  
40.  public void setStartDate( Timestamp startDate ){  
41.    this.startDate = startDate;  
42.  }  
43.  public void setState( String state ){  
44.    this.state = state;  
45.  }  
46.  public void setTaskId( long taskId ){  
47.    this.taskId = taskId;  
48.  }  
49.  public void setTaskLogId( long taskLogId ){  
50.    this.taskLogId = taskLogId;  
51.  }  
52. 
53.} 
package net.chinacsharp.jdf.quartz;

import java.sql.Timestamp;
/**
* TASK_LOG 任务日志表对应的Bean
* @author keyboardsun
*
*/
public class TaskLogBean{
  private long taskLogId=-1;
  private long taskId=-1;
  private String state="";
  private Timestamp startDate=null;
  private Timestamp finishDate=null;
  private String remarks="";
  public Timestamp getFinishDate(){
    return finishDate;
  }
  public String getRemarks(){
    return remarks;
  }
  public Timestamp getStartDate(){
    return startDate;
  }
  public String getState(){
    return state;
  }
  public long getTaskId(){
    return taskId;
  }
  public long getTaskLogId(){
    return taskLogId;
  }
  public void setFinishDate( Timestamp finishDate ){
    this.finishDate = finishDate;
  }
  public void setRemarks( String remarks ){
    this.remarks = remarks;
  }
  public void setStartDate( Timestamp startDate ){
    this.startDate = startDate;
  }
  public void setState( String state ){
    this.state = state;
  }
  public void setTaskId( long taskId ){
    this.taskId = taskId;
  }
  public void setTaskLogId( long taskLogId ){
    this.taskLogId = taskLogId;
  }

}


Test.java

view plaincopy to clipboardprint?
01.package net.chinacsharp.jdf.quartz;  
02. 
03.import java.util.HashMap;  
04.import java.util.Iterator;  
05. 
06./** 
07. * 一个测试任务噢。 
08. * 一个测试的任务，用于测试使用，呵呵。 
09. * @author keyboardsun 
10. * 
11. */ 
12.public class Test  
13.    extends Task{  
14. 
15.  public void execute( HashMap map ){  
16.    try{  
17.      Thread.sleep(2000);  
18.      System.out.println("****************************************");  
19.      System.out.println("执行任务id:"+map.get("TASK_ID"));  
20.      System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");  
21.    }catch( InterruptedException e ){  
22.    }  
23.  }  
24. 
25.} 
package net.chinacsharp.jdf.quartz;

import java.util.HashMap;
import java.util.Iterator;

/**
* 一个测试任务噢。
* 一个测试的任务，用于测试使用，呵呵。
* @author keyboardsun
*
*/
public class Test
    extends Task{

  public void execute( HashMap map ){
    try{
      Thread.sleep(2000);
      System.out.println("****************************************");
      System.out.println("执行任务id:"+map.get("TASK_ID"));
      System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
    }catch( InterruptedException e ){
    }
  }

}


下面我们在数据库里面添加两条任务。

INSERT INTO `job_task` VALUES ('1', 'TEST1', 'G1', 'net.chinacsharp.jdf.quartz.Test', '0/25 * * * * ?', '2009-07-09 16:48:00', 'U', '<item><key>sss</key><value>vvv</value></item><item><key>ss</key><value>vv</value></item>', null, '2009-07-07 16:07:41');
INSERT INTO `job_task` VALUES ('2', 'TEST2', 'G1', 'net.chinacsharp.jdf.quartz.Test', '0/20 * * * * ?', '2009-07-09 17:19:21', 'U', '<item><key>sss</key><value>vvv</value></item><item><key>ss</key><value>vv</value></item>', null, '2009-07-08 16:07:20');
INSERT INTO `job_task` VALUES ('3', 'TESTENGINE', 'ENG', 'net.chinacsharp.jdf.quartz.JobEngine', '0/7 * * * * ?', '2009-07-09 16:48:00', 'U', '<item><key>sss</key><value>vvv</value></item><item><key>ss</key><value>vv</value></item>', null, '2009-07-07 16:07:41');



这里的第三条任务是必须的。用于扫描JOB_TASK表的改动，及时把改动的部分覆盖到现有执行中的任务。

下面我们运行任务

view plaincopy to clipboardprint?
01.public static void main(String args[]) throws Exception{  
02.  Mouse.run();  
03.} 
  public static void main(String args[]) throws Exception{
    Mouse.run();
  }

我们查看日志信息

view plaincopy to clipboardprint?
01.[2009-07-09 20:15:20,000] [DefaultQuartzScheduler_Worker-3] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST2  
02.[2009-07-09 20:15:21,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine  
03.[2009-07-09 20:15:21,000] [DefaultQuartzScheduler_Worker-4] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE  
04.****************************************  
05.执行任务id:2 
06.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<  
07.[2009-07-09 20:15:25,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'G1.TEST1', class=net.chinacsharp.jdf.quartz.Test  
08.[2009-07-09 20:15:25,000] [DefaultQuartzScheduler_Worker-5] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST1  
09.****************************************  
10.执行任务id:1 
11.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<  
12.[2009-07-09 20:15:28,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine  
13.[2009-07-09 20:15:28,000] [DefaultQuartzScheduler_Worker-6] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE  
14.[2009-07-09 20:15:35,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine  
15.[2009-07-09 20:15:35,000] [DefaultQuartzScheduler_Worker-7] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE  
16.[2009-07-09 20:15:40,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'G1.TEST2', class=net.chinacsharp.jdf.quartz.Test  
17.[2009-07-09 20:15:40,000] [DefaultQuartzScheduler_Worker-8] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST2  
18.[2009-07-09 20:15:42,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine  
19.[2009-07-09 20:15:42,000] [DefaultQuartzScheduler_Worker-9] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE  
20.****************************************  
21.执行任务id:2 
22.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<  
23.[2009-07-09 20:15:49,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine  
24.[2009-07-09 20:15:49,000] [DefaultQuartzScheduler_Worker-10] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE  
25.[2009-07-09 20:15:50,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'G1.TEST1', class=net.chinacsharp.jdf.quartz.Test  
26.[2009-07-09 20:15:50,000] [DefaultQuartzScheduler_Worker-1] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST1  
27.****************************************  
28.执行任务id:1 
29.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 
[2009-07-09 20:15:20,000] [DefaultQuartzScheduler_Worker-3] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST2
[2009-07-09 20:15:21,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine
[2009-07-09 20:15:21,000] [DefaultQuartzScheduler_Worker-4] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE
****************************************
执行任务id:2
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
[2009-07-09 20:15:25,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'G1.TEST1', class=net.chinacsharp.jdf.quartz.Test
[2009-07-09 20:15:25,000] [DefaultQuartzScheduler_Worker-5] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST1
****************************************
执行任务id:1
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
[2009-07-09 20:15:28,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine
[2009-07-09 20:15:28,000] [DefaultQuartzScheduler_Worker-6] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE
[2009-07-09 20:15:35,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine
[2009-07-09 20:15:35,000] [DefaultQuartzScheduler_Worker-7] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job ENG.TESTENGINE
[2009-07-09 20:15:40,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'G1.TEST2', class=net.chinacsharp.jdf.quartz.Test
[2009-07-09 20:15:40,000] [DefaultQuartzScheduler_Worker-8] (JobRunShell.java:201) DEBUG org.quartz.core.JobRunShell - Calling execute on job G1.TEST2
[2009-07-09 20:15:42,000] [DefaultQuartzScheduler_QuartzSchedulerThread] (SimpleJobFactory.java:50) DEBUG org.quartz.simpl.SimpleJobFactory - Producing instance of Job 'ENG.TESTENGINE', class=net.chinacsharp.jdf.quartz.JobEngine
[2009-07-09 20:15:42,000