Dans l'article précédent ? Développement WeChat — Construction de l'environnement de développement WeChat ?, nous avons terminé les préparatifs pour le développement de WeChat. Une fois les préparatifs terminés, nous commencerons à nous mettre au travail.

1. Les principes de base de la plateforme publique WeChat

Avant de commencer, présentons brièvement les principes de base de la plateforme publique WeChat.

Le serveur WeChat est équivalent à un serveur de transfert. Le terminal (téléphone portable, Pad, etc.) initie une requête au serveur WeChat, et le serveur WeChat transmet ensuite la requête à notre serveur d'application. Une fois le traitement terminé, le serveur d'applications renvoie les données de réponse au serveur WeChat, et le serveur WeChat répond ensuite les informations de réponse spécifiques au terminal de l'application WeChat.

Le protocole de communication est : HTTP

Le format de transmission des données est : XML

Le processus spécifique est tel qu'illustré dans la figure ci-dessous :

Prenons une image plus intuitive?:

Ce que nous devons faire est de répondre à la requête HTTP transmise par le serveur WeChat. Nous analysons le contenu spécifique de la requête selon un format XML spécifique. Après traitement, nous devons également le renvoyer selon un format XML spécifique.

2. Accès au compte public WeChat

Dans la documentation du développeur de la plateforme publique WeChat, la section sur l'accès au compte public est écrite plus en détail dans le guide d'accès, dans le document Il est dit que l'accès le compte officiel nécessite trois étapes, qui sont :

1. Remplir la configuration du serveur
2. Vérifier la validité de l'adresse du serveur
3. Implémenter la logique métier basée sur le document d'interface

En fait, l'étape 3 ne peut plus être considérée comme l'étape de connexion du compte officiel, mais après la connexion, les développeurs peuvent faire du développement basé sur l'interface fournie par le compte officiel WeChat.

La configuration du serveur à l'étape 1 comprend l'adresse du serveur (URL), le jeton et l'EncodingAESKey.

L'adresse du serveur est l'adresse d'entrée de la logique métier fournie par le backend du compte officiel. Actuellement, elle ne prend en charge que le port 80. Elle inclura ultérieurement la vérification d'accès et toute autre demande d'opération (telle que l'envoi de messages, le menu). gestion, gestion du matériel, etc.) Vous devez entrer à partir de cette adresse. La différence entre la vérification d'accès et les autres demandes est que la vérification d'accès est une demande d'obtention, et d'autres fois, il s'agit d'une demande de publication

Le jeton peut être rempli arbitrairement par le développeur et utilisé pour générer une signature (le jeton?; sera le même que celui de l'URL de l'interface. Le jeton inclus est comparé pour vérifier la sécurité);

La clé EncodingAESKey est renseignée manuellement par le développeur ou générée aléatoirement et sera utilisée comme chiffrement du corps du message. et la clé de décryptage. Dans cet exemple, tous les messages sont en texte brut non chiffré et cet élément de configuration n'est pas impliqué.

étape 2, vérifiez la validité de l'adresse du serveur. Lorsque vous cliquez sur le bouton "Soumettre", le serveur WeChat enverra une requête http get à l'adresse du serveur que vous venez de renseigner, et comportent quatre paramètres?:

Après avoir re?u la demande, nous devons effectuer les trois étapes suivantes s'il est confirmé que la demande GET. provient du serveur WeChat, il restera tel quel. Si le contenu du paramètre echostr est renvoyé, l'accès prendra effet, sinon l'accès échouera.

1. Triez les trois paramètres token, timestamp et nonce par ordre lexicographique
2. Fusionnez les trois cha?nes de paramètres en une seule cha?ne pour le cryptage sha1
3. Une fois que le développeur a obtenu le cryptage La cha?ne peut être comparé à une signature, indiquant que la demande provient de WeChat

Utilisons du code Java pour démontrer ce processus de vérification

Utilisez l'IDE (Eclipse ou IntelliJ IDEA) pour créer un projet JavaWeb, ici je J'utilise IntelliJ IDEA. La structure du répertoire du projet est la suivante?:

écrivez un servlevt et définissez la méthode de vérification dans la méthode doGet. Le code spécifique est le suivant?:

package me.gacl.wx.web.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

/**
 * Created by xdp on 2016/1/25.
 * 使用@WebServlet注解配置WxServlet,urlPatterns屬性指明了WxServlet的訪問路徑
 */
@WebServlet(urlPatterns="/WxServlet")
public class WxServlet extends HttpServlet {

    /**
     * Token可由開發(fā)者可以任意填寫，用作生成簽名（該Token會和接口URL中包含的Token進行比對，從而驗證安全性）
     * 比如這里我將Token設置為gacl
     */
    private final String TOKEN = "gacl";

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("開始校驗簽名");
        /**
         * 接收微信服務器發(fā)送請求時傳遞過來的4個參數(shù)
         */
        String signature = request.getParameter("signature");//微信加密簽名signature結(jié)合了開發(fā)者填寫的token參數(shù)和請求中的timestamp參數(shù)、nonce參數(shù)。
        String timestamp = request.getParameter("timestamp");//時間戳
        String nonce = request.getParameter("nonce");//隨機數(shù)
        String echostr = request.getParameter("echostr");//隨機字符串
        //排序
        String sortString = sort(TOKEN, timestamp, nonce);
        //加密
        String mySignature = sha1(sortString);
        //校驗簽名
        if (mySignature != null && mySignature != "" && mySignature.equals(signature)) {
            System.out.println("簽名校驗通過。");
            //如果檢驗成功輸出echostr，微信服務器接收到此輸出，才會確認檢驗完成。
            //response.getWriter().println(echostr);
            response.getWriter().write(echostr);
        } else {
            System.out.println("簽名校驗失敗.");
        }

    }

    /**
     * 排序方法
     *
     * @param token
     * @param timestamp
     * @param nonce
     * @return
     */
    public String sort(String token, String timestamp, String nonce) {
        String[] strArray = {token, timestamp, nonce};
        Arrays.sort(strArray);
        StringBuilder sb = new StringBuilder();
        for (String str : strArray) {
            sb.append(str);
        }

        return sb.toString();
    }

    /**
     * 將字符串進行sha1加密
     *
     * @param str 需要加密的字符串
     * @return 加密后的內(nèi)容
     */
    public String sha1(String str) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-1");
            digest.update(str.getBytes());
            byte messageDigest[] = digest.digest();
            // Create Hex String
            StringBuffer hexString = new StringBuffer();
            // 字節(jié)數(shù)組轉(zhuǎn)換為 十六進制 數(shù)
            for (int i = 0; i < messageDigest.length; i++) {
                String shaHex = Integer.toHexString(messageDigest[i] & 0xFF);
                if (shaHex.length() < 2) {
                    hexString.append(0);
                }
                hexString.append(shaHex);
            }
            return hexString.toString();

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }
}

J'utilise ici Servlet3.0. L'avantage d'utiliser Servlet3.0 est que vous pouvez directement utiliser l'annotation @WebServlet pour mapper le chemin d'accès du Servlet. plus besoin de l'ajouter dans le fichier web.xml Configuration

Déployez le projet WxStudy sur le serveur Tomcat pour l'exécuter, démarrez le projet directement, puis utilisez ngrok pour mapper le port 8080 local au réseau externe. (comment utiliser ngrok, veuillez vous référer au blog "WeChat Development - WeChat Development Environment Construction" 》). Comme le montre l'image ci-dessous?:

　　測試是否可以通過http://xdp.ngrok.natapp.cn地址正常訪問，測試結(jié)果如下：

　　可以看到，我們的項目已經(jīng)可以被外網(wǎng)正常訪問到了。

　　進入微信測試公眾號管理界面，在接口配置信息中填入映射的外網(wǎng)地址和token，如下圖所示：

　　點擊提交按鈕，頁面會提示配置成功，

　　IDE的控制臺中輸出了校驗通過的信息,如下圖所示:

　　到此，我們的公眾號應用已經(jīng)能夠和微信服務器正常通信了，也就是說我們的公眾號已經(jīng)接入到微信公眾平臺了。

三、access_token管理

3.1、access_token介紹

　　我們的公眾號和微信服務器對接成功之后，接下來要做的就是根據(jù)我們的業(yè)務需求調(diào)用微信公眾號提供的接口來實現(xiàn)相應的邏輯了。在使用微信公眾號接口中都需要一個access_token。

　　關于access_token，在微信公眾平臺開發(fā)者文檔上的獲取接口調(diào)用憑據(jù)有比較詳細的介紹：access_token是公眾號的全局唯一票據(jù)，公眾號調(diào)用各接口時都需使用access_token，開發(fā)者需要妥善保存access_token的存儲至少要保留512個字符空間。access_token的有效期目前為2個小時，需定時刷新，重復獲取將導致上次獲取的access_token失效。并且每天調(diào)用獲取access_token接口的上限是2000次。

　　總結(jié)以上說明，access_token需要做到以下兩點：

　　1.因為access_token有2個小時的時效性，要有一個機制保證最長2個小時重新獲取一次。

　　2.因為接口調(diào)用上限每天2000次，所以不能調(diào)用太頻繁。

3.2、微信公眾平臺提供的獲取access_token的接口

　　關于access_token的獲取方式，在微信公眾平臺開發(fā)者文檔上有說明，公眾號可以調(diào)用一個叫"獲取access token"的接口來獲取access_token。

　　獲取access token接口調(diào)用請求說明

　　　　http請求方式: GET

　　　　請求的URL地址：https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET　　　　　　

我們可以看到,調(diào)用過程中需要傳遞appID和AppSecret,appID和AppSecret是在申請公眾號的時候自動分配給公眾號的，相當于公眾號的身份標示，使用微信公眾號的注冊帳號登錄到騰訊提供的微信公眾號管理后臺就可以看到自己申請的公眾號的AppID和AppSecret，如下圖所示：

　　這是我申請公眾號測試帳號時分配到的AppID和AppSecret。

3.3、獲取access_token方案以及具體實現(xiàn)

　　這里采用的方案是這樣的，定義一個默認啟動的servlet，在init方法中啟動一個Thread,這個進程中定義一個無限循環(huán)的方法，用來獲取access_token，當獲取成功后，此進程休眠7000秒(7000秒=1.944444444444444小時)，否則休眠3秒鐘繼續(xù)獲取。流程圖如下：

　　下面正式開始在工程中實現(xiàn)以上思路，因為返回的數(shù)據(jù)都是json格式，這里會用到阿里的fastjson庫，為構(gòu)造請求和處理請求后的數(shù)據(jù)序列化和反序列化提供支持。

　　1.定義一個AccessToken實體類

package me.gacl.wx.entry;

/**
 * AccessToken的數(shù)據(jù)模型
 * Created by xdp on 2016/1/25.
 */
public class AccessToken {

    //獲取到的憑證
    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;
    }
}

　2.定義一個AccessTokenInfo類,用于存放獲取到的AccessToken,代碼如下:

package me.gacl.wx.Common;

import me.gacl.wx.entry.AccessToken;

/**
 * Created by xdp on 2016/1/25.
 */
public class AccessTokenInfo {

    //注意是靜態(tài)的
    public static AccessToken accessToken = null;
}

　　3.編寫一個用于發(fā)起https請求的工具類NetWorkHelper,代碼如下:

package me.gacl.wx.util;

import javax.net.ssl.*;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

/**
 * 訪問網(wǎng)絡用到的工具類
 */
public class NetWorkHelper {

    /**
     * 發(fā)起Https請求
     * @param reqUrl 請求的URL地址
     * @param requestMethod
     * @return 響應后的字符串
     */
    public String getHttpsResponse(String reqUrl, String requestMethod) {
        URL url;
        InputStream is;
        String resultData = "";
        try {
            url = new URL(reqUrl);
            HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
            TrustManager[] tm = {xtm};

            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(null, tm, null);

            con.setSSLSocketFactory(ctx.getSocketFactory());
            con.setHostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }
            });


            con.setDoInput(true); //允許輸入流，即允許下載

            //在android中必須將此項設置為false
            con.setDoOutput(false); //允許輸出流，即允許上傳
            con.setUseCaches(false); //不使用緩沖
            if (null != requestMethod && !requestMethod.equals("")) {
                con.setRequestMethod(requestMethod); //使用指定的方式
            } else {
                con.setRequestMethod("GET"); //使用get請求
            }
            is = con.getInputStream();   //獲取輸入流，此時才真正建立鏈接
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader bufferReader = new BufferedReader(isr);
            String inputLine;
            while ((inputLine = bufferReader.readLine()) != null) {
                resultData += inputLine + "\n";
            }
            System.out.println(resultData);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultData;
    }

    X509TrustManager xtm = new X509TrustManager() {
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        @Override
        public void checkServerTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {

        }

        @Override
        public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {

        }
    };
}

　　getHttpsResponse方法是請求一個https地址，參數(shù)requestMethod為字符串“GET”或者“POST”，傳null或者“”默認為get方式。

　　4.定義一個默認啟動的servlet，在init方法中啟動一個新的線程去獲取accessToken

package me.gacl.wx.web.servlet;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import me.gacl.wx.Common.AccessTokenInfo;
import me.gacl.wx.entry.AccessToken;
import me.gacl.wx.util.NetWorkHelper;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;

/**
 * 用于獲取accessToken的Servlet
 * Created by xdp on 2016/1/25.
 */
@WebServlet(
        name = "AccessTokenServlet",
        urlPatterns = {"/AccessTokenServlet"},
        loadOnStartup = 1,
        initParams = {
                @WebInitParam(name = "appId", value = "wxbe4d433e857e8bb1"),
                @WebInitParam(name = "appSecret", value = "ccbc82d560876711027b3d43a6f2ebda")
        })
public class AccessTokenServlet extends HttpServlet {

    @Override
    public void init() throws ServletException {
        System.out.println("啟動WebServlet");
        super.init();

        final String appId = getInitParameter("appId");
        final String appSecret = getInitParameter("appSecret");

        //開啟一個新的線程
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        //獲取accessToken
                        AccessTokenInfo.accessToken = getAccessToken(appId, appSecret);
                        //獲取成功
                        if (AccessTokenInfo.accessToken != null) {
                            //獲取到access_token 休眠7000秒,大約2個小時左右
                            Thread.sleep(7000 * 1000);
                            //Thread.sleep(10 * 1000);//10秒鐘獲取一次
                        } else {
                            //獲取失敗
                            Thread.sleep(1000 * 3); //獲取的access_token為空 休眠3秒
                        }
                    } catch (Exception e) {
                        System.out.println("發(fā)生異常：" + e.getMessage());
                        e.printStackTrace();
                        try {
                            Thread.sleep(1000 * 10); //發(fā)生異常休眠1秒
                        } catch (Exception e1) {

                        }
                    }
                }

            }
        }).start();
    }

    /**
     * 獲取access_token
     *
     * @return AccessToken
     */
    private AccessToken getAccessToken(String appId, String appSecret) {
        NetWorkHelper netHelper = new NetWorkHelper();
        /**
         * 接口地址為https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET，其中grant_type固定寫為client_credential即可。
         */
        String Url = String.format("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s", appId, appSecret);
        //此請求為https的get請求，返回的數(shù)據(jù)格式為{"access_token":"ACCESS_TOKEN","expires_in":7200}
        String result = netHelper.getHttpsResponse(Url, "");
        System.out.println("獲取到的access_token="+result);
        //使用FastJson將Json字符串解析成Json對象
        JSONObject json = JSON.parseObject(result);
        AccessToken token = new AccessToken();
        token.setAccessToken(json.getString("access_token"));
        token.setExpiresin(json.getInteger("expires_in"));
        return token;
    }
}

　　AccessTokenServlet采用注解的方式進行配置
　　至此代碼實現(xiàn)完畢，將項目部署，看到控制臺輸出如下：

　　為了方便看效果，可以把休眠時間設置短一點，比如10秒獲取一次，然后將access_token輸出。

　　下面做一個測試jsp頁面，并把休眠時間設置為10秒，這樣過10秒刷新頁面，就可以看到變化

<%-- Created by IntelliJ IDEA. --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="me.gacl.wx.Common.AccessTokenInfo"%>
<html>
  <head>
    <title></title>
  </head>
  <body>
    微信學習
    <hr/>
    access_token為：<%=AccessTokenInfo.accessToken.getAccessToken()%>
  </body>
</html>

　　10秒鐘后刷新頁面,access_token變了,如下圖所示:

四、接收微信服務器發(fā)送的消息并做出響應

　　經(jīng)過上述的三步,我們開發(fā)前的準備工作已經(jīng)完成了,接下來要做的就是接收微信服務器發(fā)送的消息并做出響應

　　從微信公眾平臺接口消息指南中可以了解到，當用戶向公眾帳號發(fā)消息時，微信服務器會將消息通過POST方式提交給我們在接口配置信息中填寫的URL，而我們就需要在URL所指向的請求處理類WxServlet的doPost方法中接收消息、處理消息和響應消息。

4.1.編寫一個用于處理消息的工具類

　　編寫處理消息的工具欄,工具類代碼如下:

package me.gacl.wx.util;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import javax.servlet.http.HttpServletRequest;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 消息處理工具類
 * Created by xdp on 2016/1/26.
 */
public class MessageHandlerUtil {

    /**
     * 解析微信發(fā)來的請求（XML）
     * @param request
     * @return map
     * @throws Exception
     */
    public static Map<String,String> parseXml(HttpServletRequest request) throws Exception {
        // 將解析結(jié)果存儲在HashMap中
        Map<String,String> map = new HashMap();
        // 從request中取得輸入流
        InputStream inputStream = request.getInputStream();
        System.out.println("獲取輸入流");
        // 讀取輸入流
        SAXReader reader = new SAXReader();
        Document document = reader.read(inputStream);
        // 得到xml根元素
        Element root = document.getRootElement();
        // 得到根元素的所有子節(jié)點
        List<Element> elementList = root.elements();

        // 遍歷所有子節(jié)點
        for (Element e : elementList) {
            System.out.println(e.getName() + "|" + e.getText());
            map.put(e.getName(), e.getText());
        }

        // 釋放資源
        inputStream.close();
        inputStream = null;
        return map;
    }

    // 根據(jù)消息類型 構(gòu)造返回消息
    public static String buildXml(Map<String,String> map) {
        String result;
        String msgType = map.get("MsgType").toString();
        System.out.println("MsgType:" + msgType);
        if(msgType.toUpperCase().equals("TEXT")){
            result = buildTextMessage(map, "孤傲蒼狼在學習和總結(jié)微信開發(fā)了,構(gòu)建一條文本消息:Hello World!");
        }else{
            String fromUserName = map.get("FromUserName");
            // 開發(fā)者微信號
            String toUserName = map.get("ToUserName");
            result = String
                    .format(
                            "<xml>" +
                                    "<ToUserName><![CDATA[%s]]></ToUserName>" +
                                    "<FromUserName><![CDATA[%s]]></FromUserName>" +
                                    "<CreateTime>%s</CreateTime>" +
                                    "<MsgType><![CDATA[text]]></MsgType>" +
                                    "<Content><![CDATA[%s]]></Content>" +
                                    "</xml>",
                            fromUserName, toUserName, getUtcTime(),
                            "請回復如下關鍵詞：\n文本\n圖片\n語音\n視頻\n音樂\n圖文");
        }

        return result;
    }

    /**
     * 構(gòu)造文本消息
     *
     * @param map
     * @param content
     * @return
     */
    private static String buildTextMessage(Map<String,String> map, String content) {
        //發(fā)送方帳號
        String fromUserName = map.get("FromUserName");
        // 開發(fā)者微信號
        String toUserName = map.get("ToUserName");
        /**
         * 文本消息XML數(shù)據(jù)格式
         * <xml>
             <ToUserName><![CDATA[toUser]]></ToUserName>
             <FromUserName><![CDATA[fromUser]]></FromUserName>
             <CreateTime>1348831860</CreateTime>
             <MsgType><![CDATA[text]]></MsgType>
             <Content><![CDATA[this is a test]]></Content>
             <MsgId>1234567890123456</MsgId>
         </xml>
         */
        return String.format(
                "<xml>" +
                        "<ToUserName><![CDATA[%s]]></ToUserName>" +
                        "<FromUserName><![CDATA[%s]]></FromUserName>" +
                        "<CreateTime>%s</CreateTime>" +
                        "<MsgType><![CDATA[text]]></MsgType>" +
                        "<Content><![CDATA[%s]]></Content>" + "</xml>",
                fromUserName, toUserName, getUtcTime(), content);
    }

    private static String getUtcTime() {
        Date dt = new Date();// 如果不需要格式,可直接用dt,dt就是當前系統(tǒng)時間
        DateFormat df = new SimpleDateFormat("yyyyMMddhhmm");// 設置顯示格式
        String nowTime = df.format(dt);
        long dd = (long) 0;
        try {
            dd = df.parse(nowTime).getTime();
        } catch (Exception e) {

        }
        return String.valueOf(dd);
    }
}

　　為了方便解析微信服務器發(fā)送給我們的xml格式的數(shù)據(jù),這里我們借助于開源框架dom4j去解析xml（這里使用的是dom4j-2.0.0-RC1.jar）

4.2.在WxServlet的doPost方法中處理請求

　　WxServlet的doPost方法的代碼如下:

/**
     * 處理微信服務器發(fā)來的消息
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO 接收、處理、響應由微信服務器轉(zhuǎn)發(fā)的用戶發(fā)送給公眾帳號的消息
        // 將請求、響應的編碼均設置為UTF-8（防止中文亂碼）
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        System.out.println("請求進入");
        String result = "";
        try {
            Map<String,String> map = MessageHandlerUtil.parseXml(request);
            System.out.println("開始構(gòu)造消息");
            result = MessageHandlerUtil.buildXml(map);
            System.out.println(result);
            if(result.equals("")){
                result = "未正確響應";
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("發(fā)生異常："+ e.getMessage());
        }
        response.getWriter().println(result);
    }

　　到此,我們的WxServlet已經(jīng)可以正常處理用戶的請求并做出響應了.接下來我們測試一下我們開發(fā)好的公眾號應用是否可以正常和微信用戶交互

　　將WxStudy部署到Tomcat服務器,啟動服務器,記得使用ngrok將本地Tomcat服務器的8080端口映射到外網(wǎng),保證接口配置信息的URL地址:http://xdp.ngrok.natapp.cn/WxServlet可以正常與微信服務器通信

　　登錄到我們的測試公眾號的管理后臺,然后用微信掃描一下測試號的二維碼,如下圖所示:

　　關注成功后,我們開發(fā)好的公眾號應用會先給用戶發(fā)一條提示用戶操作的文本消息,微信用戶根據(jù)提示操作輸入"文本",我們的公眾號應用接收到用戶請求后就給用戶回復了一條我們自己構(gòu)建好的文本消息,如下圖所示:

　　我們的公眾號應用響應給微信用戶的文本消息的XML數(shù)據(jù)如下:

<xml>
  <ToUserName><![CDATA[ojADgs0eDaqh7XkTM9GvDmdYPoDw]]></ToUserName>
  <FromUserName><![CDATA[gh_43df3882c452]]></FromUserName>
  <CreateTime>1453755900000</CreateTime>
  <MsgType><![CDATA[text]]></MsgType>
  <Content><![CDATA[孤傲蒼狼在學習和總結(jié)微信開發(fā)了,構(gòu)建一條文本消息:Hello World!]]></Content>
</xml>

　　測試公眾號的管理后臺也可以看到關注測試號的用戶列表,如下圖所示:

　　通過這個簡單的入門程序,我們揭開了微信開發(fā)的神秘面紗了.

　更多Résumé de lapprentissage dintroduction au développement de WeChat相關文章請關注PHP中文網(wǎng)！