Java 类org.quartz.SchedulerListener 实例源码

public void notifySchedulerListenersError(String msg, SchedulerException se) {
    // build a list of all scheduler listeners that are to be notified...
    List<SchedulerListener> schedListeners = buildSchedulerListenerList();

    // notify all scheduler listeners
    for(SchedulerListener sl: schedListeners) {
        try {
            sl.schedulerError(msg, se);
        } catch (Exception e) {
            getLog()
                    .error(
                            "Error while notifying SchedulerListener of error: ",
                            e);
            getLog().error(
                    "  Original error (for notification) was: " + msg, se);
        }
    }
}

public void notifySchedulerListenersUnscheduled(TriggerKey triggerKey) {
    // build a list of all scheduler listeners that are to be notified...
    List<SchedulerListener> schedListeners = buildSchedulerListenerList();

    // notify all scheduler listeners
    for(SchedulerListener sl: schedListeners) {
        try {
            if(triggerKey == null)
                sl.schedulingDataCleared();
            else
                sl.jobUnscheduled(triggerKey);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of unscheduled job."
                            + "  Triger=" + (triggerKey == null ? "ALL DATA" : triggerKey), e);
        }
    }
}

public void notifySchedulerListenersError(String msg, SchedulerException se) {
    // build a list of all scheduler listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.schedulerError(msg, se);
        } catch (Exception e) {
            getLog()
                    .error(
                            "Error while notifying SchedulerListener of error: ",
                            e);
            getLog().error(
                    "  Original error (for notification) was: " + msg, se);
        }
    }
}

public void notifySchedulerListenersSchduled(Trigger trigger) {
    // build a list of all scheduler listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.jobScheduled(trigger);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of scheduled job."
                            + "  Triger=" + trigger.getFullName(), e);
        }
    }
}

public void notifySchedulerListenersUnscheduled(String triggerName,
        String triggerGroup) {
    // build a list of all scheduler listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.jobUnscheduled(triggerName, triggerGroup);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of unscheduled job."
                            + "  Triger=" + triggerGroup + "."
                            + triggerName, e);
        }
    }
}

public void notifySchedulerListenersFinalized(Trigger trigger) {
    // build a list of all scheduler listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.triggerFinalized(trigger);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of finalized trigger."
                            + "  Triger=" + trigger.getFullName(), e);
        }
    }
}

public void notifySchedulerListenersPausedTrigger(String name, String group) {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.triggersPaused(name, group);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of paused trigger/group."
                            + "  Triger=" + group + "." + name, e);
        }
    }
}

public void notifySchedulerListenersResumedTrigger(String name, String group) {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.triggersResumed(name, group);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of resumed trigger/group."
                            + "  Triger=" + group + "." + name, e);
        }
    }
}

public void notifySchedulerListenersPausedJob(String name, String group) {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.jobsPaused(name, group);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of paused job/group."
                            + "  Job=" + group + "." + name, e);
        }
    }
}

public void notifySchedulerListenersResumedJob(String name, String group) {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.jobsResumed(name, group);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of resumed job/group."
                            + "  Job=" + group + "." + name, e);
        }
    }
}

public void notifySchedulerListenersInStandbyMode() {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.schedulerInStandbyMode();
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of inStandByMode.",
                    e);
        }
    }
}

public void notifySchedulerListenersStarted() {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.schedulerStarted();
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of startup.",
                    e);
        }
    }
}

public void notifySchedulerListenersShutdown() {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.schedulerShutdown();
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of shutdown.",
                    e);
        }
    }
}

public void notifySchedulerListenersShuttingdown() {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.schedulerShuttingdown();
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of shutdown.",
                    e);
        }
    }
}

public void notifySchedulerListenersJobAdded(JobDetail jobDetail) {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.jobAdded(jobDetail);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of JobAdded.",
                    e);
        }
    }
}

public void notifySchedulerListenersJobDeleted(String jobName, String groupName) {
    // build a list of all job listeners that are to be notified...
    List schedListeners = getSchedulerListeners();

    // notify all scheduler listeners
    java.util.Iterator itr = schedListeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener sl = (SchedulerListener) itr.next();
        try {
            sl.jobDeleted(jobName, groupName);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of JobAdded.",
                    e);
        }
    }
}

public void jobAdded(JobDetail jobDetail) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobAdded(jobDetail);
    }
}

public void jobDeleted(JobKey jobKey) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobDeleted(jobKey);
    }
}

public void jobScheduled(Trigger trigger) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobScheduled(trigger);
    }
}

public void jobUnscheduled(TriggerKey triggerKey) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobUnscheduled(triggerKey);
    }
}

public void triggerFinalized(Trigger trigger) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.triggerFinalized(trigger);
    }
}

public void triggerPaused(TriggerKey key) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.triggerPaused(key);
    }
}

public void triggersPaused(String triggerGroup) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.triggersPaused(triggerGroup);
    }
}

public void triggerResumed(TriggerKey key) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.triggerResumed(key);
    }
}

public void triggersResumed(String triggerGroup) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.triggersResumed(triggerGroup);
    }
}

public void schedulingDataCleared() {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulingDataCleared();
    }
}

public void jobPaused(JobKey key) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobPaused(key);
    }
}

public void jobsPaused(String jobGroup) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobsPaused(jobGroup);
    }
}

public void jobResumed(JobKey key) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobResumed(key);
    }
}

public void jobsResumed(String jobGroup) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.jobsResumed(jobGroup);
    }
}

public void schedulerError(String msg, SchedulerException cause) {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulerError(msg, cause);
    }
}

public void schedulerStarted() {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulerStarted();
    }
}

public void schedulerStarting() {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while (itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulerStarting();
    }
}

public void schedulerInStandbyMode() {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulerInStandbyMode();
    }
}

public void schedulerShutdown() {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulerShutdown();
    }
}

public void schedulerShuttingdown() {
    Iterator<SchedulerListener> itr = listeners.iterator();
    while(itr.hasNext()) {
        SchedulerListener l = itr.next();
        l.schedulerShuttingdown();
    }
}

private List<SchedulerListener> buildSchedulerListenerList() {
    List<SchedulerListener> allListeners = new LinkedList<SchedulerListener>();
    allListeners.addAll(getListenerManager().getSchedulerListeners());
    allListeners.addAll(getInternalSchedulerListeners());

    return allListeners;
}

public void notifySchedulerListenersSchduled(Trigger trigger) {
    // build a list of all scheduler listeners that are to be notified...
    List<SchedulerListener> schedListeners = buildSchedulerListenerList();

    // notify all scheduler listeners
    for(SchedulerListener sl: schedListeners) {
        try {
            sl.jobScheduled(trigger);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of scheduled job."
                            + "  Triger=" + trigger.getKey(), e);
        }
    }
}

public void notifySchedulerListenersFinalized(Trigger trigger) {
    // build a list of all scheduler listeners that are to be notified...
    List<SchedulerListener> schedListeners = buildSchedulerListenerList();

    // notify all scheduler listeners
    for(SchedulerListener sl: schedListeners) {
        try {
            sl.triggerFinalized(trigger);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of finalized trigger."
                            + "  Triger=" + trigger.getKey(), e);
        }
    }
}

public void notifySchedulerListenersPausedTrigger(TriggerKey triggerKey) {
    // build a list of all scheduler listeners that are to be notified...
    List<SchedulerListener> schedListeners = buildSchedulerListenerList();

    // notify all scheduler listeners
    for(SchedulerListener sl: schedListeners) {
        try {
            sl.triggerPaused(triggerKey);
        } catch (Exception e) {
            getLog().error(
                    "Error while notifying SchedulerListener of paused trigger: "
                            + triggerKey, e);
        }
    }
}