全部代码下载,在这———————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;
}
}