一次搞定所有定时任务

全部代码下载，在这———————http://download.csdn.net/detail/woxiaoheia/9335679

package com.suning.search.job.servcie;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;


import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;


import com.suning.search.admin.common.thread.Task;
import com.suning.search.admin.common.thread.ThreadExecuterService;
import com.suning.search.job.bean.Job;
import com.suning.search.job.bean.JobManangerRef;
import com.suning.search.job.bean.Manager;
import com.suning.search.job.common.thread.HttpRemotJobThread;
import com.suning.search.job.dao.JobDao;
import com.suning.search.job.dao.JobManagerDao;


/**
 * 
 * 〈Quartz任务的的维护〉<br> 
 * 〈Quartz任务的创建、删除、更新、查询、执行等〉
 *
 * @author 14061754
 */
public class Processor {


    private JobDao jobDao;
    private Scheduler scheduler;
    private JobManagerDao jobManagerDao;
    
    /** 所有任务: <任务id, 任务实体数据对象> */
    private static Map<String,JobEntity> jobEntityMap = new ConcurrentHashMap<String, JobEntity>();
    
    /** 所有互斥任务、待执行的任务管理 ： <managerId, JobManager>*/
    private static Map<String,JobManager> jobManagerMap = new ConcurrentHashMap<String,JobManager>();
    
    /** 根据状态码分类好的任务 ，key为状态码*/
    private static Map<Integer, Map<String, JobEntity>> stateMap = new ConcurrentHashMap<Integer, Map<String, JobEntity>>();
    private ThreadExecuterService<JobEntity,JobEntity> executor = null;
    public static Object lock = new Object();
    
    public void initial(){
        SchedulerFactory factory = new StdSchedulerFactory();
        try {
            scheduler = factory.getScheduler();
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        
        List<Job> jobs = jobDao.query();
        for(Job job:jobs){
        JobEntity jobEn = new JobEntity(job.getId()+"",job.getName(),job.getTime(), job.getUrl(), this);
        jobEn.setListenUrl(job.getCheckUrl());
        jobEn.setDefineSuccState(job.getDefineSuccState());
        jobEn.setUrlSuccResponse(job.getUrlSuccResponse());
        jobEntityMap.put(job.getId()+"", jobEn);
        }
        
        List<Manager> managers = jobManagerDao.queryManager(null);
        for(Manager manager:managers){
            jobManagerMap.put(manager.getId()+"", new JobManager(manager.getName(), manager.getId()+"", this));
        }
        
        List<JobManangerRef> jobManagerRefs = jobManagerDao.queryJobManangerRefs();
        for(JobManangerRef jobManagerRef:jobManagerRefs){
            JobEntity jobEntity = jobEntityMap.get(jobManagerRef.getJobId()+"");
            JobManager jobManager = jobManagerMap.get(jobManagerRef.getManagerId()+"");
            if(jobEntity!=null&&jobManager!=null){
                jobEntity.getManagers().put(jobManager.getManagerCode(),jobManager);
                jobManager.getMutexJobs().put(jobEntity.getJobCode(),jobEntity);
            }
        }
        
        for(Entry<String, JobEntity> entry:jobEntityMap.entrySet()){
            JobEntity jobEntity = entry.getValue();
            try {
                insertJobEntity(jobEntity);
            } catch (ParseException e) {
                e.printStackTrace();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    }
    
    public boolean jobIsRunning(Job job){
    boolean result = false;
    JobEntity request = new JobEntity();
    request.setJobCode(job.getId() + "");
    request.setJobName(job.getName());
    request.setUrl(job.getUrl());
    request.setListenUrl(job.getCheckUrl());
    JobEntity jobEntity = getRemoteJob(request);
   
if (jobEntity != null && !jobEntity.isUndefined()) {
    result = JobEntity.STATE_RUNING == jobEntity.getState();
    }
   
        return result;
    }
    
    public JobEntity getRemoteJob(JobEntity request){
    Collection<Task<JobEntity,JobEntity>> tasks = new ArrayList<Task<JobEntity,JobEntity>>();
    JobEntity response = new JobEntity();
    Task<JobEntity,JobEntity> task = new HttpRemotJobThread(request.getJobName(), request, response);
    tasks.add(task);
    executor.executeTasks(tasks);
        return response;
    }
    
    public int jobRunningNum(String code){
    // 1 - 获取runningNum
    return getNumber(code, JobEntity.STATE_RUNING);
    }
    
    public int jobWaitingNum(String code){
    int num = 0;
JobEntity job = jobEntityMap.get(code);
if (job != null) {
for (Entry<String, JobManager> managerEntry : job.getManagers().entrySet()) {
Iterator<JobCallBack> it = managerEntry.getValue().getCallBackQueue().iterator();
while (it.hasNext()) {
JobEntity je = (JobEntity) it.next();
if (je.getJobName().equals(job.getJobName())) {
num++;
}
}
//num += managerEntry.getValue().getCallBackQueue().size();
}
}

    return num;
    }
    
    public boolean execute(String code){
       return jobEntityMap.get(code).doRun();
    }
    
    public void insertJobEntity(JobEntity newJob) throws ParseException, SchedulerException{
        JobDetail jobDetail = new JobDetail(newJob.getJobCode(),Scheduler.DEFAULT_GROUP,MyJob.class);
        CronTrigger trigger = new CronTrigger(newJob.getJobCode(),Scheduler.DEFAULT_GROUP);
        jobDetail.getJobDataMap().put(newJob.getJobCode(),newJob);
        trigger.setCronExpression(newJob.getCronExpression());
        scheduler.scheduleJob(jobDetail, trigger);
    }
    
    public void updateJobEntity(JobEntity newJob) throws SchedulerException, ParseException{
        synchronized (lock) {
            JobEntity oldJob = jobEntityMap.get(newJob.getJobCode());
            oldJob.setJobName(newJob.getJobName());
            oldJob.setUrl(newJob.getUrl());
            oldJob.setUrlSuccResponse(newJob.getUrlSuccResponse());
            if(!oldJob.getCronExpression().equals(newJob.getCronExpression())){
                oldJob.setCronExpression(newJob.getCronExpression());
                scheduler.deleteJob(newJob.getJobCode(), Scheduler.DEFAULT_GROUP);
                insertJobEntity(oldJob);
            }
        }
    }
    
    public boolean deleteJobEntity(String jobId) throws SchedulerException{
        boolean flag = false;
        final JobEntity jobEntity = jobEntityMap.get(jobId);
        synchronized (lock) {
            for(Map.Entry<String, JobManager> entry:jobEntity.getManagers().entrySet()){
                JobManager jobManager = entry.getValue();
                jobManager.getMutexJobs().remove(jobEntity.getJobCode());
            }
            scheduler.deleteJob(jobEntity.getJobCode(),Scheduler.DEFAULT_GROUP);
            jobEntityMap.remove(jobId);
        }
        return flag;
    }
    
    public void deleteJobManager(String managerId){
        JobManager jobManager = jobManagerMap.get(managerId);
        synchronized (lock) {
            for(Entry<String, JobEntity> entry:jobManager.getMutexJobs().entrySet()){
                JobEntity jobEntity = entry.getValue();
                jobEntity.getManagers().remove(managerId);
            }
            jobManagerMap.remove(managerId);
        }
    }
    
    
    public void updateManagerJobRefs(String managerId,String[] jobIds){
        JobManager jobManager = jobManagerMap.get(managerId);
        synchronized (lock) {
            for(Entry<String, JobEntity> entry:jobManager.getMutexJobs().entrySet()){
                JobEntity jobEntity = entry.getValue();
                jobEntity.getManagers().remove(managerId);
            }
            jobManager.getMutexJobs().clear();
            if(jobIds!=null)
                for(String jobId:jobIds){
                    JobEntity jobEntity = jobEntityMap.get(jobId);
                    jobEntity.getManagers().put(jobManager.getManagerCode(), jobManager);
                    jobManager.getMutexJobs().put(jobId, jobEntity);
                }
        }
    }
    
    /**
     * 
     * @param jobCode
     * job code
     * @param state
     * 1 - 获取waitingNum, 2 - 获取runningNum
     * @return
     */
    private int getNumber(String jobCode, int state)
    {
Set<String> s = new HashSet<String>();
JobEntity job = jobEntityMap.get(jobCode);
if (job != null) {
for (Entry<String, JobManager> managerEntry : job.getManagers().entrySet()) {
for (Entry<String, JobEntity> entityEntry : managerEntry.getValue().getMutexJobs().entrySet()) {
JobEntity tmpBean = new JobEntity();
tmpBean.setJobCode(entityEntry.getValue().getJobCode());
tmpBean.setJobName(entityEntry.getValue().getJobName());
tmpBean.setUrl(entityEntry.getValue().getUrl());
tmpBean.setListenUrl(entityEntry.getValue().getListenUrl());
tmpBean = getRemoteJob(tmpBean);

if (tmpBean != null && state == tmpBean.getState()) {
s.add(tmpBean.getJobName());
}
}
}
}

    return s.size();
    }
    
    public static void stateChange(JobEntity oldJob, int newState)
    {
    int state = oldJob.getState();
    Map<String, JobEntity> oldMap = stateMap.get(state);
   
    if (oldMap != null) {
    oldMap.remove(oldJob.getJobCode());
    }
   
    Map<String, JobEntity> newMap = stateMap.get(newState);
    if (newMap == null) {
    newMap = new HashMap<String, JobEntity>();
    stateMap.put(newState, newMap);
    }
    oldJob.setState(newState);
    newMap.put(oldJob.getJobCode(), oldJob);
    }
    
    
    public void setExecutor(ThreadExecuterService<JobEntity, JobEntity> executor) {
this.executor = executor;
}
    
    public Map<JobEntity, JobEntity> executeTasks(Collection<Task<JobEntity,JobEntity>> tasks){
        return executor.executeTasks(tasks);
    }
    
   
    public void setJobDao(JobDao jobDao) {
        this.jobDao = jobDao;
    }


    public void setJobManagerDao(JobManagerDao jobManagerDao) {
        this.jobManagerDao = jobManagerDao;
    }


    public Map<String, JobEntity> getJobEntityMap() {
        return jobEntityMap;
    }


    public Map<String, JobManager> getJobManagerMap() {
        return jobManagerMap;
    }
}