C# entwickelt das WeChat-Portal und verwendet das WeChat-Unternehmenskonto zum Empfangen, Verarbeiten und Entschlüsseln von Nachrichten und Ereignissen

1. Festlegen des Rückrufmodus des Unternehmenskontos

Ähnlich wie beim öffentlichen Konto müssen die entsprechenden Rückrufparameter im Hintergrund festgelegt werden, wenn das WeChat-Unternehmenskonto eine sekundäre Entwicklung erfordert folgende Schnittstelle.

Nachdem wir diese festgelegt und die Prüfung bestanden haben, können wir Nachrichten auf unserem eigenen WeChat-Anwendungsserver senden und empfangen.

Bei der Eingabe der Rückrufnachricht müssen wir POST-Daten und gewöhnliche GET-Daten separat verarbeiten. GET-Daten sind die eigene Verifizierungsverarbeitung von WeChat, und POST-Daten sind die interaktive Operation von WeChat-Nachrichten.

    /// <summary>
    /// 企业号回调信息接口。统一接收并处理信息的入口。    /// </summary>
    public class corpapi : IHttpHandler
    {        /// <summary>
        /// 处理企业号的信息        /// </summary>
        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {

Oben haben wir einen allgemeinen Anwendungshandler zum Verarbeiten von Nachrichten definiert.

Dann trennen wir verschiedene Nachrichtentypen (POST-, GET-Methoden) und verarbeiten sie entsprechend.

                    if (HttpContext.Current.Request.HttpMethod.ToUpper() == "POST")
                    {                        using (Stream stream = HttpContext.Current.Request.InputStream)
                        {
                            Byte[] postBytes = new Byte[stream.Length];
                            stream.Read(postBytes, 0, (Int32)stream.Length);
                            postString = Encoding.UTF8.GetString(postBytes);
                        }                        if (!string.IsNullOrEmpty(postString))
                        {
                            Execute(postString, accountInfo);
                        }
                    }                    else
                    {
                        Auth(accountInfo);
                    }

2. Überprüfung von WeChat-Rückrufnachrichten

Im Folgenden finden Sie die Anweisungen von WeChat für den Rückrufmodus und die Überprüfungs-URL.

URL-Gültigkeit überprüfen

Wenn Sie die oben genannten Informationen übermitteln, sendet das Unternehmenskonto eine GET-Anfrage an die ausgefüllte URL. Die GET-Anfrage enthält vier Parameter: Unternehmen müssen beim Erhalt von eine URL-Decode-Verarbeitung durchführen, andernfalls ist die Überprüfung nicht erfolgreich.

参数	描述	是否必带
msg_signature	微信加密签名，msg_signature结合了企业填写的token、请求中的timestamp、nonce参数、加密的消息体	是
timestamp	时间戳	是
nonce	随机数	是
echostr	加密的随机字符串，以msg_encrypt格式提供。需要解密并返回echostr明文，解密后有random、msg_len、msg、$CorpID四个字段，其中msg即为echostr明文	首次校验时必带

Das Unternehmen überprüft die Anfrage über den Parameter msg_signature. Wenn bestätigt wird, dass die GET-Anfrage vom Unternehmenskonto stammt, dann Die Unternehmensanwendung entschlüsselt den Echostr-Parameter und gibt den Echostr-Klartext zurück Ist dies der Fall (keine Anführungszeichen), dann wird die Zugriffsüberprüfung wirksam und der Rückrufmodus kann aktiviert werden.

Wenn nachfolgende Rückrufe an das Unternehmen erfolgen, werden die oben genannten Parameter (außer echostr) in die Anforderungs-URL aufgenommen und die Überprüfungsmethode ist dieselbe wie die erste Überprüfungs-URL.

Gemäß den obigen Anweisungen müssen wir diese Parameter abrufen und dann die von WeChat bereitgestellte Nachrichtenverarbeitungsfunktion aufrufen, um die Verschlüsselungs- und Entschlüsselungsverarbeitung durchzuführen.

In der Auth(accountInfo);-Operation zur Überprüfung der URL können wir sehen, dass der Kerninhalt wie folgt lautet: Die übergebenen Parameterinformationen werden abgerufen und dann an die Basisklasse übergeben, um sie zu verarbeiten Signaturinhalt der Nachricht.

                        #region 具体处理逻辑                        string echoString = HttpContext.Current.Request.QueryString["echoStr"];                        string signature = HttpContext.Current.Request.QueryString["msg_signature"];//企业号的 msg_signature
                        string timestamp = HttpContext.Current.Request.QueryString["timestamp"];                        string nonce = HttpContext.Current.Request.QueryString["nonce"];                        string decryptEchoString = "";                        if (new CorpBasicApi().CheckSignature(token, signature, timestamp, nonce, corpId, encodingAESKey, echoString, ref decryptEchoString))
                        {                            if (!string.IsNullOrEmpty(decryptEchoString))
                            {
                                HttpContext.Current.Response.Write(decryptEchoString);
                                HttpContext.Current.Response.End();
                            }
                        } 
                        #endregion

Die Abteilung für den Bestätigungscode wird unten angezeigt.

        /// <summary>
        /// 验证企业号签名        /// </summary>
        /// <param name="token">企业号配置的Token</param>
        /// <param name="signature">签名内容</param>
        /// <param name="timestamp">时间戳</param>
        /// <param name="nonce">nonce参数</param>
        /// <param name="corpId">企业号ID标识</param>
        /// <param name="encodingAESKey">加密键</param>
        /// <param name="echostr">内容字符串</param>
        /// <param name="retEchostr">返回的字符串</param>
        /// <returns></returns>
        public bool CheckSignature(string token, string signature, string timestamp, string nonce, string corpId, string encodingAESKey, string echostr, ref string retEchostr)
        {
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(token, encodingAESKey, corpId);            int result = wxcpt.VerifyURL(signature, timestamp, nonce, echostr, ref retEchostr);            if (result != 0)
            {
                LogTextHelper.Error("ERR: VerifyURL fail, ret: " + result);                return false;
            }            return true;
        }

3. Nachrichtenverarbeitung des Unternehmenskontos

Oben wird der Verifizierungsprozess des WeChat-Unternehmenskontos für die URL vorgestellt Sonstiges Ein Nachrichtenverarbeitungsprozess ist der Prozess, bei dem der WeChat-Server die Nachricht zur Verarbeitung an unseren eigenen Anwendungsserver sendet. Unser Anwendungsserver muss nach dem Empfang der Nachricht eine regelmäßige Antwortverarbeitung durchführen.

ist die Codelogik unten.

                    if (HttpContext.Current.Request.HttpMethod.ToUpper() == "POST")
                    {                        using (Stream stream = HttpContext.Current.Request.InputStream)
                        {
                            Byte[] postBytes = new Byte[stream.Length];
                            stream.Read(postBytes, 0, (Int32)stream.Length);
                            postString = Encoding.UTF8.GetString(postBytes);
                        }                        if (!string.IsNullOrEmpty(postString))
                        {
                            Execute(postString, accountInfo);
                        }
                    }

Wenn wir auf eine Nachricht an den WeChat-Server antworten, müssen wir auch die entsprechenden Parameter abrufen und dann die Nachrichtenantwort erstellen.

            string echoString = HttpContext.Current.Request.QueryString["echoStr"];            string signature = HttpContext.Current.Request.QueryString["msg_signature"];//企业号的 msg_signature
            string timestamp = HttpContext.Current.Request.QueryString["timestamp"];            string nonce = HttpContext.Current.Request.QueryString["nonce"];

Und einige andere Parameterinformationen stammen aus den Konfigurationsparametern unseres Unternehmenskontos.

            //获取配置参数并对加解密函数初始化
            string CorpToken = accountInfo.Token;            string AESKey = accountInfo.EncodingAESKey;            string CorpId = accountInfo.CorpID;

Verwenden Sie dann die von WeChat bereitgestellte Nachrichtenverschlüsselungs- und -entschlüsselungsklasse, um die Nachricht erfolgreich zu ver- und entschlüsseln. Der spezifische Operationscode lautet wie folgt.

            //根据参数信息，初始化微信对应的消息加密解密类
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(CorpToken, AESKey, CorpId);            //对收到的密文进行解析处理
            string sMsg = "";  // 解析之后的明文
            int flag = wxcpt.DecryptMsg(signature, timestamp, nonce, postStr, ref sMsg);            if (flag == 0)
            {                //LogTextHelper.Info("记录解密后的数据:");                //LogTextHelper.Info(sMsg);//记录解密后的数据
                CorpApiDispatch dispatch = new CorpApiDispatch();                string responseContent = dispatch.Execute(sMsg);                //加密后并发送                //LogTextHelper.Info(responseContent);
                string encryptResponse = "";
                timestamp = DateTime.Now.DateTimeToInt().ToString();
                wxcpt.EncryptMsg(responseContent, timestamp, nonce, ref encryptResponse, ref signature);

                HttpContext.Current.Response.ContentEncoding = Encoding.UTF8;
                HttpContext.Current.Response.Write(encryptResponse);
            }            else
            {
                LogTextHelper.Info("解密消息失败！");
            }

Abschließend übergeben wir die entschlüsselte Nachricht einfach an die entsprechende Kapselungsklasse zur einheitlichen Verarbeitung.

                CorpApiDispatch dispatch = new CorpApiDispatch();                string responseContent = dispatch.Execute(sMsg);

Auf diese Weise müssen wir uns bei der Kapselung der Enterprise-API nur auf die Logik konzentrieren, wie auf die Nachricht reagiert werden soll, und nicht mehr Um den Rest brauchen Sie sich keine Sorgen zu machen.

Mehr C#-Entwicklung des WeChat-Portals und Anwendung des WeChat-Unternehmenskontos Empfang, Verarbeitung und Entschlüsselung von Nachrichten und Veranstaltungen Verwandte Artikel finden Sie auf der chinesischen PHP-Website!