Quartz存储与持久化--mysql--建表

Quartz存储与持久化--mysql--建表

        <p>Quartz提供两种基本作业存储类型。</p>

第一种类型叫做RAMJobStore。

第二种类型叫做JDBC作业存储。

在默认情况下Quartz将任务调度的运行信息保存在内存中,这种方法提供了最佳的性能,因为内存中数据访问最快。不足之处是缺乏数据的持久性,当程序路途停止或系统崩溃时,所有运行的信息都会丢失。

         比如我们希望安排一个执行100次的任务,如果执行到50次时系统崩溃了,系统重启时任务的执行计数器将从0开始。在大多数实际的应用中,我们往往并不需要保存任务调度的现场数据,因为很少需要规划一个指定执行次数的任务。对于仅执行一次的任务来说,其执行条件信息本身应该是已经持久化的业务数据(如锁定到期解锁任务,解锁的时间应该是业务数据),当执行完成后,条件信息也会相应改变。当然调度现场信息不仅仅是记录运行次数,还包括调度规则、JobDataMap中的数据等等。

        如果确实需要持久化任务调度信息,Quartz允许你通过调整其属性文件,将这些信息保存到数据库中。使用数据库保存任务调度信息后,即使系统崩溃后重新启动,任务的调度信息将得到恢复。如前面所说的例子,执行50次崩溃后重新运行,计数器将从51开始计数。使用了数据库保存信息的任务称为持久化任务。

对比

类型

优点

缺点

RAMJobStore

不要外部数据库,配置容易,运行速度快

因为调度程序信息是存储在被分配给JVM的内存里面,所以,当应用程序停止运行时,所有调度信息将被丢失。另外因为存储到JVM内存里面,所以可以存储多少个Job和Trigger将会受到限制

JDBC作业存储

支持集群,因为所有的任务信息都会保存到数据库中,可以控制事物,还有就是如果应用服务器关闭或者重启,任务信息都不会丢失,并且可以恢复因服务器关闭或者重启而导致执行失败的任务

运行速度的快慢取决与连接数据库的快慢

 1:建立数据存储表

因为需要把quartz的数据保存到数据库,所以要建立相关的数据库。这个可以从下载到的quartz包里面找到对应的sql脚本,目前可以支持mysql,DB2,oracle等主流的数据库,自己可以根据项目需要选择合适的脚本运行。

        我的项目是mysql的,就在数据中建立了一个quartzdb的database,因为我们用的是mysql,所以执行tables_mysql_innodb.sql脚本建表。其中脚本 文件位于:quartz-2.2.3\docs\dbTables(根据你Quartz放置的目录会不同)

2:里面就是quartz框架需要的表,因为我们用到的是mysql数据库,可以看驱动类StdJDBCDelegate.class:

quartz.properties:
# 驱动器方言 mysql驱动
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate

里面也就是jdbc 连接数据库 固定的sql语句、表


 
 
  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5. package org.quartz.impl.jdbcjobstore;
  6. import java.io.ByteArrayInputStream;
  7. import java.io.ByteArrayOutputStream;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.io.NotSerializableException;
  11. import java.io.ObjectInputStream;
  12. import java.io.ObjectOutputStream;
  13. import java.math.BigDecimal;
  14. import java.sql.Blob;
  15. import java.sql.Connection;
  16. import java.sql.PreparedStatement;
  17. import java.sql.ResultSet;
  18. import java.sql.SQLException;
  19. import java.sql.Statement;
  20. import java.util.Date;
  21. import java.util.HashMap;
  22. import java.util.HashSet;
  23. import java.util.Iterator;
  24. import java.util.LinkedList;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.Properties;
  28. import java.util.Set;
  29. import java.util.Map.Entry;
  30. import org.quartz.Calendar;
  31. import org.quartz.Job;
  32. import org.quartz.JobDataMap;
  33. import org.quartz.JobDetail;
  34. import org.quartz.JobKey;
  35. import org.quartz.JobPersistenceException;
  36. import org.quartz.TriggerBuilder;
  37. import org.quartz.TriggerKey;
  38. import org.quartz.impl.JobDetailImpl;
  39. import org.quartz.impl.jdbcjobstore.TriggerPersistenceDelegate.TriggerPropertyBundle;
  40. import org.quartz.impl.matchers.GroupMatcher;
  41. import org.quartz.impl.matchers.StringMatcher.StringOperatorName;
  42. import org.quartz.impl.triggers.SimpleTriggerImpl;
  43. import org.quartz.spi.ClassLoadHelper;
  44. import org.quartz.spi.OperableTrigger;
  45. import org.slf4j.Logger;
  46. public class StdJDBCDelegate implements DriverDelegate, StdJDBCConstants {
  47. protected Logger logger = null;
  48. protected String tablePrefix = "QRTZ_";
  49. protected String instanceId;
  50. protected String schedName;
  51. protected boolean useProperties;
  52. protected ClassLoadHelper classLoadHelper;
  53. protected List<TriggerPersistenceDelegate> triggerPersistenceDelegates = new LinkedList();
  54. private String schedNameLiteral = null;
  55. public StdJDBCDelegate() {
  56. }
  57. public void initialize(Logger logger, String tablePrefix, String schedName, String instanceId, ClassLoadHelper classLoadHelper, boolean useProperties, String initString) throws NoSuchDelegateException {
  58. this.logger = logger;
  59. this.tablePrefix = tablePrefix;
  60. this.schedName = schedName;
  61. this.instanceId = instanceId;
  62. this.useProperties = useProperties;
  63. this.classLoadHelper = classLoadHelper;
  64. this.addDefaultTriggerPersistenceDelegates();
  65. if (initString != null) {
  66. String[] settings = initString.split( "\\|");
  67. String[] arr$ = settings;
  68. int len$ = settings.length;
  69. for( int i$ = 0; i$ < len$; ++i$) {
  70. String setting = arr$[i$];
  71. String[] parts = setting.split( "=");
  72. String name = parts[ 0];
  73. if (parts.length != 1 && parts[ 1] != null && !parts[ 1].equals( "")) {
  74. if (!name.equals( "triggerPersistenceDelegateClasses")) {
  75. throw new NoSuchDelegateException( "Unknown setting: '" + name + "'");
  76. }
  77. String[] trigDelegates = parts[ 1].split( ",");
  78. String[] arr$ = trigDelegates;
  79. int len$ = trigDelegates.length;
  80. for( int i$ = 0; i$ < len$; ++i$) {
  81. String trigDelClassName = arr$[i$];
  82. try {
  83. Class<?> trigDelClass = classLoadHelper.loadClass(trigDelClassName);
  84. this.addTriggerPersistenceDelegate((TriggerPersistenceDelegate)trigDelClass.newInstance());
  85. } catch (Exception var21) {
  86. throw new NoSuchDelegateException( "Error instantiating TriggerPersistenceDelegate of type: " + trigDelClassName, var21);
  87. }
  88. }
  89. }
  90. }
  91. }
  92. }
  93. protected void addDefaultTriggerPersistenceDelegates() {
  94. this.addTriggerPersistenceDelegate( new SimpleTriggerPersistenceDelegate());
  95. this.addTriggerPersistenceDelegate( new CronTriggerPersistenceDelegate());
  96. this.addTriggerPersistenceDelegate( new CalendarIntervalTriggerPersistenceDelegate());
  97. this.addTriggerPersistenceDelegate( new DailyTimeIntervalTriggerPersistenceDelegate());
  98. }
  99. protected boolean canUseProperties() {
  100. return this.useProperties;
  101. }
  102. public void addTriggerPersistenceDelegate(TriggerPersistenceDelegate delegate) {
  103. this.logger.debug( "Adding TriggerPersistenceDelegate of type: " + delegate.getClass().getCanonicalName());
  104. delegate.initialize( this.tablePrefix, this.schedName);
  105. this.triggerPersistenceDelegates.add(delegate);
  106. }
  107. public TriggerPersistenceDelegate findTriggerPersistenceDelegate(OperableTrigger trigger) {
  108. Iterator i$ = this.triggerPersistenceDelegates.iterator();
  109. TriggerPersistenceDelegate delegate;
  110. do {
  111. if (!i$.hasNext()) {
  112. return null;
  113. }
  114. delegate = (TriggerPersistenceDelegate)i$.next();
  115. } while(!delegate.canHandleTriggerType(trigger));
  116. return delegate;
  117. }
  118. public TriggerPersistenceDelegate findTriggerPersistenceDelegate(String discriminator) {
  119. Iterator i$ = this.triggerPersistenceDelegates.iterator();
  120. TriggerPersistenceDelegate delegate;
  121. do {
  122. if (!i$.hasNext()) {
  123. return null;
  124. }
  125. delegate = (TriggerPersistenceDelegate)i$.next();
  126. } while(!delegate.getHandledTriggerTypeDiscriminator().equals(discriminator));
  127. return delegate;
  128. }
  129. public int updateTriggerStatesFromOtherStates(Connection conn, String newState, String oldState1, String oldState2) throws SQLException {
  130. PreparedStatement ps = null;
  131. int var6;
  132. try {
  133. ps = conn.prepareStatement( this.rtp( "UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND (TRIGGER_STATE = ? OR TRIGGER_STATE = ?)"));
  134. ps.setString( 1, newState);
  135. ps.setString( 2, oldState1);
  136. ps.setString( 3, oldState2);
  137. var6 = ps.executeUpdate();
  138. } finally {
  139. closeStatement(ps);
  140. }
  141. return var6;
  142. }
  143. public List<TriggerKey> selectMisfiredTriggers(Connection conn, long ts) throws SQLException {
  144. PreparedStatement ps = null;
  145. ResultSet rs = null;
  146. try {
  147. ps = conn.prepareStatement( this.rtp( "SELECT * FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
  148. ps.setBigDecimal( 1, new BigDecimal(String.valueOf(ts)));
  149. rs = ps.executeQuery();
  150. LinkedList list = new LinkedList();
  151. while(rs.next()) {
  152. String triggerName = rs.getString( "TRIGGER_NAME");
  153. String groupName = rs.getString( "TRIGGER_GROUP");
  154. list.add(TriggerKey.triggerKey(triggerName, groupName));
  155. }
  156. LinkedList var12 = list;
  157. return var12;
  158. } finally {
  159. closeResultSet(rs);
  160. closeStatement(ps);
  161. }
  162. }
  163. public List<TriggerKey> selectTriggersInState(Connection conn, String state) throws SQLException {
  164. PreparedStatement ps = null;
  165. ResultSet rs = null;
  166. try {
  167. ps = conn.prepareStatement( this.rtp( "SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_STATE = ?"));
  168. ps.setString( 1, state);
  169. rs = ps.executeQuery();
  170. LinkedList list = new LinkedList();
  171. while(rs.next()) {
  172. list.add(TriggerKey.triggerKey(rs.getString( 1), rs.getString( 2)));
  173. }
  174. LinkedList var6 = list;
  175. return var6;
  176. } finally {
  177. closeResultSet(rs);
  178. closeStatement(ps);
  179. }
  180. }
  181. public List<TriggerKey> selectMisfiredTriggersInState(Connection conn, String state, long ts) throws SQLException {
  182. PreparedStatement ps = null;
  183. ResultSet rs = null;
  184. try {
  185. ps = conn.prepareStatement( this.rtp( "SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_STATE = ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
  186. ps.setBigDecimal( 1, new BigDecimal(String.valueOf(ts)));
  187. ps.setString( 2, state);
  188. rs = ps.executeQuery();
  189. LinkedList list = new LinkedList();
  190. while(rs.next()) {
  191. String triggerName = rs.getString( "TRIGGER_NAME");
  192. String groupName = rs.getString( "TRIGGER_GROUP");
  193. list.add(TriggerKey.triggerKey(triggerName, groupName));
  194. }
  195. LinkedList var13 = list;
  196. return var13;
  197. } finally {
  198. closeResultSet(rs);
  199. closeStatement(ps);
  200. }
  201. }
  202. public boolean hasMisfiredTriggersInState(Connection conn, String state1, long ts, int count, List<TriggerKey> resultList) throws SQLException {
  203. PreparedStatement ps = null;
  204. ResultSet rs = null;
  205. try {
  206. ps = conn.prepareStatement( this.rtp( "SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_STATE = ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
  207. ps.setBigDecimal( 1, new BigDecimal(String.valueOf(ts)));
  208. ps.setString( 2, state1);
  209. rs = ps.executeQuery();
  210. boolean hasReachedLimit = false;
  211. while(rs.next() && !hasReachedLimit) {
  212. if (resultList.size() == count) {
  213. hasReachedLimit = true;
  214. } else {
  215. String triggerName = rs.getString( "TRIGGER_NAME");
  216. String groupName = rs.getString( "TRIGGER_GROUP");
  217. resultList.add(TriggerKey.triggerKey(triggerName, groupName));
  218. }
  219. }
  220. boolean var15 = hasReachedLimit;
  221. return var15;
  222. } finally {
  223. closeResultSet(rs);
  224. closeStatement(ps);
  225. }
  226. }
  227. public int countMisfiredTriggersInState(Connection conn, String state1, long ts) throws SQLException {
  228. PreparedStatement ps = null;
  229. ResultSet rs = null;
  230. int var7;
  231. try {
  232. ps = conn.prepareStatement( this.rtp( "SELECT COUNT(TRIGGER_NAME) FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_STATE = ?"));
  233. ps.setBigDecimal( 1, new BigDecimal(String.valueOf(ts)));
  234. ps.setString( 2, state1);
  235. rs = ps.executeQuery();
  236. if (!rs.next()) {
  237. throw new SQLException( "No misfired trigger count returned.");
  238. }
  239. var7 = rs.getInt( 1);
  240. } finally {
  241. closeResultSet(rs);
  242. closeStatement(ps);
  243. }
  244. return var7;
  245. }
  246. public List<TriggerKey> selectMisfiredTriggersInGroupInState(Connection conn, String groupName, String state, long ts) throws SQLException {
  247. PreparedStatement ps = null;
  248. ResultSet rs = null;
  249. try {
  250. ps = conn.prepareStatement( this.rtp( "SELECT TRIGGER_NAME FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_GROUP = ? AND TRIGGER_STATE = ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
  251. ps.setBigDecimal( 1, new BigDecimal(String.valueOf(ts)));
  252. ps.setString( 2, groupName);
  253. ps.setString( 3, state);
  254. rs = ps.executeQuery();
  255. LinkedList list = new LinkedList();
  256. while(rs.next()) {
  257. String triggerName = rs.getString( "TRIGGER_NAME");
  258. list.add(TriggerKey.triggerKey(triggerName, groupName));
  259. }
  260. LinkedList var13 = list;
  261. return var13;
  262. } finally {
  263. closeResultSet(rs);
  264. closeStatement(ps);
  265. }
  266. }
  267. public List<OperableTrigger> selectTriggersForRecoveringJobs(Connection conn) throws SQLException, IOException, ClassNotFoundException {
  268. PreparedStatement ps = null;
  269. ResultSet rs = null;
  270. try {
  271. ps = conn.prepareStatement( this.rtp( "SELECT * FROM {0}FIRED_TRIGGERS WHERE SCHED_NAME = {1} AND INSTANCE_NAME = ? AND REQUESTS_RECOVERY = ?"));
  272. ps.setString( 1, this.instanceId);
  273. this.setBoolean(ps, 2, true);
  274. rs = ps.executeQuery();
  275. long dumId = System.currentTimeMillis();
  276. LinkedList list = new LinkedList();
  277. while(rs.next()) {
  278. String jobName = rs.getString( "JOB_NAME");
  279. String jobGroup = rs.getString( "JOB_GROUP");
  280. String trigName = rs.getString( "TRIGGER_NAME");
  281. String trigGroup = rs.getString( "TRIGGER_GROUP");
  282. long firedTime = rs.getLong( "FIRED_TIME");
  283. long scheduledTime = rs.getLong( "SCHED_TIME");
  284. int priority = rs.getInt( "PRIORITY");
  285. SimpleTriggerImpl rcvryTrig = new SimpleTriggerImpl( "recover_" + this.instanceId + "_" + dumId++, "RECOVERING_JOBS", new Date(scheduledTime));
  286. rcvryTrig.setJobName(jobName);
  287. rcvryTrig.setJobGroup(jobGroup);
  288. rcvryTrig.setPriority(priority);
  289. rcvryTrig.setMisfireInstruction(- 1);
  290. JobDataMap jd = this.selectTriggerJobDataMap(conn, trigName, trigGroup);
  291. jd.put( "QRTZ_FAILED_JOB_ORIG_TRIGGER_NAME", trigName);
  292. jd.put( "QRTZ_FAILED_JOB_ORIG_TRIGGER_GROUP", trigGroup);
  293. jd.put( "QRTZ_FAILED_JOB_ORIG_TRIGGER_FIRETIME_IN_MILLISECONDS_AS_STRING", String.valueOf(firedTime));
  294. jd.put( "QRTZ_FAILED_JOB_ORIG_TRIGGER_SCHEDULED_FIRETIME_IN_MILLISECONDS_AS_STRING", String.valueOf(scheduledTime));
  295. rcvryTrig.setJobDataMap(jd);
  296. list.add(rcvryTrig);
  297. }
  298. LinkedList var21 = list;
  299. return var21;
  300. } finally {
  301. closeResultSet(rs);
  302. closeStatement(ps);
  303. }
  304. }
  305. public int deleteFiredTriggers(Connection conn) throws SQLException {
  306. PreparedStatement ps = null;
  307. int var3;
  308. try {
  309. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}FIRED_TRIGGERS WHERE SCHED_NAME = {1}"));
  310. var3 = ps.executeUpdate();
  311. } finally {
  312. closeStatement(ps);
  313. }
  314. return var3;
  315. }
  316. public int deleteFiredTriggers(Connection conn, String theInstanceId) throws SQLException {
  317. PreparedStatement ps = null;
  318. int var4;
  319. try {
  320. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}FIRED_TRIGGERS WHERE SCHED_NAME = {1} AND INSTANCE_NAME = ?"));
  321. ps.setString( 1, theInstanceId);
  322. var4 = ps.executeUpdate();
  323. } finally {
  324. closeStatement(ps);
  325. }
  326. return var4;
  327. }
  328. public void clearData(Connection conn) throws SQLException {
  329. PreparedStatement ps = null;
  330. try {
  331. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}SIMPLE_TRIGGERS WHERE SCHED_NAME = {1}"));
  332. ps.executeUpdate();
  333. ps.close();
  334. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}SIMPROP_TRIGGERS WHERE SCHED_NAME = {1}"));
  335. ps.executeUpdate();
  336. ps.close();
  337. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}CRON_TRIGGERS WHERE SCHED_NAME = {1}"));
  338. ps.executeUpdate();
  339. ps.close();
  340. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}BLOB_TRIGGERS WHERE SCHED_NAME = {1}"));
  341. ps.executeUpdate();
  342. ps.close();
  343. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}TRIGGERS WHERE SCHED_NAME = {1}"));
  344. ps.executeUpdate();
  345. ps.close();
  346. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1}"));
  347. ps.executeUpdate();
  348. ps.close();
  349. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}CALENDARS WHERE SCHED_NAME = {1}"));
  350. ps.executeUpdate();
  351. ps.close();
  352. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}PAUSED_TRIGGER_GRPS WHERE SCHED_NAME = {1}"));
  353. ps.executeUpdate();
  354. } finally {
  355. closeStatement(ps);
  356. }
  357. }
  358. public int insertJobDetail(Connection conn, JobDetail job) throws IOException, SQLException {
  359. ByteArrayOutputStream baos = this.serializeJobData(job.getJobDataMap());
  360. PreparedStatement ps = null;
  361. boolean var5 = false;
  362. int insertResult;
  363. try {
  364. ps = conn.prepareStatement( this.rtp( "INSERT INTO {0}JOB_DETAILS (SCHED_NAME, JOB_NAME, JOB_GROUP, DESCRIPTION, JOB_CLASS_NAME, IS_DURABLE, IS_NONCONCURRENT, IS_UPDATE_DATA, REQUESTS_RECOVERY, JOB_DATA) VALUES({1}, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
  365. ps.setString( 1, job.getKey().getName());
  366. ps.setString( 2, job.getKey().getGroup());
  367. ps.setString( 3, job.getDescription());
  368. ps.setString( 4, job.getJobClass().getName());
  369. this.setBoolean(ps, 5, job.isDurable());
  370. this.setBoolean(ps, 6, job.isConcurrentExectionDisallowed());
  371. this.setBoolean(ps, 7, job.isPersistJobDataAfterExecution());
  372. this.setBoolean(ps, 8, job.requestsRecovery());
  373. this.setBytes(ps, 9, baos);
  374. insertResult = ps.executeUpdate();
  375. } finally {
  376. closeStatement(ps);
  377. }
  378. return insertResult;
  379. }
  380. public int updateJobDetail(Connection conn, JobDetail job) throws IOException, SQLException {
  381. ByteArrayOutputStream baos = this.serializeJobData(job.getJobDataMap());
  382. PreparedStatement ps = null;
  383. boolean var5 = false;
  384. int insertResult;
  385. try {
  386. ps = conn.prepareStatement( this.rtp( "UPDATE {0}JOB_DETAILS SET DESCRIPTION = ?, JOB_CLASS_NAME = ?, IS_DURABLE = ?, IS_NONCONCURRENT = ?, IS_UPDATE_DATA = ?, REQUESTS_RECOVERY = ?, JOB_DATA = ? WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  387. ps.setString( 1, job.getDescription());
  388. ps.setString( 2, job.getJobClass().getName());
  389. this.setBoolean(ps, 3, job.isDurable());
  390. this.setBoolean(ps, 4, job.isConcurrentExectionDisallowed());
  391. this.setBoolean(ps, 5, job.isPersistJobDataAfterExecution());
  392. this.setBoolean(ps, 6, job.requestsRecovery());
  393. this.setBytes(ps, 7, baos);
  394. ps.setString( 8, job.getKey().getName());
  395. ps.setString( 9, job.getKey().getGroup());
  396. insertResult = ps.executeUpdate();
  397. } finally {
  398. closeStatement(ps);
  399. }
  400. return insertResult;
  401. }
  402. public List<TriggerKey> selectTriggerKeysForJob(Connection conn, JobKey jobKey) throws SQLException {
  403. PreparedStatement ps = null;
  404. ResultSet rs = null;
  405. try {
  406. ps = conn.prepareStatement( this.rtp( "SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  407. ps.setString( 1, jobKey.getName());
  408. ps.setString( 2, jobKey.getGroup());
  409. rs = ps.executeQuery();
  410. LinkedList list = new LinkedList();
  411. while(rs.next()) {
  412. String trigName = rs.getString( "TRIGGER_NAME");
  413. String trigGroup = rs.getString( "TRIGGER_GROUP");
  414. list.add(TriggerKey.triggerKey(trigName, trigGroup));
  415. }
  416. LinkedList var11 = list;
  417. return var11;
  418. } finally {
  419. closeResultSet(rs);
  420. closeStatement(ps);
  421. }
  422. }
  423. public int deleteJobDetail(Connection conn, JobKey jobKey) throws SQLException {
  424. PreparedStatement ps = null;
  425. int var4;
  426. try {
  427. if ( this.logger.isDebugEnabled()) {
  428. this.logger.debug( "Deleting job: " + jobKey);
  429. }
  430. ps = conn.prepareStatement( this.rtp( "DELETE FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  431. ps.setString( 1, jobKey.getName());
  432. ps.setString( 2, jobKey.getGroup());
  433. var4 = ps.executeUpdate();
  434. } finally {
  435. closeStatement(ps);
  436. }
  437. return var4;
  438. }
  439. public boolean isJobNonConcurrent(Connection conn, JobKey jobKey) throws SQLException {
  440. PreparedStatement ps = null;
  441. ResultSet rs = null;
  442. boolean var5;
  443. try {
  444. ps = conn.prepareStatement( this.rtp( "SELECT IS_NONCONCURRENT FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  445. ps.setString( 1, jobKey.getName());
  446. ps.setString( 2, jobKey.getGroup());
  447. rs = ps.executeQuery();
  448. if (rs.next()) {
  449. var5 = this.getBoolean(rs, "IS_NONCONCURRENT");
  450. return var5;
  451. }
  452. var5 = false;
  453. } finally {
  454. closeResultSet(rs);
  455. closeStatement(ps);
  456. }
  457. return var5;
  458. }
  459. public boolean jobExists(Connection conn, JobKey jobKey) throws SQLException {
  460. PreparedStatement ps = null;
  461. ResultSet rs = null;
  462. boolean var5;
  463. try {
  464. ps = conn.prepareStatement( this.rtp( "SELECT JOB_NAME FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  465. ps.setString( 1, jobKey.getName());
  466. ps.setString( 2, jobKey.getGroup());
  467. rs = ps.executeQuery();
  468. if (!rs.next()) {
  469. var5 = false;
  470. return var5;
  471. }
  472. var5 = true;
  473. } finally {
  474. closeResultSet(rs);
  475. closeStatement(ps);
  476. }
  477. return var5;
  478. }
  479. public int updateJobData(Connection conn, JobDetail job) throws IOException, SQLException {
  480. ByteArrayOutputStream baos = this.serializeJobData(job.getJobDataMap());
  481. PreparedStatement ps = null;
  482. int var5;
  483. try {
  484. ps = conn.prepareStatement( this.rtp( "UPDATE {0}JOB_DETAILS SET JOB_DATA = ? WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  485. this.setBytes(ps, 1, baos);
  486. ps.setString( 2, job.getKey().getName());
  487. ps.setString( 3, job.getKey().getGroup());
  488. var5 = ps.executeUpdate();
  489. } finally {
  490. closeStatement(ps);
  491. }
  492. return var5;
  493. }
  494. public JobDetail selectJobDetail(Connection conn, JobKey jobKey, ClassLoadHelper loadHelper) throws ClassNotFoundException, IOException, SQLException {
  495. PreparedStatement ps = null;
  496. ResultSet rs = null;
  497. JobDetailImpl var11;
  498. try {
  499. ps = conn.prepareStatement( this.rtp( "SELECT * FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
  500. ps.setString( 1, jobKey.getName());
  501. ps.setString( 2, jobKey.getGroup());
  502. rs = ps.executeQuery();
  503. JobDetailImpl job = null;
  504. if (rs.next()) {
  505. job = new JobDetailImpl();
  506. job.setName(rs.getString( "JOB_NAME"));
  507. job.setGroup(rs.getString( "JOB_GROUP"));
  508. job.setDescription(rs.getString( "DESCRIPTION"));
  509. job.setJobClass(loadHelper.loadClass(rs.getString( "JOB_CLASS_NAME"), Job.class));
  510. job.setDurability( this.getBoolean(rs, "IS_DURABLE"));
  511. job.setRequestsRecovery( this.getBoolean(rs, "REQUESTS_RECOVERY"));
  512. Map<?, ?> map = null;
  513. if ( this.canUseProperties()) {
  514. map = this.getMapFromProperties(rs);
  515. } else {
  516. map = (Map) this.getObjectFromBlob(rs, "JOB_DATA");
  517. }
  518. if ( null != map) {
  519. job.setJobDataMap( new JobDataMap(map));
  520. }
  521. }
  522. var11 = job;
  523. } finally {
  524. closeResultSet(rs);
  525. closeStatement(ps);
  526. }
  527. return var11;
  528. }
  529. private Map<?, ?> getMapFromProperties(ResultSet rs) throws ClassNotFoundException, IOException, SQLException {
  530. InputStream is = (InputStream) this.getJobDataFromBlob(rs, "JOB_DATA");
  531. if (is == null) {
  532. return null;
  533. } else {
  534. Properties properties = new Properties();
  535. if (is != null) {
  536. try {
  537. properties.load(is);
  538. } finally {
  539. is.close();
  540. }
  541. }
  542. Map<?, ?> map = this.convertFromProperty(properties);
  543. return map;
  544. }
  545. }
  546. public int selectNumJobs(Connection conn) throws SQLException {
  547. PreparedStatement ps = null;
  548. ResultSet rs = null;
  549. int var5;
  550. try {
  551. int count = 0;
  552. ps = conn.prepareStatement( this.rtp( "SELECT COUNT(JOB_NAME) FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1}"));
  553. rs = ps.executeQuery();
  554. if (rs.next()) {
  555. count = rs.getInt( 1);
  556. }
  557. var5 = count;
  558. } finally {
  559. closeResultSet(rs);
  560. closeStatement(ps);
  561. }
  562. return var5;
  563. }
  564. public List<String> selectJobGroups(Connection conn) throws SQLException {
  565. PreparedStatement ps = null;
  566. ResultSet rs = null;
  567. try {
  568. ps = conn.prepareStatement( this.rtp( "SELECT DISTINCT(JOB_GROUP) FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1}"));
  569. rs = ps.executeQuery();
  570. LinkedList list = new LinkedList();
  571. while(rs.next()) {
  572. list.add(rs.getString( 1));
  573. }
  574. LinkedList var5 = list;
  575. return var5;
  576. } finally {
  577. closeResultSet(rs);
  578. closeStatement(ps);
  579. }
  580. }
  581. public Set<JobKey> selectJobsInGroup(Connection conn, GroupMatcher<JobKey> matcher) throws SQLException {
  582. PreparedStatement ps = null;
  583. ResultSet rs = null;
  584. try {
  585. if ( this.isMatcherEquals(matcher)) {
  586. ps = conn.prepareStatement( this.rtp( "SELECT JOB_NAME, JOB_GROUP FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_GROUP = ?"));
  587. ps.setString( 1, this.toSqlEqualsClause(matcher));
  588. } else {
  589. ps = conn.prepareStatement( this.rtp( "SELECT JOB_NAME, JOB_GROUP FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_GROUP LIKE ?"));
  590. ps.setString( 1, this.toSqlLikeClause(matcher));
  591. }
  592. rs = ps.executeQuery();
  593. LinkedList list = new LinkedList();
  594. while(rs.next()) {
  595. list.add(JobKey.jobKey(rs.getString( 1), rs.getString( 2)));
  596. }
  597. HashSet var6 = new HashSet(list);
  598. return var6;
  599. } finally {
  600. closeResultSet(rs);
  601. closeStatement(ps);
  602. }
  603. }
  604. protected boolean isMatcherEquals(GroupMatcher<?> matcher) {
  605. return matcher.getCompareWithOperator().equals(StringOperatorName.EQUALS);
  606. }
  607. protected String toSqlEqualsClause(GroupMatcher<?> matcher) {
  608. return matcher.getCompareToValue();
  609. }
  610. protected String toSqlLikeClause(GroupMatcher<?> matcher) {
  611. String groupName;
  612. switch(matcher.getCompareWithOperator()) {
  613. case EQUALS:
  614. groupName = matcher.getCompareToValue();
  615. break;
  616. case CONTAINS:
  617. groupName = "%" + matcher.getCompareToValue() + "%";
  618. break;
  619. case ENDS_WITH:
  620. groupName = "%" + matcher.getCompareToValue();
  621. break;
  622. case STARTS_WITH:
  623. groupName = matcher.getCompareToValue() + "%";
  624. break;
  625. case ANYTHING:
  626. groupName = "%";
  627. break;
  628. default:
  629. throw new UnsupportedOperationException( "Don't know how to translate " + matcher.getCompareWithOperator() + " into SQL");
  630. }
  631. return groupName;
  632. }
  633. public int insertTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
  634. ByteArrayOutputStream baos = null;
  635. if (trigger.getJobDataMap().size() > 0) {
  636. baos = this.serializeJobData(trigger.getJobDataMap());
  637. }
  638. PreparedStatement ps = null;
  639. boolean var7 = false;
  640. int insertResult;
  641. try {
  642. ps = conn.prepareStatement( this.rtp( "INSERT INTO {0}TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP, JOB_NAME, JOB_GROUP, DESCRIPTION, NEXT_FIRE_TIME, PREV_FIRE_TIME, TRIGGER_STATE, TRIGGER_TYPE, START_TIME, END_TIME, CALENDAR_NAME, MISFIRE_INSTR, JOB_DATA, PRIORITY) VALUES({1}, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
  643. ps.setString( 1, trigger.getKey().getName());
  644. ps.setString( 2, trigger.getKey().getGroup());
  645. ps.setString( 3, trigger.getJobKey().getName());
  646. ps.setString( 4, trigger.getJobKey().getGroup());
  647. ps.setString( 5, trigger.getDescription());
  648. if (trigger.getNextFireTime() != null) {
  649. ps.setBigDecimal( 6, new BigDecimal(String.valueOf(trigger.getNextFireTime().getTime())));
  650. } else {
  651. ps.setBigDecimal( 6, (BigDecimal) null);
  652. }
  653. long prevFireTime = - 1L;
  654. if (trigger.getPreviousFireTime() != null) {
  655. prevFireTime = trigger.getPreviousFireTime().getTime();
  656. }
  657. ps.setBigDecimal( 7, new BigDecimal(String.valueOf(prevFireTime)));
  658. ps.setString( 8, state);
  659. TriggerPersistenceDelegate tDel = this.findTriggerPersistenceDelegate(trigger);
  660. String type = "BLOB";
  661. if (tDel != null) {
  662. type = tDel.getHandledTriggerTypeDiscriminator();
  663. }
  664. ps.setString( 9, type);
  665. ps.setBigDecimal( 10, new BigDecimal(String.valueOf(trigger.getStartTime().getTime())));
  666. long endTime = 0L;
  667. if (trigger.getEndTime() != null) {
  668. endTime = trigger.getEndTime().getTime();
  669. }
  670. ps.setBigDecimal( 11, new BigDecimal(String.valueOf(endTime)));
  671. ps.setString( 12, trigger.getCalendarName());
  672. ps.setInt( 13, trigger.getMisfireInstruction());
  673. this.setBytes(ps, 14, baos);
  674. ps.setInt( 15, trigger.getPriority());
  675. insertResult = ps.executeUpdate();
  676. if (tDel == null) {
  677. this.insertBlobTrigger(conn, trigger);
  678. } else {
  679. tDel.insertExtendedTriggerProperties(conn, trigger, state, jobDetail);
  680. }
  681. } finally {
  682. closeStatement(ps);
  683. }
  684. return insertResult;
  685. }
  686. public int insertBlobTrigger(Connection conn, OperableTrigger trigger) throws SQLException, IOException {
  687. PreparedStatement ps = null;
  688. ByteArrayOutputStream os = null;
  689. int var8;
  690. try {
  691. os = new ByteArrayOutputStream();
  692. ObjectOutputStream oos = new ObjectOutputStream(os);
  693. oos.writeObject(trigger);
  694. oos.close();
  695. byte[] buf = os.toByteArray();
  696. ByteArrayInputStream is = new ByteArrayInputStream(buf);
  697. ps = conn.prepareStatement( this.rtp( "INSERT INTO {0}BLOB_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP, BLOB_DATA) VALUES({1}, ?, ?, ?)"));
  698. ps.setString( 1, trigger.getKey().getName());
  699. ps.setString( 2, trigger.getKey().getGroup());
  700. ps.setBinaryStream( 3, is, buf.length);
  701. var8 = ps.executeUpdate();
  702. } finally {
  703. closeStatement(ps);
  704. }
  705. return var8;
  706. }
  707. public int updateTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
  708. boolean updateJobData = trigger.getJobDataMap().isDirty();
  709. ByteArrayOutputStream baos = null;
  710. if (updateJobData && trigger.getJobDataMap().size() > 0) {
  711. baos = this.serializeJobData(trigger.getJobDataMap());
  712. }
  713. PreparedStatement ps = null;
  714. boolean var8 = false;
  715. int insertResult;
  716. try {
  717. if (updateJobData) {
  718. ps = conn.prepareStatement( this.rtp( "UPDATE {0}TRIGGERS SET JOB_NAME = ?, JOB_GROUP = ?, DESCRIPTION = ?, NEXT_FIRE_TIME = ?, PREV_FIRE_TIME = ?, TRIGGER_STATE = ?, TRIGGER_TYPE = ?, START_TIME = ?, END_TIME = ?, CALENDAR_NAME = ?, MISFIRE_INSTR = ?, PRIORITY = ?, JOB_DATA = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
  719. } else {
  720. ps = conn.prepareStatement( this.rtp( "UPDATE {0}TRIGGERS SET JOB_NAME = ?, JOB_GROUP = ?, DESCRIPTION = ?, NEXT_FIRE_TIME = ?, PREV_FIRE_TIME = ?, TRIGGER_STATE = ?, TRIGGER_TYPE = ?, START_TIME = ?, END_TIME = ?, CALENDAR_NAME = ?, MISFIRE_INSTR = ?, PRIORITY = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
  721. }
  722. ps.setString( 1, trigger.getJobKey().getName());
  723. ps.setString( 2, trigger.getJobKey().getGroup());
  724. ps.setString( 3, trigger.getDescription());
  725. long nextFireTime = - 1L;
  726. if (trigger.getNextFireTime() != null) {
  727. nextFireTime = trigger.getNextFireTime().getTime();
  728. }
  729. ps.setBigDecimal( 4, new BigDecimal(String.valueOf(nextFireTime)));
  730. long prevFireTime = - 1L;
  731. if (trigger.getPreviousFireTime() != null) {
  732. prevFireTime = trigger.getPreviousFireTime().getTime();
  733. }
  734. ps.setBigDecimal( 5, new BigDecimal(String.valueOf(prevFireTime)));
  735. ps.setString( 6, state);
  736. TriggerPersistenceDelegate tDel = this.findTriggerPersistenceDelegate(trigger);
  737. String type = "BLOB";
  738. if (tDel != null) {
  739. type = tDel.getHandledTriggerTypeDiscriminator();
  740. }
  741. ps.setString( 7, type);
  742. ps.setBigDecimal( 8, new BigDecimal(String.valueOf(trigger.getStartTime().getTime())));
  743. long endTime = 0L;
  744. if (trigger.getEndTime() != null) {
  745. endTime = trigger.getEndTime().getTime();
  746. }
  747. ps.setBigDecimal( 9, new BigDecimal(String.valueOf(endTime)));
  748. ps.setString( 10, trigger.getCalendarName());
  749. ps.setInt( 11, trigger.getMisfireInstruction());
  750. ps.setInt( 12, trigger.getPriority());
  751. if (updateJobData) {
  752. this.setBytes(ps, 13, baos);
  753. ps.setString( 14, trigger.getKey().getName());
  754. ps.setString( 15, trigger.getKey().getGroup());
  755. } else {
  756. ps.setString( 13, trigger.getKey().getName());
  757. ps.setString( 14, trigger.getKey().getGroup());
  758. }
  759. insertResult = ps.executeUpdate();
  760. if (tDel == null) {
  761. this.updateBlobTrigger(conn, trigger);
  762. } else {
  763. tDel.updateExtendedTriggerProperties(conn, trigger, state, jobDetail);
  764. }
  765. } finally {
  766. closeStatement(ps);
  767. }
  768. return insertResult;
  769. }
  770. public int updateBlobTrigger(Connection conn, OperableTrigger trigger) throws SQLException, IOException {
  771. PreparedStatement ps = null;
  772. ByteArrayOutputStream os = null;
  773. int var8;
  774. try {
  775. os = new ByteArrayOutputStream();
  776. ObjectOutputStream oos = new ObjectOutputStream(os);
  777. oos.writeObject(trigger);
  778. oos.close();
  779. byte[] buf = os.toByteArray();
  780. ByteArrayInputStream is = new ByteArrayInputStream(buf);
  781. ps = conn.prepareStatement( this.rtp( "UPDATE {0}BLOB_TRIGGERS SET BLOB_DATA = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
  782. ps.setBinaryStream( 1, is, buf.length);
  783. ps.setString( 2, trigger.getKey().getName());
  784. ps.setString( 3, trigger.getKey().getGroup());
  785. var8 = ps.executeUpdate();
  786. } finally {
  787. closeStatement(ps);
  788. if (os != null) {
  789. os.close();
  790. }
  791. }
  792. return var8;
  793. }
  794. public boolean triggerExists(Connection conn, TriggerKey triggerKey) throws SQLException {
  795. PreparedStatement ps = null;
  796. ResultSet rs = null;
  797. boolean var5;
  798. try {
  799. ps = conn.prepareStatement( this.rtp( "SELECT TRIGGER_NAME FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
  800. ps.setString( 1, triggerKey.getName());
  801. ps.setString( 2, triggerKey.getGroup());
  802. rs = ps.executeQuery();
  803. if (!rs.next()) {
  804. var5 = false;
  805. return var5;
  806. }
  807. var5 = true;
  808. } finally {
  809. closeResultSet(rs);
  810. closeStatement(ps);
  811. }
  812. return var5;
  813. }
  814. public int updateTriggerState(Connection conn, TriggerKey triggerKey, String state) throws SQLException {
  815. PreparedStatement ps = null;
  816. int var5;
  817. try {
  818. ps = conn.prepareStatement( this.rtp( "UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
  819. ps.setString( 1, state);
  820. ps.setString( 2, triggerKey.getName());
  821. ps.setString( 3, triggerKey.getGroup());
  822. var5 = ps.executeUpdate();
  823. } finally {
  824. closeStatement(ps);
  825. }
  826. return var5;
  827. }
  828. public int updateTriggerStateFromOtherStates(Connection conn, TriggerKey triggerKey, String newState, String oldState1, String oldState2, String oldState3) throws SQLException {
  829. PreparedStatement ps = null;
  830. int var8;
  831. try {
  832. ps = conn.prepareStatement( this.rtp( "UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ? AND (TRIGGER_STATE = ? OR TRIGGER_STATE = ? OR TRIGGER_STATE = ?)"));
  833. ps.setString( 1, newState);
  834. ps.setString( 2, triggerKey.getName());
  835. ps.setString( 3, triggerKey.getGroup());
  836. ps.setString( 4, oldState1);
  837. ps.setString( 5, oldState2);
  838. ps.setString( 6, oldState3);
  839. var8 = ps.executeUpdate();
  840. } finally {
  841. closeStatement(ps);
  842. }
  843. return var8;
  844. }
  845. public int updateTriggerGroupStateFromOtherStates(Connection conn, GroupMatcher<TriggerKey> matcher, String newState, String oldState1, String oldState2, String oldState3) throws SQLException {
  846. PreparedStatement ps = null;
  847. int var8;
  848. try {
  849. ps = conn.prepareStatement( this.rtp( "UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE ? AND (TRIGGER_STATE = ? OR TRIGGER_STATE = ? OR TRIGGER_STATE = ?)"));
  850. ps.setString( 1, newState);
  851. ps.setString( 2, this.toSqlLikeClause(matcher));
  852. ps.setString( 3, oldState1);
  853. ps.setString( 4, oldState2);
  854. ps.setString( 5, oldState3);
  855. var8 = ps.executeUpdate();
  856. } finally {
  857. closeStatement(ps);
  858. }
  859. return var8;
  860. }
  861. public int updateTriggerStateFromOtherState(Connection conn, TriggerKey triggerKey, String newState, String oldState) throws SQLException {
  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值