jobstoresupport.java

非常好用的计划任务调度包,能定义复杂的任务

        for (int i = 0; i < misfiredTriggers.length && i < getMaxMisfiresToHandleAtATime(); i++) {
            Trigger trig = getDelegate().selectTrigger(conn,
                    misfiredTriggers[i].getName(),
                    misfiredTriggers[i].getGroup());

            if (trig == null) continue;

            Calendar cal = null;
            if (trig.getCalendarName() != null)
                    cal = retrieveCalendar(conn, null, trig.getCalendarName());

            String[] listeners = getDelegate().selectTriggerListeners(conn,
                trig.getName(), trig.getGroup());
            for (int l = 0; l < listeners.length; ++l) {
              trig.addTriggerListener(listeners[l]);
            }
            
            signaler.notifyTriggerListenersMisfired(trig);

            trig.updateAfterMisfire(cal);

            if (trig.getNextFireTime() == null) 
                storeTrigger(conn, null, trig, null, true, STATE_COMPLETE, 
                        false, recovering);
            else
                storeTrigger(conn, null, trig, null, true, STATE_WAITING, 
                        false, recovering);
        }

        if (misfiredTriggers.length > getMaxMisfiresToHandleAtATime()) return true;

        return false;
    }

    protected boolean updateMisfiredTrigger(Connection conn,
            SchedulingContext ctxt, String triggerName, String groupName,
            String newStateIfNotComplete, boolean forceState) // TODO: probably
            // get rid of
            // this
            throws JobPersistenceException {
        try {

            Trigger trig = getDelegate().selectTrigger(conn, triggerName,
                    groupName);

            long misfireTime = System.currentTimeMillis();
            if (getMisfireThreshold() > 0)
                    misfireTime -= getMisfireThreshold();

            if (trig.getNextFireTime().getTime() > misfireTime) return false;

            Calendar cal = null;
            if (trig.getCalendarName() != null)
                    cal = retrieveCalendar(conn, ctxt, trig.getCalendarName());

            signaler.notifyTriggerListenersMisfired(trig);

            trig.updateAfterMisfire(cal);

            if (trig.getNextFireTime() == null) storeTrigger(conn, ctxt, trig,
                    null, true, STATE_COMPLETE, forceState, false);
            else {
                storeTrigger(conn, ctxt, trig, null, true, newStateIfNotComplete,
                        forceState, false);
            }
            
            return true;

        } catch (Exception e) {
            throw new JobPersistenceException(
                    "Couldn't update misfired trigger '" + groupName + "."
                            + triggerName + "': " + e.getMessage(), e);
        }
    }

    /**
     * <p>
     * Insert or update a job.
     * </p>
     */
    protected void storeJob(Connection conn, SchedulingContext ctxt,
            JobDetail newJob, boolean replaceExisting)
            throws ObjectAlreadyExistsException, JobPersistenceException {
        if (newJob.isVolatile() && isClustered())
                getLog()
                        .info(
                                "note: volatile jobs are effectively non-volatile in a clustered environment.");

        boolean existingJob = jobExists(conn, newJob.getName(), newJob
                .getGroup());
        try {
            if (existingJob) {
                if (!replaceExisting) { throw new ObjectAlreadyExistsException(
                        newJob); }
                getDelegate().updateJobDetail(conn, newJob);
            } else {
                getDelegate().insertJobDetail(conn, newJob);
            }
        } catch (IOException e) {
            throw new JobPersistenceException("Couldn't store job: "
                    + e.getMessage(), e);
        } catch (SQLException e) {
            throw new JobPersistenceException("Couldn't store job: "
                    + e.getMessage(), e);
        }
    }

    /**
     * <p>
     * Check existence of a given job.
     * </p>
     */
    protected boolean jobExists(Connection conn, String jobName,
            String groupName) throws JobPersistenceException {
        try {
            return getDelegate().jobExists(conn, jobName, groupName);
        } catch (SQLException e) {
            throw new JobPersistenceException(
                    "Couldn't determine job existence (" + groupName + "."
                            + jobName + "): " + e.getMessage(), e);
        }
    }

    /**
     * <p>
     * Insert or update a trigger.
     * </p>
     */
    protected void storeTrigger(Connection conn, SchedulingContext ctxt,
            Trigger newTrigger, JobDetail job, boolean replaceExisting, String state,
            boolean forceState, boolean recovering)
            throws ObjectAlreadyExistsException, JobPersistenceException {
        if (newTrigger.isVolatile() && isClustered())
                getLog()
                        .info(
                                "note: volatile triggers are effectively non-volatile in a clustered environment.");

        boolean existingTrigger = triggerExists(conn, newTrigger.getName(),
                newTrigger.getGroup());

        try {

            boolean shouldBepaused = false;

            if (!forceState) {
                shouldBepaused = getDelegate().isTriggerGroupPaused(
                        conn, newTrigger.getGroup());

                if(!shouldBepaused) {
                    shouldBepaused = getDelegate().isTriggerGroupPaused(conn,
                            ALL_GROUPS_PAUSED);

                    if (shouldBepaused)
                            getDelegate().insertPausedTriggerGroup(conn,
                                    newTrigger.getGroup());
                }

                if (shouldBepaused && (state.equals(STATE_WAITING) || state.equals(STATE_ACQUIRED)))
                        state = STATE_PAUSED;
            }

            if(job == null) {
                job = getDelegate().selectJobDetail(conn,
                    newTrigger.getJobName(), newTrigger.getJobGroup(),
                    getClassLoadHelper());
            }
            if (job == null)
                    throw new JobPersistenceException("The job ("
                            + newTrigger.getFullJobName()
                            + ") referenced by the trigger does not exist.");
            if (job.isVolatile() && !newTrigger.isVolatile())
                    throw new JobPersistenceException(
                            "It does not make sense to "
                                    + "associate a non-volatile Trigger with a volatile Job!");

            if (job.isStateful() && !recovering && state.equals(STATE_WAITING)) {
                state = getNewStatusForTrigger(conn, ctxt, job.getName(), job
                        .getGroup());
            }
            if (existingTrigger) {
                if (!replaceExisting) { throw new ObjectAlreadyExistsException(
                        newTrigger); }
                if (newTrigger instanceof SimpleTrigger) {
                    getDelegate().updateSimpleTrigger(conn,
                            (SimpleTrigger) newTrigger);
                } else if (newTrigger instanceof CronTrigger) {
                    getDelegate().updateCronTrigger(conn,
                            (CronTrigger) newTrigger);
                } else {
                    getDelegate().updateBlobTrigger(conn, newTrigger);
                }
                getDelegate().updateTrigger(conn, newTrigger, state, job);
            } else {
                getDelegate().insertTrigger(conn, newTrigger, state, job);
                if (newTrigger instanceof SimpleTrigger) {
                    getDelegate().insertSimpleTrigger(conn,
                            (SimpleTrigger) newTrigger);
                } else if (newTrigger instanceof CronTrigger) {
                    getDelegate().insertCronTrigger(conn,
                            (CronTrigger) newTrigger);
                } else {
                    getDelegate().insertBlobTrigger(conn, newTrigger);
                }
            }
        } catch (Exception e) {
            throw new JobPersistenceException("Couldn't store trigger: "
                    + e.getMessage(), e);
        }
    }

    /**
     * <p>
     * Check existence of a given trigger.
     * </p>
     */
    protected boolean triggerExists(Connection conn, String triggerName,
            String groupName) throws JobPersistenceException {
        try {
            return getDelegate().triggerExists(conn, triggerName, groupName);
        } catch (SQLException e) {
            throw new JobPersistenceException(
                    "Couldn't determine trigger existence (" + groupName + "."
                            + triggerName + "): " + e.getMessage(), e);
        }
    }

    protected boolean removeJob(Connection conn, SchedulingContext ctxt,
            String jobName, String groupName, boolean activeDeleteSafe)
            throws JobPersistenceException {

        try {
            Key[] jobTriggers = getDelegate().selectTriggerNamesForJob(conn,
                    jobName, groupName);
            for (int i = 0; i < jobTriggers.length; ++i) {
                getDelegate().deleteSimpleTrigger(conn,
                        jobTriggers[i].getName(), jobTriggers[i].getGroup());
                getDelegate().deleteCronTrigger(conn, jobTriggers[i].getName(),
                        jobTriggers[i].getGroup());
                getDelegate().deleteBlobTrigger(conn, jobTriggers[i].getName(),
                        jobTriggers[i].getGroup());
                getDelegate().deleteTriggerListeners(conn,
                        jobTriggers[i].getName(), jobTriggers[i].getGroup());
                getDelegate().deleteTrigger(conn, jobTriggers[i].getName(),
                        jobTriggers[i].getGroup());
            }

            getDelegate().deleteJobListeners(conn, jobName, groupName);

            if (getDelegate().deleteJobDetail(conn, jobName, groupName) > 0) {
                return true;
            } else {
                return false;
            }
        } catch (SQLException e) {
            throw new JobPersistenceException("Couldn't remove job: "
                    + e.getMessage(), e);
        }
    }

    protected JobDetail retrieveJob(Connection conn, SchedulingContext ctxt,
            String jobName, String groupName) throws JobPersistenceException {
        try {
            JobDetail job = getDelegate().selectJobDetail(conn, jobName,
                    groupName, getClassLoadHelper());
            String[] listeners = getDelegate().selectJobListeners(conn,
                    jobName, groupName);
            for (int i = 0; i < listeners.length; ++i) {
                job.addJobListener(listeners[i]);
            }

            return job;
        } catch (ClassNotFoundException e) {
            throw new JobPersistenceException(
                    "Couldn't retrieve job because a required class was not found: "
                            + e.getMessage(), e,
                    SchedulerException.ERR_PERSISTENCE_JOB_DOES_NOT_EXIST);
        } catch (IOException e) {
            throw new JobPersistenceException(
                    "Couldn't retrieve job because the BLOB couldn't be deserialized: "
                            + e.getMessage(), e,
                    SchedulerException.ERR_PERSISTENCE_JOB_DOES_NOT_EXIST);
        } catch (SQLException e) {
            throw new JobPersistenceException("Couldn't retrieve job: "
                    + e.getMessage(), e);
        }
    }

    protected boolean removeTrigger(Connection conn, SchedulingContext ctxt,
            String triggerName, String groupName)
            throws JobPersistenceException {
        boolean removedTrigger = false;
        try {
            // this must be called before we delete the trigger, obviously
            JobDetail job = getDelegate().selectJobForTrigger(conn,
                    triggerName, groupName, getClassLoadHelper());

            getDelegate().deleteSimpleTrigger(conn, triggerName, groupName);
            getDelegate().deleteCronTrigger(conn, triggerName, groupName);
            getDelegate().deleteBlobTrigger(conn, triggerName, groupName);
            getDelegate().deleteTriggerListeners(conn, triggerName, groupName);
            removedTrigger = (getDelegate().deleteTrigger(conn, triggerName,
                    groupName) > 0);

            if (null != job && !job.isDurable()) {
                int numTriggers = getDelegate().selectNumTriggersForJob(conn,
                        job.getName(), job.getGroup());
                if (numTriggers == 0) {
                    removeJob(conn, ctxt, job.getName(), job.getGroup(), true);
                }
            }
        } catch (ClassNotFoundException e) {
            throw new JobPersistenceException("Couldn't remove trigger: "
                    + e.getMessage(), e);
        } catch (SQLException e) {
            throw new JobPersistenceException("Couldn't remove trigger: "
                    + e.getMessage(), e);
        }

        return removedTrigger;
    }

    protected boolean replaceTrigger(Connection conn, SchedulingContext ctxt,
            String triggerName, String groupName, Trigger newTrigger)
    throws JobPersistenceException {
        boolean removedTrigger = false;
        try {
            // this must be called before we delete the trigger, obviously
            JobDetail job = getDelegate().selectJobForTrigger(conn,
                    triggerName, groupName, getClassLoadHelper());

            if(job == null)
                return false;
            
            if(!newTrigger.getJobName().equals(job.getName()) || 
               !newTrigger.getJobGroup().equals(job.getGroup()))
                throw new JobPersistenceException("New trigger is not related to the same job as the old trigger.");
            
            getDelegate().deleteSimpleTrigger(conn, triggerName, groupName);
            getDelegate().deleteCronTrigger(conn, triggerName, groupName);
            getDelegate().deleteBlobTrigger(conn, triggerName, groupName);
            getDelegate().deleteTriggerListeners(conn, triggerName, groupName);
            removedTrigger = (getDelegate().deleteTrigger(conn, triggerName,
                    groupName) > 0);
            
            storeTrigger(conn, ctxt, newTrigger, job, false, STATE_WAITING, false, false);

        } catch (ClassNotFoundException e) {
            throw new JobPersistenceException("Couldn't remove trigger: "
                    + e.getMessage(), e);
        } catch (SQLException e) {
            throw new JobPersistenceException("Couldn't remove trigger: "
                    + e.getMessage(), e);
        }

        return removedTrigger;
    }

    protected Trigger retrieveTrigger(Connection conn, SchedulingContext ctxt,
            String triggerName, String groupName)
            throws JobPersistenceException {
        try {
            Trigger trigger = getDelegate().selectTrigger(conn, triggerName,
                    groupName);
            if (trigger == null) return null;
            String[] listeners = getDelegate().selectTriggerListeners(conn,
                    triggerName, groupName);
            for (int i = 0; i < listeners.length; ++i) {
                trigger.addTriggerListener(listeners[i]);
            }