Tomcat启动完毕后启动方法任务

Tomcat启动完成后再执行一个指定的方法 - 不影响Tomcat的启动时间

本文主要介绍Tomcat启动真正完成后（即在eclipse的控制台上出现类似于Server started in 2300ms这样的消息后）执行一个操作。 
如下的3种方法都是在Tomcat启动过程中执行的，这样会影响Tomcat的启动时间，从而造成Tomcat不能启动成功：  
1.配置一个Servlet默认自动启动。  
2.配置一个Listener来启动  
3.实现Spring的InitializingBean接口  
要想不影响Tomcat的启动，便联想到了异步调用 。即无非就是新创建了一个线程来单独执行，这样Tomcat执行到相应的操作就可以直接继续下去了，不会处于等待的状态，避免了启动超时。基于这样的思想，可以有两种方法来完成：

方法一： 使用如上三种方式中的任何一种来在启动Tomcat的过程中执行相应的方法，然后在执行的过程中使用另一个线程来执行：比如说将要执行的方法所在的类继承HttpServlet并在web.xml中配置，然后在该Servlet的init中去调用想要执行的方法时（假设这个方法名叫start())，启动另一个线程来执行，具体代码如下。

 package com.cc.ovp.web.video;


 import static com.cc.ovp.util.RedisUtils.getPool;

 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.FutureTask;

 import javax.annotation.Resource;

 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Controller;

 import redis.clients.jedis.Jedis;
 import ayou.util.DOC;
 import ayou.util.StringUtil;

 import com.cc.ovp.dao.M3u8ContentDAO;
 import com.cc.ovp.dao.M3u8_db;
 import com.cc.ovp.domain.M3u8Content;
 import com.cc.ovp.service.MongoSearchService;
 import com.cc.ovp.util.JsonUtil;
 import com.cc.ovp.util.Pager;


 /**
  * 定时清理一下videojson 的redis缓存
  * 需求：
  * 查询m3u8_content的status字段不为8，
  * 就清除redis 缓存，重新set值到redis，
  * cleanRedisVideoJSon(String vid)，
  * 更新m3u8_content的status 字段为8
  */
 @Controller
 public class CleanVideoJsonRedis extends HttpServlet{

     private static final Logger logger = LoggerFactory.getLogger(CleanVideoJsonRedis.class);

     private final int sleepTime=5*60*1000;

     @Resource(name = "m3u8ContentDAO")
     private M3u8ContentDAO m3u8ContentDAO;

     @Resource(name="videoJson")
     private VideoJson videoJson;


     // Servlet的init方法会在Tomcat启动的时候执行
     @Override
     public void init() throws ServletException {
       FutureTask task = new FutureTask(new Callable(){
            @Override
            public String call() throws Exception {
                taskstart(); //使用另一个线程来执行该方法，会避免占用Tomcat的启动时间
               return "Collection Completed";
            }
       });

       new Thread(task).start();;
     }


     public void taskstart(){
         while (true) {
             try {
                 System.out.println("init");
                 System.out.println("==============================");
                 Thread.sleep(5*1000);
                 Pager pager = new Pager(1, 200);
               pager.setSortname("dateAdded");
               pager.setSortorder("desc");
               List list = m3u8ContentDAO.findList(pager);
               System.out.println("=============================="+list.size());
                 logger.info("tomcat 测试方法");
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         }
     }

 }

web.xml配置文件增加一个serlvet

 <servlet>
    <servlet-name>event-collectorservlet-name>
    <servlet-class>com.cc.ovp.web.video.CleanVideoJsonRedisservlet-class>
    <load-on-startup>60load-on-startup>
  servlet>

  <servlet-mapping>
    <servlet-name>event-collectorservlet-name>
    <url-pattern>/event-collecturl-pattern>
  servlet-mapping>

方法二： 配置一个Listener来启动  

web.xml

 <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
 listener>

    <listener>
     <listener-class>com.cc.ovp.web.video.CleanVideoJsonRedislistener-class>
 listener>

注意： 标签一定要在之后，在之前配置

 2。CleanVideoJsonRedis.java
 package myservlet;
 import javax.servlet.*;
 import java.util.*;
 public class CleanVideoJsonRedis implements ServletContextListener{

 public CleanVideoJsonRedis(){
    System.out.println("调用了构造方法");
 }
 public void contextInitialized(ServletContextEvent event) {
    System.out.println(" ----------创建了Context created on " +
    new Date() + ".");
    }
    public void contextDestroyed(ServletContextEvent event) {
    System.out.println("--------销毁了Context destroyed on " +
    new Date() + ".");
    }

 }
 说明:listener 配置在web.xml中，当web服务启动时，会实例化class/>中指定的类，所以里面一定要写完整类路径.

方法三： 使用Spring的Timer或者是著名的Quartz在Tomcat启动后再执行该方法,Spring中的Timer非常简单，这个地方不想讲解了，Quartz相对更复杂些，下面主要介绍下在Spring中怎么样使用Quartz来实现上面的需求：

例子：

 package com.cc.ovp.web.video;


 import static com.cc.ovp.util.RedisUtils.getPool;

 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.FutureTask;

 import javax.annotation.Resource;
 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;

 import org.quartz.Job;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Controller;

 import redis.clients.jedis.Jedis;
 import ayou.util.DOC;
 import ayou.util.StringUtil;

 import com.cc.ovp.dao.M3u8ContentDAO;
 import com.cc.ovp.dao.M3u8_db;
 import com.cc.ovp.domain.M3u8Content;
 import com.cc.ovp.service.MongoSearchService;
 import com.cc.ovp.util.JsonUtil;
 import com.cc.ovp.util.Pager;


 /**
  * 定时清理一下videojson 的redis缓存
  * 需求：
  * 查询m3u8_content的status字段不为8，
  * 就清除redis 缓存，重新set值到redis，
  * cleanRedisVideoJSon(String vid)，
  * 更新m3u8_content的status 字段为8
  */
 @Controller
 public class CleanVideoJsonRedis implements Job{

     private static final Logger logger = LoggerFactory.getLogger(CleanVideoJsonRedis.class);

     private final int sleepTime=5*60*1000;

     @Resource(name = "m3u8ContentDAO")
     private M3u8ContentDAO m3u8ContentDAO;

     @Resource(name="videoJson")
     private VideoJson videoJson;


     @Override
     public void execute(JobExecutionContext arg0) throws JobExecutionException {
         // TODO Auto-generated method stub
     }

     public void executeA() throws JobExecutionException {
         // TODO Auto-generated method stub
         logger.info("==========clean redis videojson");
         //cleanRedis();
     }

     /**
      * 每隔5分钟，执行一次 时间,
      * 在spring配置文件设置 dispatcher-servlet.xml
      */
     public void cleanRedis(){
            Pager pager = new Pager(1, 2000);
            pager.setSortname("dateAdded");
            pager.setSortorder("desc");
            List list = m3u8ContentDAO.findList(pager);
            if(list.size()>0){
                for(int i=0;i
                    M3u8Content m3u8content = new M3u8Content();
                    cleanRedisVideoJSon(m3u8content.getVideoPoolId());//覆盖redis.videojson缓存
                    logger.info("定时程序， 覆盖redis.videojson缓存");
                    //更改状态
                    m3u8content.setStatus(8);
                    m3u8ContentDAO.updateStatus(m3u8content);
                    logger.info("定时程序， 修改m3u8_content的status的值为8");
                }
            }
     }

     /**
      * 定时清除videoJson 的redis缓存
      */
     public void cleanRedisVideoJSon(String vid){
             Jedis jedis = null;
             //String userid = vid.substring(0,10);
             //String jsonbody = JsonUtil.docToJson(vdoc);
             jedis = getPool().getResource();
             String videokey = "videojson_"+vid;
             //String userkey = "userjson_"+userid;
             String videojson = jedis.get(videokey);
             if(!StringUtil.isFine(videojson)){
                 DOC vdoc = videoJson.videoJson(vid);
                 if (vdoc!=null && vdoc.size()!=0){
                     videojson = JsonUtil.docToJson(vdoc);
                     //预防缓存了空json
                     if(videojson.length()>10){
                         jedis.set(videokey, videojson);
                     }
                 }
             }
     }


     /**
      * 测试方法
      */
     public void taskstart(){
         System.out.println("init");
         Pager pager = new Pager(1, 1000);
 //      pager.setSortname("dateAdded");
 //      pager.setSortorder("desc");
           logger.info("================s==============");
           List list = m3u8ContentDAO.findList(pager);
           logger.info("==================s============"+list.size());
           logger.info("==================u============");

           cleanRedisVideoJSon("fffdd2a8ecfdddfa9aee376070e1c759");//覆盖redis.videojson缓存
           M3u8Content m3u8content = new M3u8Content();
           m3u8content.setBitRateIndex(1);
           m3u8content.setVideoPoolId("fffdd2a8ecfdddfa9aee376070e1c759");
           m3u8content.setStatus(8);
           m3u8ContentDAO.updateStatus(m3u8content);
           logger.info("==================u============");
            logger.info("tomcat 测试方法");
     }

 }

spring 定时任务调度设置：（在spring配置文件增加如下配置）

     <bean id="initJob" class="com.cc.ovp.web.video.CleanVideoJsonRedis" />


     <bean id="initJobDetail"
         class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject" ref="initJob" />
         <property name="targetMethod" value="executeA" />

     bean>

     <bean id="initTrigger"
         class="org.springframework.scheduling.quartz.SimpleTriggerBean">
         <property name="jobDetail" ref="initJobDetail" />
         <property name="startDelay" value="10000" />
         <property name="repeatInterval" value="300000" />

     bean>

     <bean id="schedulerFactory"
         class="org.springframework.scheduling.quartz.SchedulerFactoryBean" autowire="no">
         <property name="triggers">
             <list>
                 <ref bean="initTrigger" />
             list>
         property>
         <property name="autoStartup" value="true"/>
     bean>

并发执行设置

是设置执行模式的，大概意思是：比如您设置了5分钟，可以在该任务执行之后的5分钟后继续执行下一次，就是上一次任务必须执行完毕之后执行下一次。还有就是无论上次任务有没有执行完毕，那么过五分钟之后继续执行下次任务。

 

     <bean id="initJob" class="com.cc.ovp.web.video.CleanVideoJsonRedis" />


     <bean id="initJobDetail"
         class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject" ref="initJob" />
         <property name="targetMethod" value="executeA" />
         <property name="concurrent" value="false" />

     bean>

     <bean id="initTrigger"
         class="org.springframework.scheduling.quartz.SimpleTriggerBean">
         <property name="jobDetail" ref="initJobDetail" />
         <property name="startDelay" value="10000" />
         <property name="repeatInterval" value="1000" />
     bean>

     <bean id="schedulerFactory"
         class="org.springframework.scheduling.quartz.SchedulerFactoryBean" autowire="no">
         <property name="triggers">
             <list>
                 <ref bean="initTrigger" />
             list>
         property>
         <property name="autoStartup" value="true"/>
     bean>

或者使用Java的线程池实现：

 public void execute() throws InterruptedException {
     System.out.println("Start job");
     ExecutorService exec = Executors.newFixedThreadPool(1);

     Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
             System.out.println("thread start");
             try {
                 Thread.sleep(3000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println("thread end");
         }
     });
     exec.execute(thread);
     exec.shutdown();
        while (!exec.isTerminated()) {
            // 等待所有子线程结束，才退出主线程
        }
     System.out.println("end job");
 }

OK，至此spring quartz多线程并发问题解决。回顾下，我们要使用isTerminated()方法等多线程结束后在结束job；多线程任务派发结束后，要使用shutdown()方法顺序关闭线程（等待正在执行任务，不接受新任务）