Tutoriel de développement de la plateforme publique WeChat (3) Construction du cadre de base

Tutoriel de développement de plateforme publique WeChat (3) Construction du cadre de base

Dans le chapitre précédent, nous avons initialement expliqué les principes de base du développement de comptes publics WeChat. Aujourd'hui, nous allons explorer la mise en œuvre de la conception.

Tout d'abord, nous avons conçu un diagramme hiérarchique de modules. Bien entendu, le diagramme ne montre qu'une méthode de mise en œuvre et ne se limite pas à cela. Voir la figure ci-dessous pour plus de détails.

Les principales fonctions sont présentées comme suit :

1) Demander la couche d'interface. Traitement des requêtes et réponses HTTP

2) Couche de distribution. La requête est transmise depuis la couche d'interface, puis le type de requête est analysé spécifiquement et distribué aux différents processeurs

3) Couche de logique métier. Voici notre logique métier spécifique Selon la demande, la logique métier spécifique est implémentée.

4) Couche de données. Lorsque nous implémentons une application, nous pouvons avoir besoin d'accéder à des données, qui peuvent être une base de données ou un fichier. S'il s'agit d'une application simple, cette couche peut ne pas être disponible.

En fait, des applications spécifiques peuvent être développées sur cette structure, et la couche d'objets de message, la couche d'objets métier, la couche d'accès aux données, la couche de gestion fonctionnelle, etc. peuvent être étendues. Ceci est juste pour donner une idée et ne se limite pas à cela.

Concevez un organigramme basé sur le diagramme hiérarchique et décrivez chaque processus de mise en œuvre en détail. pour comprendre l'ensemble du processus. Comme le montre la figure ci-dessous :

Selon l'organigramme, nous pouvons clairement comprendre l'ensemble du processus et les étapes spécifiques de mise en œuvre du traitement des messages.

Ci-dessous, nous implémentons le code pour chaque processus.

1. Recevoir les requêtes HTTP

Nous avons besoin d'un HttpHandler ou d'une page Web pour gérer les requêtes HTTP du serveur WeChat.

Ici, nous utilisons HttpHandler. En raison de sa grande flexibilité et de ses bonnes performances.

La mise en œuvre spécifique est la suivante.

    public class WeiXinHttpHandler:IHttpHandler
    {        /// <summary>
        /// 
        /// </summary>
        public bool IsReusable
        {            get { return true; }
        }        /// <summary>
        /// 处理请求        /// </summary>
        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {            //由微信服务接收请求，具体处理请求
            WeiXinService wxService = new WeiXinService(context.Request);            string responseMsg = wxService.Response();
            context.Response.Clear();
            context.Response.Charset = "UTF-8";
            context.Response.Write(responseMsg);
            context.Response.End();
        }
    }

S'il s'agit de HTTPHandler, vous devez configurer l'application spécifique dans le fichier de configuration. Nous n'expliquerons pas la configuration spécifique du nœud. Donnez directement un exemple et configurez le nœud HttpHandler comme suit Demande de distribution

Afin d'encapsuler la fonction, nous l'encapsulons également dans le composant de traitement. En fait, il peut être placé dans HttpHandler.

1) Vérifier la signature

<httpHandlers>
   <add verb="*" path="WXService.ashx" type="namespace.WeiXinHttpHandler,WXWeb" validate="true"/></httpHandlers>

S'il s'agit de la première demande, la signature doit être vérifiée. Cela équivaut à une poignée de main HTTP. Dans le chapitre précédent, l'URL du serveur et la valeur du jeton ont été définies. Cette fonction permet de vérifier si le lien réussit.

Cette requête est une requête GET. Les instructions spécifiques suivantes (officielles) :

Logique métier :

Processus de cryptage/vérification :

<1> order Sorting

<2> Épisser les trois chaînes de paramètres en une seule chaîne pour le cryptage SHA1

<3> WeChat

et le responsable n'ont fourni que des exemples de code PHP. Beaucoup de choses ne sont pas directement traduites en C#. Il existe donc également des traitements spécifiques ici. Regardons d'abord le code officiel :

Nous le traduisons dans la version C# :

Le cryptage SHA1 est requis ici. L'algorithme spécifique est le suivant :

    private function checkSignature()
    {        $signature = $_GET["signature"];        $timestamp = $_GET["timestamp"];        $nonce = $_GET["nonce"];    
                
        $token = TOKEN;        $tmpArr = array($token, $timestamp, $nonce);        sort($tmpArr);        $tmpStr = implode( $tmpArr );        $tmpStr = sha1( $tmpStr );        
        if( $tmpStr == $signature ){            return true;
        }else{            return false;
        }
    }

2) Demande de distribution

        /// <summary>
        /// 检查签名        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private bool CheckSignature()
        {            string signature = Request.QueryString[SIGNATURE];            string timestamp = Request.QueryString[TIMESTAMP];            string nonce = Request.QueryString[NONCE];

            List<string> list = new List<string>();
            list.Add(TOKEN);
            list.Add(timestamp);
            list.Add(nonce);            //排序            list.Sort();            //拼串
            string input = string.Empty;            foreach (var item in list)
            {
                input += item;
            }            //加密
            string new_signature = SecurityUtility.SHA1Encrypt(input);            //验证
            if (new_signature == signature)
            {                return true;
            }            else
            {                return false;
            }
        }

L'étape suivante est la demande de message spécifique, voici toutes les requêtes POST.

Comme il existe plusieurs types de messages, nous les encapsulons via des classes d'usine, puis chaque message dispose d'un processeur dédié pour le traitement. Logique spécifique d'implémentation :

        /// <summary>
        /// SHA1加密        /// </summary>
        /// <param name="intput">输入字符串</param>
        /// <returns>加密后的字符串</returns>
        public static string SHA1Encrypt(string intput)
        {            byte[] StrRes = Encoding.Default.GetBytes(intput);
            HashAlgorithm mySHA = new SHA1CryptoServiceProvider();
            StrRes = mySHA.ComputeHash(StrRes);
            StringBuilder EnText = new StringBuilder();            foreach (byte Byte in StrRes)
            {
                EnText.AppendFormat("{0:x2}", Byte);
            }            return EnText.ToString();
        }

Méthode externe de traitement des requêtes (c'est la méthode appelée par HttpHandler), soit :

        /// <summary>
        /// 处理请求        /// </summary>
        /// <returns></returns>
        private string ResponseMsg()
        {            string requestXml = Common.ReadRequest(this.Request);
            IHandler handler = HandlerFactory.CreateHandler(requestXml);            if (handler != null)
            {                return handler.HandleRequest();
            }            return string.Empty;
        }

3. Le processeur de message traite spécifiquement le message

1) Type de message

Premièrement, jetons un coup d'œil aux types de messages spécifiques. En fait, l'interface des messages a été clairement présentée dans l'image précédente.

Regardons de plus près ici pour voir quels types de messages sont demandés, à quels types de messages on répond, etc.

        /// <summary>
        /// 处理请求，产生响应        /// </summary>
        /// <returns></returns>
        public string Response()
        {            string method = Request.HttpMethod.ToUpper();            //验证签名
            if (method == "GET")
            {                if (CheckSignature())
                {                    return Request.QueryString[ECHOSTR];
                }                else
                {                    return "error";
                }
            }            //处理消息
            if (method == "POST")
            {                return ResponseMsg();
            }            else
            {                return "无法处理";
            }
        }

Assurez-vous de noter que le message demandé est de type texte et que le message de réponse n'est pas nécessairement du texte. Il peut s'agir de n'importe quel type de message auquel il faut répondre tel que des graphiques, du texte, de la musique, etc. Voir le tableau ci-dessous pour plus de détails.

2) Concevoir la classe de message en fonction de l'interface de message spécifique.

这里给出类图，供参考。

 

3）针对不同的消息，会有不同的处理器，来看下具体的类图。

  

4）具体业务处理 

每个handler里面就是可以处理具体请求。输入的什么消息，访问那些数据，调用服务等，都在这里处理。

还是建议大家对具体的业务进行单独封装，在Handler中，只提供调用的接口。

因为随着业务的增加，一个Handler可能要处理很多业务，如果所有的操作逻辑都写在这里，势必影响阅读，也不易于维护与扩展。 

5）产生回复消息

在处理完请求后，需要生成回复消息，响应到终端。消息格式，就是我们介绍那些消息类型，但必须是可用于回复的，当前支持的有：文本、图文、音乐等。

一定要明确：回复的消息类型不一定要与请求的消息类型一样，比如，请求是文本，回复的可以是图文、音乐。

产生回复消息的过程，其实，就是特定的消息对象格式化为对应的XML的过程，然后将XML响应至微信服务器。

6）实例

这里以微信用户关注公众账号，然后服务端处理处理事件请求，登记用户，并提示欢迎信息。

    class EventHandler : IHandler
    {        /// <summary>
        /// 请求的xml        /// </summary>
        private string RequestXml { get; set; }        /// <summary>
        /// 构造函数        /// </summary>
        /// <param name="requestXml"></param>
        public EventHandler(string requestXml)
        {            this.RequestXml = requestXml;
        }        /// <summary>
        /// 处理请求        /// </summary>
        /// <returns></returns>
        public string HandleRequest()
        {            string response = string.Empty;
            EventMessage em = EventMessage.LoadFromXml(RequestXml);            if (em.Event == EventType.Subscribe)
            {                //注册用户
                User user = new User();
                user.OpenID = em.FromUserName;
                UserManager.Regester(user);                //回复欢迎消息
                TextMessage tm = new TextMessage();
                tm.ToUserName = em.FromUserName;
                tm.FromUserName = em.ToUserName;
                tm.CreateTime = Common.GetNowTime();
                tm.Content = "欢迎您关注xxx，我是小微。有什么我能帮助您的吗？";
                response = tm.GenerateContent();
            }            return response;
        }
    }

 

四、HTTP响应

 最后将处理结果返回至最初HttpHandler，响应给微信服务器，直接Response处理。这也是在最开始设计的HttpHandler中实现的。

下面是代码片段，具体可见一、Http请求 

            context.Response.Clear();
            context.Response.Charset = "UTF-8";
            context.Response.Write(responseMsg);
            context.Response.End();

 更多微信公众平台开发教程（三） 基础框架搭建 相关文章请关注PHP中文网！