Java微信公眾平台開發(六)--微信開發中的token獲取

（一）token的介紹

引用：access_token是公眾號的全局唯一票據，公眾號調用各接口時都需使用access_token。開發者需要進行妥善保存。access_token的存儲至少要保留512個字符空間。access_token的有效期目前為2個小時，需定時刷新，重復獲取將導致上次獲取的access_token失效！

（二）token的獲取參考文檔

獲取的流程我們完全可以參考微信官方文檔：http://mp.weixin.qq.com/wiki/14/9f9c82c1af308e3b14ba9b973f99a8ba.html 如圖：

（三）token獲取流程分析

• 從公眾平台獲取賬號的AppID和AppSecret；

• token獲取並解析存儲執行體；

• 采用任務調度每隔兩小時執行一次token獲取執行體；

（四）token的獲取流程的具體實現

①獲取appid和appsecret

在微信公眾平台接口測試工具中可以查看到我們需要的兩個參數：

這里我們將appid 和secret 定義到配置文件【wechat.properties】，在src目錄下新建【wechat.properties】文件，大致代碼為：

#開發者的appid
appid=wx7e32765bc24XXXX 
#開發者的AppSecret
AppSecret=d58051564fe9d86093f9XXXXX

②token獲取並解析存儲執行體的代碼編寫

由於在這里我們需要通過http的get請求向微信服務器獲取時效性為7200秒的token，所以我在這里寫了一個http請求的工具類HttpUtils，以方便我們的使用，如下：（這里需要導入文末的http協議包）

package com.gede.wechat.util;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.zip.GZIPInputStream;
 
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
/**
* @author gede
* @version date：2019年5月26日 下午5:43:36
* @description ：
*/
public class HttpUtils {
     
    /**
     * @Description: http get請求共用方法
     * @param @param reqUrl
     * @param @param params
     * @param @return
     * @param @throws Exception
     */
    @SuppressWarnings("resource")
    public static String sendGet(String reqUrl, Map<String, String> params)
            throws Exception {
        InputStream inputStream = null;
        HttpGet request = new HttpGet();
        try {
            String url = buildUrl(reqUrl, params);
            HttpClient client = new DefaultHttpClient();
 
            request.setHeader("Accept-Encoding", "gzip");
            request.setURI(new URI(url));
 
            HttpResponse response = client.execute(request);
 
            inputStream = response.getEntity().getContent();
            String result = getJsonStringFromGZIP(inputStream);
            return result;
        } finally {
            if (inputStream != null) {
                inputStream.close();
            }
            request.releaseConnection();
        }
 
    }
 
    @SuppressWarnings("resource")
    public static String sendPost(String reqUrl, Map<String, String> params)
            throws Exception {
        try {
            Set<String> set = params.keySet();
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            for (String key : set) {
                list.add(new BasicNameValuePair(key, params.get(key)));
            }
            if (list.size() > 0) {
                try {
                    HttpClient client = new DefaultHttpClient();
                    HttpPost request = new HttpPost(reqUrl);
 
                    request.setHeader("Accept-Encoding", "gzip");
                    request.setEntity(new UrlEncodedFormEntity(list, HTTP.UTF_8));
 
                    HttpResponse response = client.execute(request);
 
                    InputStream inputStream = response.getEntity().getContent();
                    try {
                        String result = getJsonStringFromGZIP(inputStream);
 
                        return result;
                    } finally {
                        inputStream.close();
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                    throw new Exception("網絡連接失敗,請連接網絡后再試");
                }
            } else {
                throw new Exception("參數不全，請稍后重試");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            throw new Exception("發送未知異常");
        }
    }
 
    public static String sendPostBuffer(String urls, String params)
            throws ClientProtocolException, IOException {
        HttpPost request = new HttpPost(urls);
 
        StringEntity se = new StringEntity(params, HTTP.UTF_8);
        request.setEntity(se);
        // 發送請求
        @SuppressWarnings("resource")
        HttpResponse httpResponse = new DefaultHttpClient().execute(request);
        // 得到應答的字符串，這也是一個 JSON 格式保存的數據
        String retSrc = EntityUtils.toString(httpResponse.getEntity());
        request.releaseConnection();
        return retSrc;
 
    }
 
    public static String sendXmlPost(String urlStr, String xmlInfo) {
        // xmlInfo xml具體字符串
 
        try {
            URL url = new URL(urlStr);
            URLConnection con = url.openConnection();
            con.setDoOutput(true);
            con.setRequestProperty("Pragma:", "no-cache");
            con.setRequestProperty("Cache-Control", "no-cache");
            con.setRequestProperty("Content-Type", "text/xml");
            OutputStreamWriter out = new OutputStreamWriter(
                    con.getOutputStream());
            out.write(new String(xmlInfo.getBytes("utf-8")));
            out.flush();
            out.close();
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    con.getInputStream()));
            String lines = "";
            for (String line = br.readLine(); line != null; line = br
                    .readLine()) {
                lines = lines + line;
            }
            return lines; // 返回請求結果
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "fail";
    }
 
    private static String getJsonStringFromGZIP(InputStream is) {
        String jsonString = null;
        try {
            BufferedInputStream bis = new BufferedInputStream(is);
            bis.mark(2);
            // 取前兩個字節
            byte[] header = new byte[2];
            int result = bis.read(header);
            // reset輸入流到開始位置
            bis.reset();
            // 判斷是否是GZIP格式
            int headerData = getShort(header);
            // Gzip 流 的前兩個字節是 0x1f8b
            if (result != -1 && headerData == 0x1f8b) {
                // LogUtil.i("HttpTask", " use GZIPInputStream  ");
                is = new GZIPInputStream(bis);
            } else {
                // LogUtil.d("HttpTask", " not use GZIPInputStream");
                is = bis;
            }
            InputStreamReader reader = new InputStreamReader(is, "utf-8");
            char[] data = new char[100];
            int readSize;
            StringBuffer sb = new StringBuffer();
            while ((readSize = reader.read(data)) > 0) {
                sb.append(data, 0, readSize);
            }
            jsonString = sb.toString();
            bis.close();
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return jsonString;
    }
 
    private static int getShort(byte[] data) {
        return (data[0] << 8) | data[1] & 0xFF;
    }
 
    /**
     * 構建get方式的url
     * 
     * @param reqUrl
     *            基礎的url地址
     * @param params
     *            查詢參數
     * @return 構建好的url
     */
    public static String buildUrl(String reqUrl, Map<String, String> params) {
        StringBuilder query = new StringBuilder();
        Set<String> set = params.keySet();
        for (String key : set) {
            query.append(String.format("%s=%s&", key, params.get(key)));
        }
        return reqUrl + "?" + query.toString();
    }
 
}

我們在做http請求的時候需要目標服務器的url，這里在項目中為了方便對url的管理我們src目錄下建立了interface_url.properties用於存放目標url，這里我們將請求token的url存入：

#獲取token的url
tokenUrl=https://api.weixin.qq.com/cgi-bin/token

我們需要將我們配置的配置文件在項目初始化后能得到啟動，所以我在這里加入一個項目初始化的代碼InterfaceUrlIntiServlet來實現，用於項目啟動初始化interface_url.properties和wechat.properties中的配置：

package com.gede.web.start;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
/**
* @author gede
* @version date：2019年5月26日 下午7:42:14
* @description ：
*/
public class InterfaceUrlIntiServlet extends HttpServlet {
     
    private static final long serialVersionUID = 1L;
 
    @Override
    public void init(ServletConfig config) throws ServletException {
        InterfaceUrlInti.init();
    }
}

初始化的具體實現，將初始化過后的方法都存入到GlobalConstants中方便項目中隨意調用，如下：

package com.gede.web.start;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import com.gede.web.util.GlobalConstants;
/**
* @author gede
* @version date：2019年5月26日 下午7:42:37
* @description ：
*/
public class InterfaceUrlInti {
     
    public synchronized static void init(){
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Properties props = new Properties();
        if(GlobalConstants.interfaceUrlProperties==null){
            GlobalConstants.interfaceUrlProperties = new Properties();
        }
        InputStream in = null;
        try {
            in = cl.getResourceAsStream("interface_url.properties");
            props.load(in);
            for(Object key : props.keySet()){
                GlobalConstants.interfaceUrlProperties.put(key, props.get(key));
            }
             
            props = new Properties();
            in = cl.getResourceAsStream("wechat.properties");
            props.load(in);
            for(Object key : props.keySet()){
                GlobalConstants.interfaceUrlProperties.put(key, props.get(key));
            }
             
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return;
    }
 
}

這里用到的GlobalConstants，我們新建在web.util包里面，代碼如下：

package com.gede.web.util;
import java.util.Properties;
/**
* @author gede
* @version date：2019年5月26日 下午7:45:27
* @description ：
*/
public class GlobalConstants {
    public static Properties interfaceUrlProperties;

/**
 * @Description: TODO
 * @param @param key
 * @param @return   
 */
    public static String getInterfaceUrl(String key) {
        return (String) interfaceUrlProperties.get(key);
    }
}

當我們把所有的准備工作都做好了之后我們可以開始真正的去獲取token了，這里我們將獲取到的token解析之后依然存儲到GlobalConstants中方便使用，簡單代碼如下：(這里需要導入我們附件中的json包)

package com.gede.wechat.common;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import com.gede.web.util.GlobalConstants;
import com.gede.wechat.util.HttpUtils;

import net.sf.json.JSONObject;
/**
* @author gede
* @version date：2019年5月26日 下午7:50:38
* @description ：
*/
public class WeChatTask {
    /**
     * @Description: 任務執行體
     * @param @throws Exception
     */
    public void getToken_getTicket() throws Exception {
        Map<String, String> params = new HashMap<String, String>();
        params.put("grant_type", "client_credential");
        params.put("appid", GlobalConstants.getInterfaceUrl("appid"));
        params.put("secret", GlobalConstants.getInterfaceUrl("AppSecret"));
        String jstoken = HttpUtils.sendGet(
                GlobalConstants.getInterfaceUrl("tokenUrl"), params);
        String access_token = JSONObject.fromObject(jstoken).getString(
                "access_token"); // 獲取到token並賦值保存
        GlobalConstants.interfaceUrlProperties.put("access_token", access_token);
                System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"token為=============================="+access_token);
    }
 
}

（三）采用任務調度每隔兩小時執行一次token獲取執行體

我們閱讀過微信的文檔會發現我們的token獲取的接口每天是有調用次數限制的，為了防止我們業務量比較大的情況下token的直接調用的接口次數不夠用，所以我們需要根據token的時效性（7200s）在自己的業務服務器上做到token的緩存並定時獲取，我這里用到的任務調度的方式是采用quartz，下面具體代碼的實現：

package com.gede.wechat.quartz;
import org.apache.log4j.Logger;
import com.gede.wechat.common.WeChatTask;

/**
* @author gede
* @version date：2019年5月26日 下午8:00:43
* @description ：
*/
public class QuartzJob{
    private static Logger logger = Logger.getLogger(QuartzJob.class);
    /**
     * @Description: 任務執行獲取token
     * @param    
     */
    public void workForToken() {
        try {
            WeChatTask timer = new WeChatTask();
            timer.getToken_getTicket();
        } catch (Exception e) {
            logger.error(e, e);
        }
    }
}

這里新建配置文件spring-quartz.xml以方便quartz任務的管理和啟用，這里將我們需要用到的workForToken()加入到執行任務中：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!-- 要調用的工作類 -->
    <bean id="quartzJob" class="com.gede.wechat.quartz.QuartzJob"></bean>
    <!-- 定義調用對象和調用對象的方法 -->
    <bean id="jobtaskForToken"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 調用的類 -->
        <property name="targetObject">
            <ref bean="quartzJob" />
        </property>
        <!-- 調用類中的方法 -->
        <property name="targetMethod">
            <value>workForToken</value>
        </property>
    </bean>
    <!-- 定義觸發時間 -->
    <bean id="doTimeForToken" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail">
            <ref bean="jobtaskForToken" />
        </property>
        <!-- cron表達式 -->
        <property name="cronExpression">
            <value>0 0/1 * * * ?</value>
        </property>
    </bean>
    <!-- 總管理類 如果將lazy-init='false'那么容器啟動就會執行調度程序 -->
    <bean id="startQuertz" lazy-init="false" autowire="no"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="doTimeForToken" />
            </list>
        </property>
    </bean>
</beans>

這里我為了測試將執行間隔時間設置成了1分鍾一次，根據需要可以自行修改執行時間。

好了到這里我們就已經大功告成，就差初始化加載InterfaceUrlIntiServlet和開啟quartz的使用：修改web.xml ，加入相關語句，代碼如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>mychat</display-name>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
 <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml,classpath:spring-quartz.xml</param-value>
  </context-param>
  
  <servlet>
      <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
            classpath:appServlet.xml
            </param-value>
        </init-param>
      <load-on-startup>1</load-on-startup>
  </servlet>
  
  <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>classpath:log4j.properties</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
  </listener>
  
  <servlet>
        <servlet-name>interface_url-init_servlet</servlet-name>
        <servlet-class>com.gede.web.start.InterfaceUrlIntiServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
      <servlet-name>appServlet</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

當這一切都准備完畢之后我們啟動項目，會發現每間隔一分鍾就會有token獲取到，這里我是將其存儲在項目變量中，這里看一下我們的效果圖和項目總的目錄結構：

附件：今天需要導入的包有很多，最后我就給大家打一個壓縮包，大家在運行之前將包全部導入即可。點擊下載