Java微信公众号开发----定时获取access_token并保存到redis中

本人原本是想做微信公众号菜单的创建修改删除等操作的，但是发现需要access_token，通过阅读文档，发现文档要求有以下几点：

1.access_token 获取后有效期是2小时

2.access_token 占用512个字符空间

3.获取access_token 的url 为（get请求） ：  https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET

4.请求成功返回的格式为：{"access_token":"ACCESS_TOKEN","expires_in":7200}

思路：

1.前提必须是成功获取到 access_token

2. 项目里需要配置一个定时器，用来定期获取 access_token

3.成功获取后应该把access_token妥善保存，比如保存在 数据库、缓存（本人所选，redis）、配置文件中都可以

步骤一：获取access_token

 package com.encore.util;
 
 import org.json.JSONObject;
 
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
 
 public class WeChatTokenUtil {
     //获取access_token的url
     private static final String BASE_TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token?";
     //固定值
     private static final String GRANT_TYPE = "client_credential";
     //自己的AppID
     private static final String APP_ID = "**********";
     //自己的AppSecret
     private static final String SECRET = "***********";
 
     public static String getToken(){
         String url = BASE_TOKEN_URL + "grant_type="+GRANT_TYPE+"&appid="+APP_ID+"&secret="+SECRET;
         try{
             URL realUrl = new URL(url);
             // 打开和URL之间的连接
             HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
             connection.setRequestMethod("GET");
             connection.connect();
             // 获取所有响应头字段
             Map<String, List<String>> map = connection.getHeaderFields();
             // 遍历所有的响应头字段
             for (String key : map.keySet()) {
                 System.err.println(key + "--->" + map.get(key));
             }
             // 定义 BufferedReader输入流来读取URL的响应
             BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
             String result = "";
             String line;
             while ((line = in.readLine()) != null) {
                 result += line;
             }
             JSONObject jsonObject = new JSONObject(result);
             return jsonObject.getString("access_token");
         } catch (Exception e) {
             System.err.printf("获取token失败！");
             e.printStackTrace(System.err);
             return "";
         }
     }
 
 }

步骤二：配置定时器：

在spring的xml中配置：

 <!-- 定时器配置 -->
     <task:annotation-driven scheduler="myScheduler"/>
     <task:scheduler id="myScheduler" pool-size="5"/>

注意：写定时方法的类必须在spring能够扫描的到的包下

步骤三：配置redis（如果不用redis可以跳过此步骤，直接把access_token保存到数据库或者配置文件中就可以了）

1.前提是本机装了redis，网上有很多教程，本文不做过多介绍，并不复杂

2.引入项目需要的redis依赖

 <!-- redis 依赖 -->
       <dependency>
           <groupId>redis.clients</groupId>
           <artifactId>jedis</artifactId>
           <version>2.9.0</version>
           <type>jar</type>
       </dependency>

3.配置reids连接（跟配置jdbc连接类似）

 redis.host=127.0.0.1
 redis.port=6379
 redis.timeout=3000

4.新建一个reids.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
     <context:property-placeholder location="classpath:redis.properties" />
 
     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" />
 
     <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool" scope="singleton" >
         <constructor-arg index="0" ref="jedisPoolConfig" />
         <constructor-arg index="1">
             <list>
                 <bean class="redis.clients.jedis.JedisShardInfo">
                     <constructor-arg name="host" value="${redis.host}"/>
                     <constructor-arg name="port" value="${redis.port}"/>
                     <constructor-arg name="timeout" value="${redis.timeout}"/>
                 </bean>
             </list>
         </constructor-arg>
     </bean>
 
 </beans>

5.将redis.xml引入到spring的xml中

 <import resource="redis.xml"/>

6.编写一个redis连接池的类，包含安全关闭连接池的方法，同样也要使这个类能够被spring所扫描到

 package com.encore.service;
 
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import redis.clients.jedis.ShardedJedis;
 import redis.clients.jedis.ShardedJedisPool;
 
 import javax.annotation.Resource;
 
 @Service("redisPool")
 @Slf4j
 public class RedisPool {
 
     @Resource(name = "shardedJedisPool")
     private ShardedJedisPool shardedJedisPool;
 
     public ShardedJedis instance(){
         return shardedJedisPool.getResource();
     }
 
     public void safeClose(ShardedJedis shardedJedis){
         try {
             if (shardedJedis != null){
                 shardedJedis.close();
             }
         }catch (Exception e){
             log.error("redis 关闭异常", e);
         }
     }
 }

7.封装一个类，提供把数据写入redis和从redis中读取数据的方法，也要让这个类被spring所管理

 package com.encore.service;
 
 import org.springframework.stereotype.Service;
 import redis.clients.jedis.ShardedJedis;
 
 import javax.annotation.Resource;
 
 @Service("redisCacheService")
 public class RedisCacheService {
 
     // 注入RedisPool
     @Resource(name = "redisPool")
     private RedisPool redisPool;
 
     /**
      *  把要存储的值放进缓存
      * @param cacheKey 键值，可以用来获取要存储的值
      * @param toSavedValue 要存储的值
      * @param timeOutSeconds 过期时间 单位为秒
      */
     public void saveCache(String cacheKey, String toSavedValue, int timeOutSeconds){
         if (toSavedValue == null){
             return;
         }
         ShardedJedis shardedJedis =  null;
         try {
             shardedJedis = redisPool.instance();
             shardedJedis.setex(cacheKey, timeOutSeconds, toSavedValue);
         }catch (Exception e){
             e.printStackTrace();
         }finally {
             redisPool.safeClose(shardedJedis);
         }
     }
 
     /**
      * 根据键值从缓存中获取数据
      * @param cacheKey 缓存的键值
      * @return
      */
     public String getFromCache(String cacheKey){
         ShardedJedis shardedJedis = null;
         try {
             shardedJedis = redisPool.instance();
             String value = shardedJedis.get(cacheKey);
             return value;
         }catch (Exception e){
             return null;
         }finally {
             redisPool.safeClose(shardedJedis);
         }
     }
 
 }

步骤四：实现定时器的方法（这个类要可以被spring扫描的到），实现每1.5小时获取一次access_token，并将其放到redis，同时保证可以从redis中读取出来

 package com.encore.service;
 
 import com.encore.util.WeChatTokenUtil;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
 
 @Component
 public class TaskService {
 
     @Resource
     private RedisCacheService redisCacheService;
 
     private static final String TOKEN_KEY = "my_wechat_token";
 
     @Scheduled(fixedRate= 1000*60*90, initialDelay = 2000)//项目启动2秒中之后执行一次，然后每90min执行一次，单位都为ms
     public void getToken(){
         //1. 获取token
         String access_token = WeChatTokenUtil.getToken();
         System.out.println("从微信服务器获取的token======"+access_token);
         redisCacheService.saveCache(TOKEN_KEY, access_token ,60*120);
         String getToken = redisCacheService.getFromCache(TOKEN_KEY);
         System.out.println("从redis中获取的token === "+getToken);
     }
 }

最后，在开启项目进行测试的时候，先把redis服务器打开，经测试，可以正常获取access_token，也可以存放到redis中，同时也可以从redis中读取出来，如图所示，可以从Redis Desktop Manager中看得到存放进去的access_token: