java MVC 定時器

（1）
try{
   Date actualBeginTime = liveWebcastTask.getActualBeginTime();
   Date endTime =  liveWebcastTask.getEndTime();
   int diffDate = DateUtils.dateTimeNums(actualBeginTime,endTime,"MINUTE");
   int repeatCount = diffDate/5;
   logger.info("添加直播監控定時任務，市級開始時間爲："+actualBeginTime+"，設置結束時間爲："+endTime+",計算出來任務重複次數爲："+repeatCount);
   addLiveMonitorTask(Long.parseLong(liveId),endTime,repeatCount);

}catch (Exception e){
   logger.error("添加直播監控定時任務錯誤，錯誤原因爲："+e.getMessage());

}

（2）

/**
    * 異步添加直播監控定時任務
    * @return
    */
   public void addLiveMonitorTask(final Long liveId,final Date endTime,final  int repeatCount) {
     
      logger.info("當前活動線程數："+ taskExecutor.getActiveCount());

      logger.info("線程處理隊列長度"+taskExecutor.getThreadPoolExecutor().getQueue().size());

      //用異步線程執行，確保快速返回
      taskExecutor.execute(new Runnable() {
         @Override
         public void run() {
            try{
               //添加定時任務
               QuartzJobDto quartz = new QuartzJobDto();
               quartz.setJobName("live-monitor-job-"+liveId);
               quartz.setJobGname("live-monitor-gJob-"+liveId);
               quartz.setTriggerName("live-monitor-trigger-"+liveId);
               quartz.setTriggerGname("live-monitor-trigger-gTrigger-"+liveId);
               quartz.setIntervalInSeconds(5*60);
               quartz.setScheduleType(QuartzJobDto.TYPE_SIMPLE);
               quartz.setRepeatCount(repeatCount);//重複多少次
               quartz.setJobClass("com.u1city.shop.service.LiveMonitorScheduleJobService");
               Map<String,Object> jobData = new HashMap<>();
               jobData.put("liveId",liveId);
               jobData.put("endTime",endTime);
               quartz.setJobData(jobData);
               quartzManagerService.addJob(quartz);
               logger.info("addLiveMonitorTask，執行直播監控定時任務線程，liveId:"+liveId);
            }catch(Exception e){
               logger.error("addLiveMonitorTask，執行直播監控定時任務線程報錯，liveId:"+liveId+",錯誤信息爲："+e.getMessage());
               logger.error(e.getMessage(),e);
            }
         }
      });
   }

（3）

package com.u1city.shop.service;

import com.u1city.shop.commonUtils.DateUtils;
import com.u1city.shop.commonUtils.SpringContextUtil;
import com.u1city.shop.constant.TmallShopConstant;
import com.u1city.shop.domain.EasyChannelItem;
import com.u1city.shop.domain.StoreCoupon;
import com.u1city.shop.domain.StoreIntegralExchange;
import com.u1city.shop.dto.QuartzJobDto;
import com.u1city.shop.dto.StoreIntegralExchangeDto;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;


import java.util.Date;
import java.util.Map;


/**
 * @category 積分兌換定時任務
 * @author chenlu
 * @data : 20190906
 */
@Component("liveMonitorScheduleJobService")
public class LiveMonitorScheduleJobService implements Job {

    public static Logger logger = LoggerFactory.getLogger(LiveMonitorScheduleJobService.class);


    private    LiveMonitorService liveMonitorService;


    private QuartzManagerService quartzManagerService;

    public LiveMonitorScheduleJobService()
    {
        liveMonitorService  = SpringContextUtil.getBeanByType(LiveMonitorService.class);

        quartzManagerService = SpringContextUtil.getBeanByType(QuartzManagerService.class);
    }

    /**
     * @category 查詢所有的兌換中的週期積分兌換任務
     * @author pxc
     * @date 20190906
     */
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        try {
            SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
            JobDataMap dataMap = context.getJobDetail().getJobDataMap();
            if(dataMap!=null && dataMap.get("jobData")!=null)
            {
               Map<String,Object> data = (Map<String,Object>)dataMap.get("jobData");
               Long liveId = (Long)data.get("liveId");
               if(!StringUtils.isEmpty(liveId))
               {
                   Date endTime = (Date)data.get("endTime");
                     if (endTime != null) {
                         Date nowDate = new Date();
                         int compareResult = nowDate.compareTo(endTime);
                         if (compareResult >= 0) {
                             logger.info("LiveMonitorScheduleJobService，移除直播監控定時任務，liveId:"+liveId);
                             QuartzJobDto quartz = new QuartzJobDto();
                             quartz.setJobName("live-monitor-job-"+liveId);
                             quartz.setJobGname("live-monitor-gJob-"+liveId);
                             quartz.setTriggerName("live-monitor-trigger-"+liveId);
                             quartz.setTriggerGname("live-monitor-trigger-gTrigger-"+liveId);
                             quartzManagerService.removeJob(quartz);
                         }
                     }
                     
                     logger.info("LiveMonitorScheduleJobService，插入直播監控數據……liveId:"+liveId);
                     liveMonitorService.insertLiveMonitor(liveId);
               }
               
               
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（4）

package com.u1city.shop.service;

import com.u1city.shop.commonUtils.DateUtils;
import com.u1city.shop.domain.LiveWebcastTask;
import com.u1city.shop.service.rongcloud.RongCloudService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Service
public class LiveMonitorService {

    public static Logger logger = LoggerFactory.getLogger(LiveMonitorService.class);

    @Autowired
    LiveWebcastTaskService liveWebcastTaskService;

    @Autowired
    RongCloudService rongCloudService;


        public void insertLiveMonitor(Long liveId) throws Exception {

            logger.info("插入直播監控數據，insertLiveMonitor……"+liveId);

        LiveWebcastTask redisLiveTask = liveWebcastTaskService.getLiveWebcastTaskByLiveIdFromCache(liveId);


        if (redisLiveTask.getStatus().intValue() == 3) {//直播中,只有直播中才需要插入直播數據
            //聊天室實際在線人數，從融雲獲取
            Integer chatRoomTotal=null;
            try {
                chatRoomTotal = rongCloudService.queryChatroomInfo(redisLiveTask.getGroupId(), "1", "1");
            } catch (Exception e) {
                logger.error("LiveMonitorService獲取觀看人數失敗，liveId"+liveId);
            }
            Integer onlineUsersNum = chatRoomTotal == null ? 0 : chatRoomTotal;

            Map<String,Object> map = new HashMap<>();
            map.put("liveMonitorId", UUID.randomUUID().toString());
            map.put("liveId",liveId);
            map.put("subject",redisLiveTask.getSubject());
            map.put("virtualUsersNum",redisLiveTask.getVirtualUsersNum());
            map.put("acturalUsersNum",onlineUsersNum);
            map.put("createTime",new Date());
            liveWebcastTaskService.insertLiveMonitor(map);
        }

    }
}