第五篇 ：微信公众平台开发实战Java版之如何获取公众号的access_token以及缓存access_token

一、access_token简介

为了使第三方开发者能够为用户提供更多更有价值的个性化服务，微信公众平台 开放了许多接口，包括自定义菜单接口、客服接口、获取用户信息接口、用户分组接口、群发接口等，

开发者在调用这些接口时，都需要传入一个相同的参数 access_token，它是公众账号的全局唯一票据，它是接口访问凭证。

access_token是公众号的全局唯一票据，公众号调用各接口时都需使用access_token。开发者需要进行妥善保存。

access_token的存储至少要保留512个字符空间。

access_token的有效期目前为2个小时，需定时刷新，重复获取将导致上次获取的 access_token失效。

如果第三方不使用中控服务器，而是选择各个业务逻辑点各自去刷新access_token，那么就可能会产生冲突，导致服务不稳定。

公众号可以使用AppID和AppSecret调用本接口来获取access_token。AppID和AppSecret可在微信公众平台官网-开发者中心页中获得（需要已经成为开发者，且帐号没有异常状态）。注意调用所有微信接口时均需使用https协议。

access_token的有效期是7200秒（两小时），在有效期内，可以一直使用，只有当access_token过期时，才需要再次调用接口 获取access_token。在理想情况下，一个7x24小时运行的系统，每天只需要获取12次access_token，即每2小时获取一次。如果在 有效期内，再次获取access_token，那么上一次获取的access_token将失效。

目前，获取access_token接口的调用频率限制为2000次/天，如果每次发送客服消息、获取用户信息、群发消息之前都要先调用获取 access_token接口得到接口访问凭证，这显然是不合理的，一方面会更耗时（多了一次接口调用操作），另一方面2000次/天的调用限制恐怕也不 够用。因此，在实际应用中，我们需要将获取到的access_token存储起来，然后定期调用access_token接口更新它，以保证随时取出的 access_token都是有效的。

我们先看看官方的说明：

接口调用请求说明

http请求方式: GET
https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET

参数说明

参数	是否必须	说明
grant_type	是	获取access_token填写client_credential
appid	是	第三方用户唯一凭证
secret	是	第三方用户唯一凭证密钥，即appsecret

返回说明

正常情况下，微信会返回下述JSON数据包给公众号：

{"access_token":"ACCESS_TOKEN","expires_in":7200}

参数	说明
access_token	获取到的凭证
expires_in	凭证有效时间，单位：秒

错误时微信会返回错误码等信息，JSON数据包示例如下（该示例为AppID无效错误）:

{"errcode":40013,"errmsg":"invalid appid"}

二、封装基本类

封装一下token类：

 

package com.souvc.weixin.pojo;

/**
* 类名: Token </br>
* 描述: 凭证 </br>
* 开发人员： souvc </br>
* 创建时间：  2015-9-30 </br>
* 发布版本：V1.0  </br>
 */
public class Token {
    // 接口访问凭证
    private String accessToken;
    // 凭证有效期，单位：秒
    private int expiresIn;

    public String getAccessToken() {
        return accessToken;
    }

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public int getExpiresIn() {
        return expiresIn;
    }

    public void setExpiresIn(int expiresIn) {
        this.expiresIn = expiresIn;
    }
}

三、获取token。

1.问题：如何通过获取token？

解决方案：（1）直接通过浏览器访问。（2）编写程序，模拟https连接，获得token。

解决详细步骤如下：

（1）浏览器中直接输入链接：https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET ，然后把APPID和APPSECRET替换成自己的appID和appsecret，在浏览器即可获得token。

　

（2）如何在程序中模拟发送https请求，并且获取到token呢？

对于https请求，我们需要一个证书信任管理器，这个管理器类需要自己定义，但需要实现X509TrustManager接口，　

首先定义一个MyX509TrustManager 类。

package com.souvc.weixin.util;

import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.X509TrustManager;

/**
* 类名: MyX509TrustManager </br>
* 描述: 信任管理器 </br>
* 开发人员： souvc </br>
* 创建时间：  2015-9-30 </br>
* 发布版本：V1.0  </br>
 */
public class MyX509TrustManager implements X509TrustManager {

    // 检查客户端证书
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    }

    // 检查服务器端证书
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    }

    // 返回受信任的X509证书数组
    public X509Certificate[] getAcceptedIssuers() {
        return null;
    }
}

建立一个token测试类：

package com.souvc.weixin.test;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;

import com.souvc.weixin.util.MyX509TrustManager;

public class TokenTest {

    public static void main(String[] args) throws Exception {
　　　　//修改appID，secret
        String tokenUrl="https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";
        //建立连接
        URL url = new URL(tokenUrl);
        HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();

        // 创建SSLContext对象，并使用我们指定的信任管理器初始化
        TrustManager[] tm = { new MyX509TrustManager() };
        SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
        sslContext.init(null, tm, new java.security.SecureRandom());
        // 从上述SSLContext对象中得到SSLSocketFactory对象
        SSLSocketFactory ssf = sslContext.getSocketFactory();

        httpUrlConn.setSSLSocketFactory(ssf);
        httpUrlConn.setDoOutput(true);
        httpUrlConn.setDoInput(true);

        // 设置请求方式（GET/POST）
        httpUrlConn.setRequestMethod("GET");

        // 取得输入流
        InputStream inputStream = httpUrlConn.getInputStream();
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        //读取响应内容
        StringBuffer buffer = new StringBuffer();
        String str = null;
        while ((str = bufferedReader.readLine()) != null) {
            buffer.append(str);
        }
        bufferedReader.close();
        inputStreamReader.close();
        // 释放资源
        inputStream.close();
        httpUrlConn.disconnect();
        //输出返回结果
        System.out.println(buffer);
    }

}

微信服务器返回的结果：

{"access_token":"E3kRcQTati3QBPz97ou7zG0NXFrZFbA5No_hs5FNUZ62ROT0jr0txWr-gG1w-t06kk0zBW0kFmJiicJAydFyHNZhIh2uqIw4B5t85huRLs4","expires_in":7200}

2.问题：微信服务器返回的是json数据，如何从json里面解析出来的值？

方案：可以通过一款开源的json开发工具包json-lib，将他转换为java对象。

详细实现方法：

首先引入jar包

jar包下载：  http://yunpan.cn/cH9UCqsQ9XVdE  访问密码 2711

封装一个通用的工具类 CommonUtil ，用于专门获取token：

package com.souvc.weixin.util;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;

import net.sf.json.JSONException;
import net.sf.json.JSONObject;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.souvc.weixin.pojo.Token;

/**
* 类名: CommonUtil </br>
* 描述: 通用工具类 </br>
* 开发人员： souvc </br>
* 创建时间：  2015-9-30 </br>
* 发布版本：V1.0  </br>
 */
public class CommonUtil {
    private static Logger log = LoggerFactory.getLogger(CommonUtil.class);

    // 凭证获取（GET）
    public final static String token_url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";

    /**
     * 发送https请求
     *
     * @param requestUrl 请求地址
     * @param requestMethod 请求方式（GET、POST）
     * @param outputStr 提交的数据
     * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值)
     */
    public static JSONObject httpsRequest(String requestUrl, String requestMethod, String outputStr) {
        JSONObject jsonObject = null;
        try {
            // 创建SSLContext对象，并使用我们指定的信任管理器初始化
            TrustManager[] tm = { new MyX509TrustManager() };
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, tm, new java.security.SecureRandom());
            // 从上述SSLContext对象中得到SSLSocketFactory对象
            SSLSocketFactory ssf = sslContext.getSocketFactory();

            URL url = new URL(requestUrl);
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
            conn.setSSLSocketFactory(ssf);

            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            conn.setRequestMethod(requestMethod);

            // 当outputStr不为null时向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }

            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            StringBuffer buffer = new StringBuffer();
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }

            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            inputStream = null;
            conn.disconnect();
            jsonObject = JSONObject.fromObject(buffer.toString());
        } catch (ConnectException ce) {
            log.error("连接超时：{}", ce);
        } catch (Exception e) {
            log.error("https请求异常：{}", e);
        }
        return jsonObject;
    }

    /**
     * 获取接口访问凭证
     *
     * @param appid 凭证
     * @param appsecret 密钥
     * @return
     */
    public static Token getToken(String appid, String appsecret) {
        Token token = null;
        String requestUrl = token_url.replace("APPID", appid).replace("APPSECRET", appsecret);
        // 发起GET请求获取凭证
        JSONObject jsonObject = httpsRequest(requestUrl, "GET", null);

        if (null != jsonObject) {
            try {
                token = new Token();
                token.setAccessToken(jsonObject.getString("access_token"));
                token.setExpiresIn(jsonObject.getInt("expires_in"));
            } catch (JSONException e) {
                token = null;
                // 获取token失败
                log.error("获取token失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
            }
        }
        return token;
    }
}

修改Token测试类：

package com.souvc.weixin.test;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;

import org.junit.Test;

import com.souvc.weixin.pojo.Token;
import com.souvc.weixin.util.CommonUtil;
import com.souvc.weixin.util.MyX509TrustManager;

public class TokenTest {

    @Test
    public void testGetToken1() throws Exception {
        String tokenUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=appID&secret=appsecret";
        // 建立连接
        URL url = new URL(tokenUrl);
        HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();

        // 创建SSLContext对象，并使用我们指定的信任管理器初始化
        TrustManager[] tm = { new MyX509TrustManager() };
        SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
        sslContext.init(null, tm, new java.security.SecureRandom());
        // 从上述SSLContext对象中得到SSLSocketFactory对象
        SSLSocketFactory ssf = sslContext.getSocketFactory();

        httpUrlConn.setSSLSocketFactory(ssf);
        httpUrlConn.setDoOutput(true);
        httpUrlConn.setDoInput(true);

        // 设置请求方式（GET/POST）
        httpUrlConn.setRequestMethod("GET");

        // 取得输入流
        InputStream inputStream = httpUrlConn.getInputStream();
        InputStreamReader inputStreamReader = new InputStreamReader(
                inputStream, "utf-8");
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        // 读取响应内容
        StringBuffer buffer = new StringBuffer();
        String str = null;
        while ((str = bufferedReader.readLine()) != null) {
            buffer.append(str);
        }
        bufferedReader.close();
        inputStreamReader.close();
        // 释放资源
        inputStream.close();
        httpUrlConn.disconnect();
        // 输出返回结果
        System.out.println(buffer);
    }

    @Test
    public void testGetToken2() {
        Token token = CommonUtil.getToken("appID","appsecret");
        System.out.println("access_token:"+token.getAccessToken());
        System.out.println("expires_in:"+token.getExpiresIn());
    }
}

控制台输出效果如下，说明我们获取到了access_token和expires_in：

access_token:2amR6pr1eN-BuSBgho-nzo5tofxJ6BdEnRJQ87Zs5bj4ny4CGB8w-1D3YtjG2PzmEvVm1INrsVg-5BjyHCkWmBKsLPDSF3r_bdaPxMpKtbw
expires_in:7200

四、缓存access_token。

问题：问题又来来，可是我们如何把这个值缓存起来呢，并且需要2俩小时获取一次？

方案：

（1）可以通过缓存框架把该值通过key-values形式缓存在内存中 。

（2）可以把该值存入数据库中，需要的时候就去提取。

使用数据库的话,大概思路就是这样的。第一次使用将其access_token存储起来,下次需要access_token则将其查出。若是失效则，重新创建并更新数据库.若是没有失效,则直接使用。

建立数据库 souvc

create database  souvc ；

建立数据库表 t_token 来存放token值

CREATE TABLE `t_token` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `access_token` varchar(1024) NOT NULL,
  `expires_in` int(11) NOT NULL,
  `createTime` datetime NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8

现在我们通过jdbc来读取这个token值。

导入jdbc的jar包

http://yunpan.cn/cH9IRaKemL3II  访问密码 2ffa

导入mysql 的jar包

http://yunpan.cn/cmv3BGe9CkUr3  访问密码 3601

新建一个数据库配置文件db.properties

#Oracle
#jdbc.driverClassName=oracle.jdbc.OracleDriver
#jdbc.url=jdbc:oracle:thin:@localhost:1521:orcl
#jdbc.username=root
#jdbc.password=123456

#Mysql
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/souvc
jdbc.username=root
jdbc.password=123456

dataSource.initialSize=10
dataSource.maxIdle=20
dataSource.minIdle=5
dataSource.maxActive=50
dataSource.maxWait=1000

新建一个jdbc的连接工具类

package com.souvc.weixin.util;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;

/**
* 类名: DBUtility </br>
* 描述: 连接数据库工具类 </br>
* 开发人员： souvc </br>
* 创建时间：  2015-10-5 </br>
* 发布版本：V1.0  </br>
 */
public class DBUtility {
    private static BasicDataSource dataSource = null;

    public DBUtility() {
    }

    public static void init() {

        Properties dbProps = new Properties();
        // 取配置文件可以根据实际的不同修改
        try {
            dbProps.load(DBUtility.class.getClassLoader().getResourceAsStream("db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            String driveClassName = dbProps.getProperty("jdbc.driverClassName");
            String url = dbProps.getProperty("jdbc.url");
            String username = dbProps.getProperty("jdbc.username");
            String password = dbProps.getProperty("jdbc.password");

            String initialSize = dbProps.getProperty("dataSource.initialSize");
            String minIdle = dbProps.getProperty("dataSource.minIdle");
            String maxIdle = dbProps.getProperty("dataSource.maxIdle");
            String maxWait = dbProps.getProperty("dataSource.maxWait");
            String maxActive = dbProps.getProperty("dataSource.maxActive");

            dataSource = new BasicDataSource();
            dataSource.setDriverClassName(driveClassName);
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);

            // 初始化连接数
            if (initialSize != null)
                dataSource.setInitialSize(Integer.parseInt(initialSize));

            // 最小空闲连接
            if (minIdle != null)
                dataSource.setMinIdle(Integer.parseInt(minIdle));

            // 最大空闲连接
            if (maxIdle != null)
                dataSource.setMaxIdle(Integer.parseInt(maxIdle));

            // 超时回收时间(以毫秒为单位)
            if (maxWait != null)
                dataSource.setMaxWait(Long.parseLong(maxWait));

            // 最大连接数
            if (maxActive != null) {
                if (!maxActive.trim().equals("0"))
                    dataSource.setMaxActive(Integer.parseInt(maxActive));
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("创建连接池失败!请检查设置!!!");
        }
    }

    /**
     * 数据库连接
     *
     * @return
     * @throws SQLException
     */
    public static synchronized Connection getConnection() throws SQLException {
        if (dataSource == null) {
            init();
        }
        Connection conn = null;
        if (dataSource != null) {
            conn = dataSource.getConnection();
        }
        return conn;
    }

    /**
     * 关闭数据库
     *
     * @param conn
     */
    public static void closeConnection(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                System.out.println("关闭资源失败");
                e.printStackTrace();
            }
        }
    }

}

新建测试连接类

package com.souvc.weixin.test;

import java.sql.SQLException;

import org.junit.Test;

import com.souvc.weixin.util.DBUtility;

public class TestDBUtility {

    /**
    * 方法名：testgetConnection</br>
    * 详述：测试是否连接</br>
    * 开发人员：souvc </br>
    * 创建时间：2015-10-5  </br>
    * @throws SQLException
    * @throws
     */
    @Test
    public void testgetConnection() throws SQLException {
        DBUtility db = new DBUtility();
        System.out.println(db.getConnection());
    }

}

测试结果如下，说明了能连上数据库：

jdbc:mysql://localhost:3306/souvc, UserName=root@localhost, MySQL-AB JDBC Driver

接下来我们封装一个从数据库读取token和保存token的类

package com.souvc.weixin.util;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import com.souvc.weixin.pojo.Token;

/**
* 类名: TokenUtil </br>
* 描述: Token </br>
* 开发人员： souvc </br>
* 创建时间：  2015-10-5 </br>
* 发布版本：V1.0  </br>
 */
public class TokenUtil {

    /**
    * 方法名：getToken</br>
    * 详述：从数据库里面获取token</br>
    * 开发人员：souvc </br>
    * 创建时间：2015-10-5  </br>
    * @return
    * @throws
     */
    public static Map<String, Object> getToken(){
        Connection con = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        String sql ="select * from t_token order by createTime desc limit 0,1";
        String access_token="";
        Map<String, Object> map=new HashMap<String, Object>();
        Integer expires_in=0;
        try {
            //创建数据库链接
            con = DBUtility.getConnection();
            //创建处理器
            stmt = con.prepareStatement(sql);
            //查询Token，读取1条记录
            rs = stmt.executeQuery();
            if (rs.next()) {
                access_token = rs.getString("access_token");
                expires_in=rs.getInt("expires_in");
                map.put("access_token", access_token);
                map.put("expires_in", expires_in);
            }  

        } catch (SQLException ex) {
            System.out.println("数据库操作异常：" + ex.getMessage());
        } finally {
            DBUtility.closeConnection(con);
        }
        return map;
    }

    /**
    * 方法名：saveToken</br>
    * 详述：保存token</br>
    * 开发人员：souvc </br>
    * 创建时间：2015-10-5  </br>
    * @return
    * @throws
     */
    public static void saveToken(Token token){
        //存入数据库中
        Connection conn = null;
        PreparedStatement pst = null;
        try {
            //创建数据库链接
            conn = DBUtility.getConnection();
            //创建预处理器
            pst = conn.prepareStatement("insert into t_token(access_token,expires_in,createTime)values(?,?,?)");
            pst.setString(1, token.getAccessToken());
            pst.setInt(2, token.getExpiresIn());
            long now = new Date().getTime();
            pst.setTimestamp(3, new java.sql.Timestamp(now));
            pst.execute();
        } catch (SQLException ex) {
            System.out.println("数据库操作异常：" + ex.getMessage());
        } finally {
            DBUtility.closeConnection(conn);
        }
    }
}

建立一个测试类测试

@Test
    public void testGetToken3() {
        Map<String, Object> token=TokenUtil.getToken();
        System.out.println(token.get("access_token"));
        System.out.println(token.get("expires_in"));
    }

    @Test
    public void testSaveToken4() {
        Token token=CommonUtil.getToken("appID", "appsecret");
        TokenUtil.saveToken(token);
    }

获取token的结果：

6bbRDvtxIG9jwVhJQBOXoi6-bN6hlMNagxZjsh5QAf447shWcCi9LC1GL5PFgrn4zTdeFMpaU4EqE0CTQDQ2_PE0qOdXTHEM2gt6CV_zlRY
7200

保存token的结果：

这样基本完成了。

也许大家觉得这个方法有点麻烦，也希望大家多多提出修改的建议，或是在评论中说一下自己的方法。贴出代码，让大家一起进步。

五，问题：但是如何让这个保存工作隔7200 秒进行保存呢？

方案：

做一个定时器。

做一个web实现监听器。

定期获取并存储access_token的流程为：

Web服务器启动时就加载一个Servlet，在Servlet的init()方法中启动一个线 程，在线程的run()方法中通过死循环+Thread.sleep()的方式定期获取access_token，然后将获取到的 access_token保存在public static修饰的变量中。

在工程中创建一个InitServlet类，该类的代码如下：

package com.souvc.weixin.servlet;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.souvc.weixin.thread.TokenThread;
import com.souvc.weixin.util.CommonUtil;

/**
* 类名: InitServlet </br>
* 描述: 初始化servlet </br>
* 开发人员： souvc </br>
* 创建时间：  Oct 6, 2015 </br>
* 发布版本：V1.0  </br>
 */
public class InitServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private static Logger log = LoggerFactory.getLogger(CommonUtil.class);

    public void init() throws ServletException {
        // 获取web.xml中配置的参数
        TokenThread.appid = getInitParameter("appid");
        TokenThread.appsecret = getInitParameter("appsecret");

        log.info("weixin api appid:{}", TokenThread.appid);
        log.info("weixin api appsecret:{}", TokenThread.appsecret);

        // 未配置appid、appsecret时给出提示
        if ("".equals(TokenThread.appid) || "".equals(TokenThread.appsecret)) {
            log.error("appid and appsecret configuration error, please check carefully.");
        } else {
            // 启动定时获取access_token的线程
            new Thread(new TokenThread()).start();
        }
    }
}

从上面的代码 可以看出，InitServlet类只重写了init()方法，并没有重写doGet()和doPost()两个方法，

因为我们并不打算让 InitServlet来处理访问请求。init()方法的实现也比较简单，先获取在web.xml中配置的参数appid和appsecret，

再启动 线程TokenThread定时获取access_token。

InitServlet在web.xml中的配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <servlet>
        <servlet-name>coreServlet</servlet-name>
        <servlet-class>
            com.souvc.weixin.servlet.CoreServlet
        </servlet-class>
    </servlet>

    <!-- url-pattern中配置的/coreServlet用于指定该Servlet的访问路径 -->
    <servlet-mapping>
        <servlet-name>coreServlet</servlet-name>
        <url-pattern>/coreServlet</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>initServlet</servlet-name>
        <servlet-class>
            com.souvc.weixin.servlet.InitServlet
        </servlet-class>
        <!-- 配置获取access_token所需参数appid和appsecret -->
        <init-param>
            <param-name>appid</param-name>
            <param-value>appid</param-value>
        </init-param>
        <init-param>
            <param-name>appsecret</param-name>
            <param-value>appsecret</param-value>
        </init-param>
        <load-on-startup>0</load-on-startup>
    </servlet>
</web-app>

InitServlet 在web.xml中的配置与普通Servlet的配置有几点区别：

1）通过配置<init-param>向Servlet中传入参数；

2）通 过配置<load-on-startup>使得Web服务器启动时就加载该Servlet；

3）没有配置<servlet- mapping>，因为InitServlet并不对外提供访问。

TokenThread的源代码如下：

package com.souvc.weixin.thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.souvc.weixin.pojo.Token;
import com.souvc.weixin.util.CommonUtil;
import com.souvc.weixin.util.TokenUtil;

/**
* 类名: TokenThread </br>
* 描述: 定时获取微信access_token的线程 </br>
* 开发人员： souvc </br>
* 创建时间：  Oct 6, 2015 </br>
* 发布版本：V1.0  </br>
 */
public class TokenThread implements Runnable {
    private static Logger log = LoggerFactory.getLogger(TokenThread.class);
    // 第三方用户唯一凭证
    public static String appid = "";
    // 第三方用户唯一凭证密钥
    public static String appsecret = "";
    public static Token accessToken = null;

    public void run() {
        while (true) {
            try {
                accessToken = CommonUtil.getToken(appid, appsecret);
                if (null != accessToken) {
                    //调用存储到数据库
                    TokenUtil.saveToken(accessToken);
                    log.info("获取access_token成功，有效时长{}秒 token:{}", accessToken.getExpiresIn(), accessToken.getAccessToken());
                    // 休眠7000秒
                    Thread.sleep((accessToken.getExpiresIn() - 200)*1000);
                } else {
                    // 如果access_token为null，60秒后再获取
                    Thread.sleep(60 * 1000);
                }
            } catch (InterruptedException e) {
                try {
                    Thread.sleep(60 * 1000);
                } catch (InterruptedException e1) {
                    log.error("{}", e1);
                }
                log.error("{}", e);
            }
        }
    }
}

配置一下log4j.properties 日志文件：

log4j.rootLogger=info,console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%-5p] %m%n

代码中通过while(true){}构造了一个死循环（永久执行）；

调用公众平台接口获取access_token；

让线程休眠7000秒再运行，即每隔7000秒获取一次access_token，保证access_token永不失效。

温馨提示：

可以不存入数据库。

在项目中的其他类，可以通过调用 TokenThread.accessToken.getToken() 来得到接口访问凭证access_token。

其他文章关联：

第一篇：微信公众平台开发实战Java版之了解微信公众平台基础知识以及资料准备

第二篇 ：微信公众平台开发实战Java版之开启开发者模式，接入微信公众平台开发

第三篇 ：微信公众平台开发实战Java版之请求消息，响应消息以及事件消息类的封装

第四篇 ：微信公众平台开发实战Java版之完成消息接受与相应以及消息的处理

第五篇 ：微信公众平台开发实战Java版之如何获取公众号的access_token以及缓存access_token

第六篇 ：微信公众平台开发实战Java版之如何自定义微信公众号菜单

第七篇 ：微信公众平台开发实战Java版之如何获取微信用户基本信息

第八篇 ：微信公众平台开发实战Java版之如何网页授权获取用户基本信息

第九篇 ：微信公众平台开发实战Java版之如何实现自定义分享内容

其他：Web开发须知：URL编码与解码