Java API token定时刷新

主要用到了调度线程池: ScheduleExecutorService, 一个循环方法scheduleWithFixedDelay(方法执行完之后计算下一次开始执行时间)

使用

TokenManager.setDaemon(false);
TokenManager.init(apiKey, SecuretKey);

当然apiKey, SecuretKey 如果只有一个参数，可以自己修改

package com.gwzx.gwzxyw.baidu;
 
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class TokenManager {
 
    private static final Logger logger = LoggerFactory.getLogger(this.getClass());
 
    private static ScheduledExecutorService scheduledExecutorService;
 
    private static Map<String, String> tokenMap = new LinkedHashMap<String, String>();
 
    private static Map<String, ScheduledFuture<?>> futureMap = new HashMap<String, ScheduledFuture<?>>();
 
    private static int poolSize = ;
 
    private static boolean daemon = Boolean.TRUE;
 
    /**
     * 初始化 scheduledExecutorService
     */
    private static void initScheduledExecutorService() {
        logger.info("daemon:{},poolSize:{}", daemon, poolSize);
        scheduledExecutorService = Executors.newScheduledThreadPool(poolSize, new ThreadFactory() {
 
            @Override
            public Thread newThread(Runnable arg0) {
                Thread thread = Executors.defaultThreadFactory().newThread(arg0);
                //设置守护线程
                thread.setDaemon(daemon);
                return thread;
            }
        });
    }
 
    /**
     * 设置线程池
     *
     * @param poolSize poolSize
     */
    public static void setPoolSize(int poolSize) {
        BaiduTokenManager.poolSize = poolSize;
    }
 
    /**
     * 设置线程方式
     *
     * @param daemon daemon
     */
    public static void setDaemon(boolean daemon) {
        BaiduTokenManager.daemon = daemon;
    }
 
    /**
     * 初始化token 刷新，每29天分钟刷新一次。
     *
     * @param access_token  access_token
     */
    public static void init(final String apiKey, final String secretKey) {
        init(apiKey, secretKey, ,  *  *  * );
    }
 
    /**
     * 初始化token 刷新，每29天分钟刷新一次。
     *
     * @param access_token access_token
     * @param initialDelay 首次执行延迟（秒）
     * @param delay        执行间隔（秒）
     */
    public static void init(final String apiKey, final String secretKey, int initialDelay, int delay) {
        if (scheduledExecutorService == null) {
            initScheduledExecutorService();
        } 
 
        if (futureMap.containsKey(apiKey)) {
            futureMap.get(apiKey).cancel(true);
        }
        //立即执行一次
        if (initialDelay == ) {
            doRun(apiKey, secretKey);
        }
        ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                doRun(apiKey, secretKey);
            }
        }, initialDelay ==  ? delay : initialDelay, delay, TimeUnit.SECONDS);
        futureMap.put(apiKey, scheduledFuture);
        logger.info("apiKey:{}", apiKey);
    }
 
    private static void doRun(final String apiKey, final String secretKey) {
        try {
            String access_token = AuthService.getAuth(apiKey, secretKey);
 
            tokenMap.put(apiKey, access_token);
            logger.info("access_token refurbish with apiKey:{}", apiKey);
        } catch (Exception e) {
            logger.error("access_token  refurbish error with apiKey:{}", apiKey);
            e.printStackTrace();
        }
    }
 
    /**
     * 取消 token 刷新
     */
    public static void destroyed() {
        scheduledExecutorService.shutdownNow();
        logger.info("destroyed");
    }
 
    /**
     * 取消刷新
     *
     * @param access_token access_token
     */
    public static void destroyed(String access_token) {
        if (futureMap.containsKey(access_token)) {
            futureMap.get(access_token).cancel(true);
            logger.info("destroyed appid:{}", access_token);
        }
    }
 
    /**
     * 获取
     * @param access_token access_token
     * @return token
     */
    public static String getToken(String access_token) {
        return tokenMap.get(access_token);
    }
 
    /**
     * access_token
     * @return token
     */
    public static String getDefaultToken() {
        Object[] objs = tokenMap.values().toArray();
        return objs.length >  ? objs[].toString() : null;
    }
 
}