Méthode de développement de la plateforme publique WeChat pour garantir la validité à long terme du access_token

Afin de permettre aux développeurs tiers de fournir aux utilisateurs des services personnalisés plus précieux, la plate-forme publique WeChat a ouvert de nombreuses interfaces, notamment des interfaces de menu personnalisées, des interfaces de service client, des interfaces d'acquisition d'informations utilisateur, des interfaces de regroupement d'utilisateurs et des envois de groupes. interfaces, etc. Lorsque les développeurs appellent ces interfaces, ils doivent transmettre le même paramètre access_token, qui est le ticket globalement unique du compte public et les informations d'identification d'accès à l'interface.

La période de validité de access_token est de 7200 secondes (deux heures). Pendant la période de validité, il peut être utilisé à tout moment. Ce n'est que lorsque le access_token expire que vous devez appeler à nouveau l'interface pour obtenir le access_token. Dans des circonstances idéales, un système fonctionnant 7x24 heures n'a besoin d'obtenir access_token que 12 fois par jour, soit une fois toutes les 2 heures. Si le access_token est obtenu à nouveau pendant la période de validité, le access_token obtenu la dernière fois sera invalide.

Actuellement, la fréquence d'appel de l'interface get access_token est limitée à 2000 fois/jour Si à chaque fois que vous envoyez un message au service client, obtenez des informations utilisateur ou envoyez un message de groupe, vous devez d'abord appeler le get. access_token pour obtenir les informations d'identification d'accès à l'interface. D'une part, cela prendra plus de temps (une opération d'appel d'interface supplémentaire, d'autre part, la limite de 2000 appels par jour peut ne pas suffire). Par conséquent, dans les applications pratiques, nous devons stocker le access_token obtenu, puis appeler régulièrement l'interface access_token pour la mettre à jour afin de garantir que le access_token retiré à tout moment est valide.

Ce qui suit explique comment obtenir et stocker régulièrement access_token. Remarque : il ne s'agit pas d'un article expliquant comment appeler l'interface pour obtenir access_token. Pour plus d'informations sur l'obtention d'access_token, veuillez vous référer à l'article « Tutoriel de développement de compte public WeChat, partie 14 – Création de menu personnalisé et réponse aux événements de menu ».

Faisons une brève analyse avant d'agir. Ce que nous devons résoudre n'est rien de plus que les deux problèmes suivants :

1 Comment obtenir régulièrement un access_token ?

En Java, si vous souhaitez exécuter une tâche régulièrement, vous devez utiliser la classe java.util.Timer. Pour ceux qui aiment utiliser des frameworks, vous pouvez utiliser le framework de planification de tâches open source quartz. Le cadre à ressort prend également en charge le quartz. De plus, une autre méthode consiste à démarrer un thread, à écrire une boucle infinie dans la méthode run() du thread, puis à utiliser Thread.sleep() pour garantir que le thread exécute régulièrement une certaine tâche.

2. Où enregistrer access_token ?

Pour le stockage d'access_token, vous pouvez envisager de le stocker dans un fichier, une base de données ou une mémoire. La méthode de stockage spécifique utilisée doit être déterminée en fonction de la situation réelle du projet. S'il n'y a qu'un seul serveur, stocker directement access_token en mémoire est le moyen le plus simple et le plus efficace.

Dans cet article, l'auteur démontrera le processus d'obtention et de stockage régulier d'access_token comme suit : charger un servlet au démarrage du serveur Web, démarrer un thread dans la méthode init() du servlet et lors de l'exécution du thread. () Dans la méthode, access_token est obtenu régulièrement via une boucle infinie + Thread.sleep(), puis le access_token obtenu est enregistré dans une variable modifiée par public static.

Créez une classe InitServlet dans le projet. Le code de cette classe est le suivant :

package org.liufeng.weixin.servlet;    
    
import javax.servlet.ServletException;    
import javax.servlet.http.HttpServlet;    
import org.liufeng.weixin.thread.TokenThread;    
import org.liufeng.weixin.util.WeixinUtil;    
import org.slf4j.Logger;    
import org.slf4j.LoggerFactory;    
    
/**  
 * 初始化servlet  
 *   
 * @author liuyq  
 * @date 2013-05-02  
 */    
public class InitServlet extends HttpServlet {    
    private static final long serialVersionUID = 1L;    
    private static Logger log = LoggerFactory.getLogger(WeixinUtil.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();    
        }    
    }    
}

Comme le montre le code ci-dessus, la classe InitServlet réécrit uniquement le init(). et ne réécrit pas les méthodes doGet() et doPost() car nous n'avons pas l'intention de laisser InitServlet gérer les demandes d'accès. L'implémentation de la méthode init() est également relativement simple. Obtenez d'abord les paramètres appid et appsecret configurés dans web.xml, puis démarrez le thread TokenThread pour obtenir régulièrement le access_token.

La configuration d'InitServlet dans web.xml est la suivante :

<?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     
    <a href="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" "="">http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"</a>>    
    
    <servlet>    
        <servlet-name>initServlet</servlet-name>    
        <servlet-class>    
            org.liufeng.weixin.servlet.InitServlet    
        </servlet-class>    
        <!-- 配置获取access_token所需参数appid和appsecret -->    
        <init-param>    
            <param-name>appid</param-name>    
            <param-value>wx617a123bb8bc99cd</param-value>    
        </init-param>    
        <init-param>    
            <param-name>appsecret</param-name>    
            <param-value>4d82cbbbb08714c12345b62d7hn3dcb8</param-value>    
        </init-param>    
        <load-on-startup>0</load-on-startup>    
    </servlet>    
    
    <welcome-file-list>    
        <welcome-file>index.jsp</welcome-file>    
    </welcome-file-list>    
</web-app>

La configuration d'InitServlet dans web.xml est différente de la configuration d'un Servlet ordinaire en plusieurs points : 1) Par configurer c732fb21e86dbf3f17b65406ed2db262 Transmettre les paramètres dans le servlet 2) Configurer 4781e2cbaa93c386271b418d3a01af08 pour charger le servlet au démarrage du serveur Web 3) Il n'y a pas de 870ae7edaa11700bcea972d006efb06e ne fournit pas d'accès externe.

Le code source de TokenThread est le suivant :

package org.liufeng.weixin.thread;    
    
import org.liufeng.weixin.pojo.AccessToken;    
import org.liufeng.weixin.util.WeixinUtil;    
import org.slf4j.Logger;    
import org.slf4j.LoggerFactory;    
    
/**  
 * 定时获取微信access_token的线程  
 *   
 * @author liuyq  
 * @date 2013-05-02  
 */    
public class TokenThread implements Runnable {    
    private static Logger log = LoggerFactory.getLogger(TokenThread.class);    
    // 第三方用户唯一凭证    
    public static String appid = "";    
    // 第三方用户唯一凭证密钥    
    public static String appsecret = "";    
    public static AccessToken accessToken = null;    
    
    public void run() {    
        while (true) {    
            try {    
                accessToken = WeixinUtil.getAccessToken(appid, appsecret);    
                if (null != accessToken) {    
                    log.info("获取access_token成功，有效时长{}秒 token:{}", accessToken.getExpiresIn(), accessToken.getToken());    
                    // 休眠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);    
            }    
        }    
    }    
}

La ligne 23 du code construit une boucle infinie (exécution permanente) via while(true){}; Appelez l'interface de la plate-forme publique pour obtenir le access_token ; la ligne 29 laisse le thread dormir pendant 7 000 secondes avant de s'exécuter, c'est-à-dire obtenir le access_token toutes les 7 000 secondes pour garantir que le access_token n'expire jamais. Dans d'autres classes du projet, vous pouvez obtenir les informations d'identification d'accès à l'interface access_token en appelant TokenThread.accessToken.getToken(). Déployez et exécutez le programme localement. Après le démarrage de Tomcat, le journal suivant s'affichera sur la console :

[INFO ] weixin api appid:wx617a123bb8bc99cd    
[INFO ] weixin api appsecret:4d82cbbbb08714c12345b62d7hn3dcb8    
[INFO ] 获取access_token成功，有效时长7200秒 token:sFopJ9lMmLl4u-ad61ojKpS0TolhN2s3SnHoI2Mh5GgdiYb35i-7DG2T2CDyQKMe

Afin de voir intuitivement l'effet de l'obtention régulière d'access_token, vous pouvez essayer de définir le thread. temps de sommeil dans TokenThread Modifier à 30 secondes ou 60 secondes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!