定时获取微信的AccessToken

使用Quartz 2.2.3开启定时任务，每个整点获取一次，如下：

String jobName = "GetWeixinAccessToken";
String triggerName = jobName;
// 每个整点执行一次
quartzManager.addJob(jobName, triggerName, WeixinAccessTokenJob.class, "0 0 */1 * * ?", wxAccesstokenManager);

QuartzManager使用Spring注入：


import java.util.Date;
import java.util.List;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.stereotype.Service;

@Service
public class QuartzManager {
    public static SchedulerFactory schedulerFactory = new StdSchedulerFactory();  

    public void addJob(String jobName, String triggerName,
            Class jobClass, String cron, Object obj) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            // 任务名，任务组，任务执行类
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(jobName).build();
            jobDetail.getJobDataMap().put("obj", obj);
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder
                    .newTrigger();
            // 触发器名
            triggerBuilder.withIdentity(triggerName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();

            // 调度容器设置JobDetail和Trigger
            sched.scheduleJob(jobDetail, trigger);

            // 启动
            if (!sched.isShutdown()) {
                sched.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
        /** 
         * @Description: 添加一个定时任务 
         *  
         * @param jobName 任务名 
         * @param jobGroupName  任务组名 
         * @param triggerName 触发器名 
         * @param triggerGroupName 触发器组名 
         * @param jobClass  任务 
         * @param cron   时间设置，参考quartz说明文档  
         */  
        @SuppressWarnings({ "unchecked", "rawtypes" })  
        public void addJob(String jobName, String jobGroupName, 
                String triggerName, String triggerGroupName, Class jobClass, String cron) {  
            try {  
                Scheduler sched = schedulerFactory.getScheduler();  
                // 任务名，任务组，任务执行类
                JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();

                // 触发器  
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组  
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定  
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                // 创建Trigger对象
                CronTrigger trigger = (CronTrigger) triggerBuilder.build();

                // 调度容器设置JobDetail和Trigger
                sched.scheduleJob(jobDetail, trigger);  

                // 启动  
                if (!sched.isShutdown()) {  
                    sched.start();  
                }  
            } catch (Exception e) {  
                throw new RuntimeException(e);  
            }  
        }  

    /**
     * 修改任务的触发时间
     * @param jobName
     * @param triggerName
     * @param cron
     */
    public void modifyJobTime(String jobName, String triggerName,
            String cron) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName);
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                /** 方式一 ：调用 rescheduleJob 开始 */
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder
                        .newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder
                        .cronSchedule(cron));
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 ：修改一个任务的触发时间
                sched.rescheduleJob(triggerKey, trigger);
                /** 方式一 ：调用 rescheduleJob 结束 */

                /** 方式二：先删除，然后在创建一个新的Job */
                // JobDetail jobDetail =
                // sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
                // Class<? extends Job> jobClass = jobDetail.getJobClass();
                // removeJob(jobName, jobGroupName, triggerName,
                // triggerGroupName);
                // addJob(jobName, jobGroupName, triggerName, triggerGroupName,
                // jobClass, cron);
                /** 方式二 ：先删除，然后在创建一个新的Job */
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
        /** 
         * @Description: 修改一个任务的触发时间
         *  
         * @param jobName 
         * @param jobGroupName
         * @param triggerName 触发器名
         * @param triggerGroupName 触发器组名 
         * @param cron   时间设置，参考quartz说明文档   
         */  
        public void modifyJobTime(String jobName, 
                String jobGroupName, String triggerName, String triggerGroupName, String cron) {  
            try {  
                Scheduler sched = schedulerFactory.getScheduler();  
                TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
                CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);  
                if (trigger == null) {  
                    return;  
                }  

                String oldTime = trigger.getCronExpression();  
                if (!oldTime.equalsIgnoreCase(cron)) { 
                    /** 方式一 ：调用 rescheduleJob 开始 */
                    // 触发器  
                    TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                    // 触发器名,触发器组  
                    triggerBuilder.withIdentity(triggerName, triggerGroupName);
                    triggerBuilder.startNow();
                    // 触发器时间设定  
                    triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                    // 创建Trigger对象
                    trigger = (CronTrigger) triggerBuilder.build();
                    // 方式一 ：修改一个任务的触发时间
                    sched.rescheduleJob(triggerKey, trigger);
                    /** 方式一 ：调用 rescheduleJob 结束 */

                    /** 方式二：先删除，然后在创建一个新的Job  */
                    //JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));  
                    //Class<? extends Job> jobClass = jobDetail.getJobClass();  
                    //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);  
                    //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron); 
                    /** 方式二 ：先删除，然后在创建一个新的Job */
                }  
            } catch (Exception e) {  
                throw new RuntimeException(e);  
            }  
        }  

    /**
     * @Description: 移除一个任务
     * 
     * @param jobName
     * @param triggerName
     */
    public void removeJob(String jobName, String triggerName) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName);
            sched.pauseTrigger(triggerKey);// 停止触发器
            sched.unscheduleJob(triggerKey);// 移除触发器
            sched.deleteJob(JobKey.jobKey(jobName));// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
        /** 
         * @Description: 移除一个任务 
         *  
         * @param jobName 
         * @param jobGroupName 
         * @param triggerName 
         * @param triggerGroupName 
         */  
        public void removeJob(String jobName, String jobGroupName,  
                String triggerName, String triggerGroupName) {  
            try {  
                Scheduler sched = schedulerFactory.getScheduler();  

                TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

                sched.pauseTrigger(triggerKey);// 停止触发器  
                sched.unscheduleJob(triggerKey);// 移除触发器  
                sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务  
            } catch (Exception e) {  
                throw new RuntimeException(e);  
            }  
        }  

        /** 
         * @Description:启动所有定时任务 
         */  
        public static void startJobs() {  
            try {  
                Scheduler sched = schedulerFactory.getScheduler();  
                sched.start();  
            } catch (Exception e) {  
                throw new RuntimeException(e);  
            }  
        }  

        /** 
         * @Description:关闭所有定时任务 
         */  
        public static void shutdownJobs() {  
            try {  
                Scheduler sched = schedulerFactory.getScheduler();  
                if (!sched.isShutdown()) {  
                    sched.shutdown();  
                }  
            } catch (Exception e) {  
                throw new RuntimeException(e);  
            }  
        }
        
        /**
         * 判断JobName是否在执行队列中
         * @param jobName
         * @return
         */
        public synchronized static boolean isJobExist(String jobName) throws SchedulerException {
            boolean isExistJob = false;
            Scheduler scheduler = schedulerFactory.getScheduler();
            for (String groupName : scheduler.getJobGroupNames()) {
                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher
                        .jobGroupEquals(groupName))) {
                    String tmpJobName = jobKey.getName();
                    String jobGroup = jobKey.getGroup();
                    // get job's trigger
                    @SuppressWarnings("unchecked")
                    List<Trigger> triggers = (List<Trigger>) scheduler
                    .getTriggersOfJob(jobKey);
                    Date nextFireTime = triggers.get(0).getNextFireTime();
                    System.out.println("[jobName] : " + tmpJobName
                            + " [groupName] : " + jobGroup + " - "
                            + nextFireTime);
                    if (tmpJobName.equals(jobName)) {
                        return true;
                    }
                }
            }
            return isExistJob;
        }
}

在Spring ApplicationContext注入后，才可获取bean，web.xml配置拦截如下：

<!--Spring ApplicationContext 载入 -->
<listener>
    <!-- <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> -->
    <listener-class>com.test.hello.ContextLoaderListenerOverWrite</listener-class>
</listener>

拦截类是为了获取manager，然后存放AccessToken到数据库中。实现如下：

public class ContextLoaderListenerOverWrite extends ContextLoaderListener {

    @Override
    public void contextInitialized(ServletContextEvent event) {
        // TODO Auto-generated method stub
        super.contextInitialized(event);
        ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(event.getServletContext());  
            startGetWeixinAccessTokenJobs(applicationContext);
    }
    /**
     * 开启整点定时任务
     */
    public void startGetWeixinAccessTokenJobs(ApplicationContext ctx) {
        WxBean currentBean = Utility.getAccessToken();
        WxAccesstoken currentToken = new WxAccesstoken();
        currentToken.setAccesstoken(currentBean.getAccess_token());
        currentToken.setExpiresIn(Integer.valueOf(currentBean.getExpires_in()));
        currentToken.setLastRequestTime(new Date());
        
        QuartzManager quartzManager = (QuartzManager)ctx.getBean("quartzManager");
        WxAccesstokenManager wxAccesstokenManager = (WxAccesstokenManager)ctx.getBean("wxAccesstokenManager");
        WxAccesstoken dbWxToken = wxAccesstokenManager.findFirst();
        if (dbWxToken == null) {    // 新增Token
            wxAccesstokenManager.save(currentToken);
            System.out.println("新增Token：" + currentToken);
        } else {    // 更新Token
            currentToken.setId(dbWxToken.getId());
            wxAccesstokenManager.update(currentToken);
            System.out.println("更新Token：" + currentToken);
        }
        String jobName = "GetWeixinAccessToken";
        String triggerName = jobName;
        // 每个整点执行一次
        quartzManager.addJob(jobName, triggerName, WeixinAccessTokenJob.class, "0 0 */1 * * ?", wxAccesstokenManager);
    }
}

获取微信AccessToken的办法如下：

/**
 * 获取微信的AccessToken
 * @return
 */
public static WxBean getAccessToken() {
    WxBean bean = null;
    Map<String, String> params = new HashMap<String, String>();
    params.put("grant_type", "client_credential");
    params.put("appid", Constants.WEIXIN_APPID);
    params.put("secret", Constants.WEIXIN_APPSECRET);
    try {
        String jstoken = HttpUtils.sendGet(
                "https://api.weixin.qq.com/cgi-bin/token", params);
        // String access_token = JSONObject.fromObject(jstoken).getString(
        // "access_token"); // 获取到token并赋值保存
        ObjectMapper objectMapper = JsonUtils.createObjectMapper();
        try {
            bean = objectMapper.readValue(jstoken, WxBean.class);
        } catch (JsonParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JsonMappingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return bean;
}

对了，还有关键的部分，在这个Job里面每个整点更新AccessToken

public class WeixinAccessTokenJob implements Job{
    
    public WeixinAccessTokenJob() {
    }
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印任务详情  
        System.out.println( "WeixinTokenJob:" + "-" +
                context.getJobDetail().getKey().getGroup() 
                +"——"+context.getJobDetail().getKey().getName()  
                +"——"+context.getTrigger().getKey().getName()  
                +"——"+context.getTrigger().getKey().getGroup() + new Date());
                JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
                WxAccesstokenManager wxAccesstokenManager = (WxAccesstokenManager)jobDataMap.get("obj");
        // Todo 使用wxAccesstokenManager来管理数据库存放的AccessToken
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,884评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,755评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,369评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,799评论 1赞 285
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,910评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,096评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,159评论 3赞 411
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,917评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,360评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,673评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,814评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,509评论 4赞 334
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,156评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,882评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,123评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,641评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,728评论 2赞 351

推荐阅读更多精彩内容

  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,778评论 6赞 342
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,638评论 18赞 139
  • 无标题文章
    spring官方文档：http://docs.spring.io/spring/docs/current/spri...
    牛马风情阅读 1,653评论 0赞 3
  • 【短篇】红与黑
    她和她第一次见面是在食堂。 盛夏的雨天。 为了能够方便区分，我们把她称为红衣的她，把她称为黑衣的她。再简单一点，把...
    W晓花阅读 639评论 0赞 3
  • 孩子反复是正常的事，别指望孩子像钟表一样
    1.感赏儿子继续做到不玩游戏,学习效率特别高,自制力越来越好!感赏儿子百度查东西，用语音输入，比我的习惯打字快多了...
    玫瑰铿锵阅读 252评论 2赞 9