java项目 定时任务执行

阅读更多

在项目中经常会用到执行定时任务，下面的两种是我在做项目的时候用到的两种

（1）spring task

在spring.xml中beans xmlns添加

 

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.0.xsd

 

 

 timeTaskServiceImpl  为你要执行的类，cron来定义您执行时间

 

（2）java自带的类 ScheduledExecutorService

 

首先我们先建一个工具类commontimer

package com.wonder.Util;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 * 通用定时任务
 */
public class CommonTimer {

    private final static ScheduledExecutorService scheduler;

    static {
        scheduler = Executors.newSingleThreadScheduledExecutor();
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                scheduler.shutdown();
            }
        });
    }

    private static CommonTimer instance = new CommonTimer();

    private CommonTimer() {
    }

    public static CommonTimer getInstance() {
        return instance;
    }

    /**
     * 创建并执行在给定延迟后启用的 ScheduledFuture
     *
     * @param command
     * @param delay   秒
     * @return
     */
    public ScheduledFuture scheduleWithSeconds(Runnable command, long delay) {
        return scheduler.schedule(command, delay, TimeUnit.SECONDS);
    }

    /**
     * 创建并执行在给定延迟后启用的 ScheduledFuture
     *
     * @param command
     * @param delay   毫秒
     * @return
     */
    public ScheduledFuture scheduleWithMilliSeconds(Runnable command, long delay) {
        return scheduler.schedule(command, delay, TimeUnit.MILLISECONDS);
    }

    /**
     * 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在
     * initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
     *
     * @param command
     * @param delay   秒
     * @param period  秒
     * @return
     */
    public ScheduledFuture scheduleAtFixedRateWithSeconds(Runnable command, long delay, long period) {
        return scheduler.scheduleAtFixedRate(command, delay, period, TimeUnit.SECONDS);
    }

    /**
     * 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在
     * initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
     *
     * @param command
     * @param delay   毫秒
     * @param period  毫秒
     * @return
     */
    public ScheduledFuture scheduleAtFixedRateWithMilliSeconds(Runnable command, long delay, long period) {
        return scheduler.scheduleAtFixedRate(command, delay, period, TimeUnit.MILLISECONDS);

    }
}

 

里面封装了几个定时执行的方法

然后建一个TimeTaskListener

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

/**
 * Created by Guozhijie on 2016/9/20.
*/
@Component("timeTaskListener")
public class TimeTaskListener implements ApplicationListener {
  @Autowired
    TimeTaskService timeTaskService;

    @Override
    public   void onApplicationEvent(ContextRefreshedEvent e){
        CommonTimer.getInstance().scheduleAtFixedRateWithSeconds(timeTaskService,1,60*1);
    }
}

 实现了 spring的 applicationListener ，即为每次在启动项目的时候，在各个service类加载完成之后，开始执行

 

多说一句，applicationListener 这个类，很适合 在项目启动适合将一些缓存的数据加载出来

 

 

附：TimeTaskServiceImpl类 

 

package com.wonder.provider;

import com.wonder.exception.ServiceException;
import com.wonder.service.TimeTaskService;
import org.springframework.stereotype.Service;

/**
 * Created by Guozhijie on 2016/9/20.
 */
@Service
public class TimeTaskServiceImpl implements TimeTaskService, Runnable {
    public void task() throws ServiceException {
        try{
            System.out.println("***********************111111");
        }catch (Exception e){
            throw e;
        }

    }
    public void run(){
          task();
    }
}