标签 Opensource 下的文章

使用Golang开发微信公众平台-发送客服消息

关注并使用过微信“飞常准”公众号的朋友们都有过如下体验:查询一个航班情况后,这个航班的checkin、登机、起降等信息都会在后续陆续异步发给你,这个服务就是通过微信公众平台的客服消息实现的。

微信公众平台开发文档中关于客服消息的解释如下:“当用户主动发消息给公众号的时候(包括发送信息、点击自定义菜单、订阅事件、扫描二维码事件、支付成功 事件、用户维权),微信将会把消息数据推送给开发者,开发者在一段时间内(目前修改为48小时)可以调用客服消息接口,通过POST一个JSON数据包来 发送消息给普通用户,在48小时内不限制发送次数。此接口主要用于客服等有人工消息处理环节的功能,方便开发者为用户提供更加优质的服务”。

这篇文章我们就来说说如何用golang实现发送文本客服消息。

一、获取access_token

access_token是公众号的全局唯一票据,公众号调用微信平台各接口时都需使用access_token。我们要主动给微信平台发送客服消息,该access_token就是我们的凭证。在构造和下发客服消息前,我们需要获取这个access_token。

access_token的有效期为2小时(7200s),我们获取一次,两小时内均可使用。微信公众平台开发文档也给出了access_token获取、保存以及刷新的技术建议。但我们这里仅是Demo,无需考虑这么多。

通过https GET请求,我们可以得到属于我们的access_token,请求line为:

https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET

golang提供了默认的http client实现,通过默认的client实现我们可以很容器的获取access_token。

const (
        token               = "wechat4go"
        appID               = "wx8e0fb2659c2eexxx"
        appSecret           = "22746009b0162fe50cb915851c53fyyy"
        accessTokenFetchUrl = "https://api.weixin.qq.com/cgi-bin/token"
)

func fetchAccessToken() (string, float64, error) {
        requestLine := strings.Join([]string{accessTokenFetchUrl,
                "?grant_type=client_credential&appid=",
                appID,
                "&secret=",
                appSecret}, "")

        resp, err := http.Get(requestLine)
        if err != nil || resp.StatusCode != http.StatusOK {
                return "", 0.0, err
        }

        defer resp.Body.Close()
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
                return "", 0.0, err
        }

        fmt.Println(string(body))
        … …
}

无论成功与否,微信平台都会返回一个包含json数据的应答:

如果获取正确,那么应答里的Json数据为:

{"access_token":"0QCeHwiRtPRUCiM5MM0cSPYIP5QOUNYdb8usRSgVZcsFuVF6mu3vQq41OIifJdrtJPGn7b1x90HdvUanpb7eZHxg40B6bU_Sgszh2byyF40","expires_in":7200}

如果获取错误,那么应答里的Json数据为:

{"errcode":40001,"errmsg":"invalid credential"}

和xml数据包一样,golang也提供了json格式数据包的Marshal和Unmarshal方法,且使用方式相同,也是将一个json数据包与一 个struct对应起来。从上面来看,通过http response,我们无法区分出是否成功获取了token,因此我们需要首先判断试下body中是否包含某些特征字符串,比 如"access_token":

if bytes.Contains(body, []byte("access_token")) {
    //unmarshal to AccessTokenResponse struct
} else {
    //unmarshal to AccessTokenErrorResponse struct
}

针对获取成功以及失败的两种Json数据,我们定义了两个结构体:

type AccessTokenResponse struct {
        AccessToken string  `json:"access_token"`
        ExpiresIn   float64 `json:"expires_in"`
}

type AccessTokenErrorResponse struct {
        Errcode float64
        Errmsg  string
}

Json unmarshal的代码片段如下:

//Json Decoding
if bytes.Contains(body, []byte("access_token")) {
        atr := AccessTokenResponse{}
        err = json.Unmarshal(body, &atr)
        if err != nil {
            return "", 0.0, err
        }
        return atr.AccessToken, atr.ExpiresIn, nil
} else {
        fmt.Println("return err")
        ater := AccessTokenErrorResponse{}
        err = json.Unmarshal(body, &ater)
        if err != nil {
            return "", 0.0, err
        }
        return "", 0.0, fmt.Errorf("%s", ater.Errmsg)
}

我们的main函数如下:
func main() {
        accessToken, expiresIn, err := fetchAccessToken()
        if err != nil {
                log.Println("Get access_token error:", err)
                return
        }
        fmt.Println(accessToken, expiresIn)
}

编译执行,成功获取access_token的输出如下:

0QCeHwiRtPRUCiM5MM0cSPYIP5QOUNYdb8usRSgVZcsFuVF6mu3vQq41OIifJdrtJPGn7b1x90HdvUanpb7eZHxg40B6bU_Sgszh2byyF40 7200

失败时,输出如下:

2014/12/30 12:39:56 Get access_token error: invalid credential

二、发送客服消息

平台开发文档中定义了文本客服消息的body格式,一个json数据:

{
    "touser":"OPENID",
    "msgtype":"text",
    "text":
    {
         "content":"Hello World"
    }
}

其中的touser填写的是openid。之前的文章中提到过,每个微信用户针对某一个订阅号/服务号都有唯一的OpenID,这个ID可以在微信订阅号 /服务号管理页面中看到,也可以在收到的微信平台转发的消息中看到(FromUserName)。比如我个人订阅的我的测试体验号后得到的OpenID 为:

BQcwuAbKpiSAbbvd_DEZg7q27QI

我们要做的就是构造这样一个json数据,并放入HTTP Post包中,发到:

https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=ACCESS_TOKEN

从平台开发文档给出的json数据包样例来看,这是个嵌套json数据包,我们通过下面方法marshall:

type CustomServiceMsg struct {
        ToUser  string         `json:"touser"`
        MsgType string         `json:"msgtype"`
        Text    TextMsgContent `json:"text"`
}

type TextMsgContent struct {
        Content string `json:"content"`
}

func pushCustomMsg(accessToken, toUser, msg string) error {
        csMsg := &CustomServiceMsg{
                ToUser:  toUser,
                MsgType: "text",
                Text:    TextMsgContent{Content: msg},
        }

        body, err := json.MarshalIndent(csMsg, " ", "  ")
        if err != nil {
                return err
        }
        fmt.Println(string(body))
        … …
}

如果单纯输出上面marshal的结果,可以看到:

{
   "touser": "oBQcwuAbKpiSAbbvd_DEZg7q27QI",
   "msgtype": "text",
   "text": {
     "content": "你好"
   }
 }

接下来将marshal后的[]byte放入一个http post的body中,发送到指定url中:

var openID = "oBQcwuAbKpiSAbbvd_DEZg7q27QI"

func pushCustomMsg(accessToken, toUser, msg string) error {
        … …

        postReq, err := http.NewRequest("POST",
                strings.Join([]string{customServicePostUrl, "?access_token=", accessToken}, ""),
                bytes.NewReader(body))
        if err != nil {
                return err
        }

        postReq.Header.Set("Content-Type", "application/json; encoding=utf-8")

        client := &http.Client{}
        resp, err := client.Do(postReq)
        if err != nil {
                return err
        }
        resp.Body.Close()

        return nil
}

我们在main函数中加上客服消息的发送环节:

func main() {
        // Fetch access_token
        accessToken, expiresIn, err := fetchAccessToken()
        if err != nil {
                log.Println("Get access_token error:", err)
                return
        }
        fmt.Println(accessToken, expiresIn)

        // Post custom service message
        msg := "你好"
        err = pushCustomMsg(accessToken, openID, msg)
        if err != nil {
                log.Println("Push custom service message err:", err)
                return
        }
}

编译执行,手机响起提示音,打开观看,微信公众平台测试号发来消息:“你好”。

上述Demo完整代码在这里可以看到,别忘了appID,appSecret改成你自己的值。

目前客服接口仅提供给认证后的订阅号以及服务号,对于未认证的订阅号,无法发送客服消息。

使用Golang开发微信公众平台-接收加密消息

在上一篇“接收文本消息”一文中,我们了解到:公众服务与微信服务器间的消息是“裸奔”的(即明文传输,通过抓包可以看到)。显然这对于一些对安 全性要求较高的大企业服务号来说,比如银行、证券、电信运营商或航空客服等是不能完全满足要求的。于是乎就有了微信服务器与公众服务间的数据加密 通信流程。

公众号管理员可以在公众号“开发者中心”选择是否采用"安全模式"(区别于明文模式):

一旦选择了“安全模式”,微信服务器在向公众号服务转发消息时会对XML数据包部分内容进行加密处理。这类加密后的请求Body中的XML数据变 成了下面这样:

xml数据基本结构变成了:

<xml>
    <ToUserName>xx</ToUserName>
    <Encrypt>xx</Encrypt>
</xml>

另外在“安全模式”下,Http Post Request line中也增加了两个字段:encrypt_typemsg_signuature,用于消息类型判断以及加密消息内容有效性校验:

POST /?signature=891789ec400309a6be74ac278030e472f90782a5&timestamp=1419214101&nonce=788148964&encrypt_type=aes&msg_signature=87d7b127fab3771b452bc6a592f530cd8edba950 HTTP/1.1\r\n

其中:

encrypt_type = "aes",说明是加密消息,否则为"raw”,即未加密消息。
msg_signature=sha1(sort(Token, timestamp, nonce, msg_encrypt))

对于测试号,测试号配置页面没有加密相关配置,因此只能通过“微信公众平台接口调试工具”来进行相关加密接口调试。

一、消息签名验证

对于“安全模式”下的消息交互,首先要做的就是消息签名验证,只有通过验证的消息才会进行下一步解密、解析和处理。

消息签名验证的原理是比较微信平台HTTP Post Line中携带的msg_signature与通过Token、timestamp、nonce和msg_encrypt等四个字段值计算出的 msg_signture是否一致,一致则通过消息签名验证。

我们依旧在procRequest中完成对“安全模式”下消息的签名验证。

//recvencryptedtextmsg.go
type EncryptRequestBody struct {
        XMLName    xml.Name `xml:"xml"`
        ToUserName string
        Encrypt    string
}

func makeMsgSignature(timestamp, nonce, msg_encrypt string) string {
        sl := []string{token, timestamp, nonce, msg_encrypt}
        sort.Strings(sl)
        s := sha1.New()
        io.WriteString(s, strings.Join(sl, ""))
        return fmt.Sprintf("%x", s.Sum(nil))
}

func validateMsg(timestamp, nonce, msgEncrypt, msgSignatureIn string) bool {
        msgSignatureGen := makeMsgSignature(timestamp, nonce, msgEncrypt)
        if msgSignatureGen != msgSignatureIn {
                return false
        }
        return true
}

func parseEncryptRequestBody(r *http.Request) *EncryptRequestBody {
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
                log.Fatal(err)
                return nil
        }
        requestBody := &EncryptRequestBody{}
        xml.Unmarshal(body, requestBody)
        return requestBody
}

func procRequest(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()

        timestamp := strings.Join(r.Form["timestamp"], "")
        nonce := strings.Join(r.Form["nonce"], "")
        signature := strings.Join(r.Form["signature"], "")
        encryptType := strings.Join(r.Form["encrypt_type"], "")
        msgSignature := strings.Join(r.Form["msg_signature"], "")

        … …

        f r.Method == "POST" {
                if encryptType == "aes" {
                        log.Println("Wechat Service: in safe mode")
                        encryptRequestBody := parseEncryptRequestBody(r)
                       
                        //Validate msg signature
                        if !validateMsg(timestamp, nonce, encryptRequestBody.Encrypt, msgSignature) {
                                log.Println("Wechat Service: msg_signature is invalid")
                                return
                        }
                        log.Println("Wechat Service: msg_signature validation is ok!")
                … …
        }
        … …
}

程序编译执行结果如下:
$sudo ./recvencryptedtextmsg
2014/12/22 13:15:56 Wechat Service: Start!

用手机微信发送一条消息给公众号,程序输出如下结果:

2014/12/22 13:17:35 Wechat Service: in safe mode
2014/12/22 13:17:35 Wechat Service: msg_signature validation is ok!

二、数据包解密

到目前为止,我们已经得到了经过消息验证ok的加密数据包EncryptRequestBody 的Encrypt。要想得到真正的消息内容,我们需要对Encrypt字段的值进行解密处理。微信采用的是AES加解密方案, 下面我们就来看看如何做AES解密。

在开发者中心选择转换为“安全模式”时,有一个字段EncodingAESKey需要填写,这个字段固定为43个字符,它就是我们在运用AES算 法时需要的那个Key。不过这个EncodingAESKey是被编了码的,真正用来加解密的AESKey需要我们自己通过解码得到。解码方法 为:

AESKey=Base64_Decode(EncodingAESKey + “=”)

Base64 decode后,我们就得到了一个32个字节的AESKey,可以看出微信加密解密用的是AES-256算法(256=32x8bit)。

在Golang中,我们可以通过下面代码得到真正的AESKey:

const (
        token = "wechat4go"
        appID = "wx5b5c2614d269ddb2"
        encodingAESKey = "kZvGYbDKbtPbhv4LBWOcdsp5VktA3xe9epVhINevtGg"
)

var aesKey []byte

func encodingAESKey2AESKey(encodingKey string) []byte {
        data, _ := base64.StdEncoding.DecodeString(encodingKey + "=")
        return data
}

func init() {
        aesKey = encodingAESKey2AESKey(encodingAESKey)
}

有了AESKey,我们再来解密数据包。微信公众平台开发文档给出了加密数据包的解析步骤:

1. aes_msg=Base64_Decode(msg_encrypt)
2. rand_msg=AES_Decrypt(aes_msg)
3. 验证尾部$AppId是否是自己的AppId,相同则表示消息没有被篡改,这里进一步加强了消息签名验证
4. 去掉rand_msg头部的16个随机字节,4个字节的msg_len和尾部的$AppId即为最终的xml消息体

微信Wiki中如果能用一个简单的图来说明Base64_Decode后的数据格式就更好了。这里进一步说明一下,解密后的数据,我们称之 plainData,它由四部分组成,按先后顺序排列分别是:

1、随机值       16字节
2、xml包长度    4字节 (注意以BIG_ENDIAN方式读取)
3、xml包  (*这部分数据的长度由上一个字段标识,这个包等价于一个完整的文本接收消息体数据,从ToUsername到MsgID都 有)
4、appID

其中第三段xml包是一个完整的接收文本数据包,与“接收消息”一文中的标准文本数据包格式一致,这就方便我们解析了。好了,下面用代码阐述解 密、解析过程以及appid验证:

procRequest中,增加如下代码:

// Decode base64
cipherData, err := base64.StdEncoding.DecodeString(encryptRequestBody.Encrypt)
if err != nil {
        log.Println("Wechat Service: Decode base64 error:", err)
        return
}

// AES Decrypt
plainData, err := aesDecrypt(cipherData, aesKey)
if err != nil {
        fmt.Println(err)
        return
}

//Xml decoding
textRequestBody, _ := parseEncryptTextRequestBody(plainData)
fmt.Printf("Wechat Service: Recv text msg [%s] from user [%s]!",
            textRequestBody.Content,
            textRequestBody.FromUserName)

根据解密方法,我们先对encryptRequestBody.Encrypt进行base64 decode操作得到cipherData,再用aesDecrypt对cipherData进行解密得到上面提到的由四部分组成的plainData。plainData经过xml decoding后就得到我们的TextRequestBody struct。

这里难点显然在aesDecrypt的实现上了。微信的加密包采用aes-256算法,秘钥长度32B,采用PKCS#7 Padding方式。Golang提供了强大的AES加密解密方法,我们利用这些方法实现微信包的解密:

func aesDecrypt(cipherData []byte, aesKey []byte) ([]byte, error) {
        k := len(aesKey) //PKCS#7
        if len(cipherData)%k != 0 {
                return nil, errors.New("crypto/cipher: ciphertext size is not multiple of aes key length")
        }

        block, err := aes.NewCipher(aesKey)
        if err != nil {
                return nil, err
        }

        iv := make([]byte, aes.BlockSize)
        if _, err := io.ReadFull(rand.Reader, iv); err != nil {
                return nil, err
        }

        blockMode := cipher.NewCBCDecrypter(block, iv)
        plainData := make([]byte, len(cipherData))
        blockMode.CryptBlocks(plainData, cipherData)
        return plainData, nil
}

对于解密后的plainData做appID校验以及xml Decoding处理如下:

func parseEncryptTextRequestBody(plainText []byte) (*TextRequestBody, error) {
        fmt.Println(string(plainText))

        // Read length
        buf := bytes.NewBuffer(plainText[16:20])
        var length int32
        binary.Read(buf, binary.BigEndian, &length)
        fmt.Println(string(plainText[20 : 20+length]))

        // appID validation
        appIDstart := 20 + length
        id := plainText[appIDstart : int(appIDstart)+len(appID)]
        if !validateAppId(id) {
                log.Println("Wechat Service: appid is invalid!")
                return nil, errors.New("Appid is invalid")
        }
        log.Println("Wechat Service: appid validation is ok!")

        // xml Decoding
        textRequestBody := &TextRequestBody{}
        xml.Unmarshal(plainText[20:20+length], textRequestBody)
        return textRequestBody, nil
}

编译执行输出textRequestBody:

&{{ xml} gh_6ebaca4bb551 on95ht9uPITsmZmq_mvuz4h6f6CI 1.419239875s text Hello, Wechat 6095588848508047134}

三、响应消息的数据包加密

微信公众平台开发文档要求:公众账号对密文消息的回复也要求加密。

对比一下普通的响应消息格式和加密后的响应消息格式:

加密后:

我们定义一个结构体映射响应消息数据包:

type EncryptResponseBody struct {
        XMLName      xml.Name `xml:"xml"`
        Encrypt      CDATAText
        MsgSignature CDATAText
        TimeStamp    string
        Nonce        CDATAText
}

type CDATAText struct {
        Text string `xml:",innerxml"`
}

我们要做的就是给EncryptResponseBody的实例逐一赋值,然后通过xml.MarshalIndent转成xml数据流即可,各字 段值生成规则如下:

Encrypt = Base64_Encode(AES_Encrypt [random(16B)+ msg_len(4B) + msg + $AppId])
MsgSignature=sha1(sort(Token, timestamp, nonce, msg_encrypt))
TimeStamp = 用请求中的值或新生成
Nonce = 用请求中的值或新生成

微信公众接口的加密复杂度要比解密高一些,关键问题在于加密结果的判定和加密逻辑的调试,AES加密出的结果每次都不同,我们要么通过微信平台真实操作验证,要么通过微信提供的在线调试工具验证加密是否正确。这里强烈建议使用在线调试工具(测试号只能选择这一种)。

在线调试工具的配置参考如下,ToUserName和FromUserName建议填写真实的(通过解密Post包打印输出得到):

如果在线调试工具收到你的应答,并解密成功,会给出如下反馈:

在procRequest中,我们在接收解析完Http Request后,通过下面几行代码构造一个加密的Response返回给微信平台或调试工具:

responseEncryptTextBody, _ := makeEncryptResponseBody(textRequestBody.ToUserName,
                                textRequestBody.FromUserName,
                                "Hello, "+textRequestBody.FromUserName,
                                nonce,
                                timestamp)
w.Header().Set("Content-Type", "text/xml")
fmt.Fprintf(w, string(responseEncryptTextBody))

func makeEncryptResponseBody(fromUserName, toUserName, content, nonce, timestamp string) ([]byte, error) {
        encryptBody := &EncryptResponseBody{}

        encryptXmlData, _ := makeEncryptXmlData(fromUserName, toUserName, timestamp, content)
        encryptBody.Encrypt = value2CDATA(encryptXmlData)
        encryptBody.MsgSignature = value2CDATA(makeMsgSignature(timestamp, nonce, encryptXmlData))
        encryptBody.TimeStamp = timestamp
        encryptBody.Nonce = value2CDATA(nonce)

        return xml.MarshalIndent(encryptBody, " ", "  ")
}

应答Xml包中只有Encrypt字段是加密的,该字段的生成方式如下:

func makeEncryptXmlData(fromUserName, toUserName, timestamp, content string) (string, error) {
        // Encrypt part3: Xml Encoding
        textResponseBody := &TextResponseBody{}
        textResponseBody.FromUserName = value2CDATA(fromUserName)
        textResponseBody.ToUserName = value2CDATA(toUserName)
        textResponseBody.MsgType = value2CDATA("text")
        textResponseBody.Content = value2CDATA(content)
        textResponseBody.CreateTime = timestamp
        body, err := xml.MarshalIndent(textResponseBody, " ", "  ")
        if err != nil {
                return "", errors.New("xml marshal error")
        }

        // Encrypt part2: Length bytes
        buf := new(bytes.Buffer)
        err = binary.Write(buf, binary.BigEndian, int32(len(body)))
        if err != nil {
                fmt.Println("Binary write err:", err)
        }
        bodyLength := buf.Bytes()

        // Encrypt part1: Random bytes
        randomBytes := []byte("abcdefghijklmnop")

        // Encrypt Part, with part4 - appID
        plainData := bytes.Join([][]byte{randomBytes, bodyLength, body, []byte(appID)}, nil)
        cipherData, err := aesEncrypt(plainData, aesKey)
        if err != nil {
                return "", errors.New("aesEncrypt error")
        }

        return base64.StdEncoding.EncodeToString(cipherData), nil
}

func aesEncrypt(plainData []byte, aesKey []byte) ([]byte, error) {
        k := len(aesKey)
        if len(plainData)%k != 0 {
                plainData = PKCS7Pad(plainData, k)
        }
       
        block, err := aes.NewCipher(aesKey)
        if err != nil {
                return nil, err
        }

        iv := make([]byte, aes.BlockSize)
        if _, err := io.ReadFull(rand.Reader, iv); err != nil {
                return nil, err
        }

        cipherData := make([]byte, len(plainData))
        blockMode := cipher.NewCBCEncrypter(block, iv)
        blockMode.CryptBlocks(cipherData, plainData)

        return cipherData, nil
}

根据官方文档: 微信所用的AES采用的时CBC模式,秘钥长度为32个字节(aesKey),数据采用PKCS#7填充;PKCS#7:K为秘钥字节数(采用32),buf为待加密的内容,N为其字节数。Buf需要被填充为K的整数倍。因此我们pad要加密的数据时,务必pad为k(=32)的整数倍,而不是aes.BlockSize(=16)的整数倍。

采用安全模式后的公众号消息交互性能似乎下降了,发送"hello, wechat"给公众号后好长时间才收到响应。

微信公众号接收加密消息的代码在这里可以下载。这些代码只是演示代码,结构上绝不算优化,大家可以将这些代码封装成通用的接口为后续微信公众平台接口开发奠定基础。

使用Golang开发微信公众平台-接收文本消息

一旦接入验证成功,成为正式开发者,你可能会迫不及待地想通过手机微信发送一条"Hello, Wechat”到你的公众号服务器。不过上一篇的那个程序还无法处理手机提交的文本消息,本篇将介绍如何用Golang编写公众号程序来接收手机端发送的 文本消息以及回复响应消息。

根据微信公众平台开发文档中描述:“当普通微信用户向公众账号发消息时,微信服务器将POST消息的XML数据包到开发者填写的URL上”。我们 用一个示意图展示一下这个消息流程:

微信服务器通过一个HTTP Post请求将终端用户发送的消息转发给公众号服务器,消息内容被包装在HTTP Post Request的Body中。数据包以XML格式存储,文本类消息XML格式样例如下(引自微信公众平台开发文档):

数据包中各个字段的含义都显而易见,我们重点关注的时Content这个字段填写的内容,也就是终端用户发送的消息内容。为了得到这个字段值,我 们需要解析微信服务器发来的HTTP Post包的Body。

在“接入验证”一文中我们提到过,微信服务器发起的请求都带有验证字段,可被公众号服务用于验证HTTP Request是否来自于微信服务器,避免恶意请求。这些用于验证来源的信息,不仅仅在接入验证阶段会发给公众号服务器,在后续微信服务器与公众号服务器 的消息交互过程中,HTTP Request中也都会携带这些信息(注意:没有echostr参数了)。

下面我们来看接收文本消息的Golang程序。

一、接收文本消息

公众号所用的HTTP Server可以沿用“接入验证”一文中的那个main中的Server,我们需要修改的是procRequest函数。

在procRequest函数中,我们保留validateUrl,用于校验请求是否来自于微信服务器。

func procRequest(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()
        if !validateUrl(w, r) {
                log.Println("Wechat Service: this http request is not from Wechat platform!")
                return
        }
        log.Println("Wechat Service: validateUrl Ok!")
       
        … …//在此解析HTTP Request Body
}

通过验证后,我们开始解析HTTP Request的Body,Body中的数据是XML格式的,我们可以通过Golang标准库encoding/xml包中提供的函数对Body进行解 析。encoding/xml根据xml字段名与struct字段名或struct tag(struct中每个字段后面反单引号引用的内容,比如xml: "xml")的对应关系将xml数据中的字段值解析到struct的字段中,因此我们需要根据这个xml包的组成定义出对应该格式的struct,这个 struct定义如下:

type TextRequestBody struct {
        XMLName      xml.Name `xml:"xml"`
        ToUserName   string
        FromUserName string
        CreateTime   time.Duration
        MsgType      string
        Content      string
        MsgId        int
}

其中FromUserName是发送方账号,这是一个OpenID,每个微信用户针对某个关注的公众号都有唯一OpenID。举个例 子:"tonybai"这个微信用户,关注了"GoNuts"和"GoDev"两个公众号,则"tonybai"发给GoNuts的消息中的 OpenID是“tonybai-gonuts”,而tonybai发给GoDev的消息中的OpenID则是“tonybai-godev”。

MsgId是一个64位整型,可用于消息排重。对于一个HTTP Post,微信服务器在五秒内如果收不到响应会断掉连接,并且针对该消息重新发起请求,总共重试三次。严谨的公众号服务端实现是应该实现消息排重功能的。

通过encoding/xml包中的Unmarshal函数,我们将上面的xml数据转换为一个TextRequestBody实例,具体代码如 下:

//recvtextmsg_unencrypt.go
func parseTextRequestBody(r *http.Request) *TextRequestBody {
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
                log.Fatal(err)
                return nil
        }
        fmt.Println(string(body))
        requestBody := &TextRequestBody{}
        xml.Unmarshal(body, requestBody)
        return requestBody
}

func procRequest(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()
        if !validateUrl(w, r) {
                log.Println("Wechat Service: this http request is not from Wechat platform!")
                return
        }

        if r.Method == "POST" {
                textRequestBody := parseTextRequestBody(r)
                if textRequestBody != nil {
                        fmt.Printf("Wechat Service: Recv text msg [%s] from user [%s]!",
                                textRequestBody.Content,
                                textRequestBody.FromUserName)
                }
        }
}

构建并执行该程序:

$>sudo ./recvtextmsg_unencrypt
2014/12/19 08:03:27 Wechat Service: Start!

通过手机微信或公众开发平台提供的页面调试工具发送"Hello, Wechat",我们可以看到如下输出:

2014/12/19 08:05:51 Wechat Service: validateUrl Ok!
Wechat Service: Recv text msg [Hello, Wechat] from user [oBQcwuAbKpiSAbbvd_DEZg7q27QI]!

上述接收"Hello, Wechat"文本消息的Http抓包分析文本如下(Copy from wireshark output):

POST /?signature=9b8233c4ef635eaf5b9545dc196da6661ee039b0&timestamp=1418976343&nonce=1368270896 HTTP/1.0\r\n
User-Agent: Mozilla/4.0\r\n
Accept: */*\r\n
Host: wechat.tonybai.com\r\n
Pragma: no-cache\r\n
Content-Length: 286\r\n
Content-Type: text/xml\r\n

公众号服务器给微信服务器返回的HTTP Post Response为:

HTTP/1.0 200 OK\r\n
Date: Fri, 19 Dec 2014 08:05:51 GMT\r\n
Content-Length: 0\r\n
Content-Type: text/plain; charset=utf-8\r\n

二、响应文本消息

上面的例子中,终端用户发送"Hello, Wechat",虽然公众号服务器成功接收到了这段内容,但终端用户并没有得到响应,这显然不那么友好!这里我们来给终端用户补发一个文本消息的响 应:Hello,用户OpenID。

这类响应消息可以通过HTTP Post Request的Response包携带,将数据放入Response包的Body中,当然也可以单独向微信公众平台发起请求(后话)。微信公众平台开发 文档中关于被动的文本消息响应的定义如下:

这与前面的接收消息结构极其类似,字段含义也不说自明。Golang encoding/xml中的Marshal(和MarshalIndent)函数提供了将struct编码为XML数据流的功能,它是 Unmarshal的逆过程,Golang实现回复 文本响应消息的代码如下:

type TextResponseBody struct {
        XMLName      xml.Name `xml:"xml"`
        ToUserName   string
        FromUserName string
        CreateTime   time.Duration
        MsgType      string
        Content      string
}

func makeTextResponseBody(fromUserName, toUserName, content string) ([]byte, error) {
        textResponseBody := &TextResponseBody{}
        textResponseBody.FromUserName = fromUserName
        textResponseBody.ToUserName = toUserName
        textResponseBody.MsgType = "text"
        textResponseBody.Content = content
        textResponseBody.CreateTime = time.Duration(time.Now().Unix())
        return xml.MarshalIndent(textResponseBody, " ", "  ")
}

func procRequest(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()
        if !validateUrl(w, r) {
                log.Println("Wechat Service: this http request is not from Wechat platform!")
                return
        }

        if r.Method == "POST" {
                textRequestBody := parseTextRequestBody(r)
                if textRequestBody != nil {
                        fmt.Printf("Wechat Service: Recv text msg [%s] from user [%s]!",
                                textRequestBody.Content,
                                textRequestBody.FromUserName)
                        responseTextBody, err := makeTextResponseBody(textRequestBody.ToUserName,
                                textRequestBody.FromUserName,
                                "Hello, "+textRequestBody.FromUserName)
                        if err != nil {
                                log.Println("Wechat Service: makeTextResponseBody error: ", err)
                                return
                        }
                        fmt.Fprintf(w, string(responseTextBody))
                }
        }
}

编译执行上面程序后,通过手机微信或网页调试工具发送一条"Hello, Wechat"到公众号,公众号会响应如下信息:“Hello, oBQcwuAbKpiSAbbvd_DEZg7q27QI",手机端微信会正确接收该响应。

上述响应的抓包分析如下。公众号服务器给微信服务器返回的HTTP Post Response为:

HTTP/1.0 200 OK\r\n
Date: Fri, 19 Dec 2014 09:03:55 GMT\r\n
Content-Length: 220\r\n
Content-Type: text/plain; charset=utf-8\r\n

\r\n
<xml><ToUserName>oBQcwuAbKpiSAbbvd_DEZg7q27QI</ToUserName><FromUserName>gh_xxxxxxxx</FromUserName><CreateTime>1418979835</CreateTime><MsgType>text</MsgType><Content>Hello, oBQcwuAbKpiSAbbvd_DEZg7q27QI</Content></xml>

三、关于Content-Type设置

虽然Content-Type为:text/plain; charset=utf-8的 响应信息可以被微信平台正确解析,但通过抓取微信平台给公众号服务器发送的HTTP Post Request来看,在发送xml数据时微信服务器用的Content-Type为Content-Type: text/xml。我们的响应信息Body也是xml数据包,我们能否为响应信息重新设置Content-Type为 text/xml呢?我们可以通过如下代码设置:

w.Header().Set("Content-Type", "text/xml")
fmt.Fprintf(w, string(responseTextBody))

不过奇怪的是我通过AWS EC2上抓包得到的Content-Type始终是“text/plain; charset=utf-8”。但利用ngrok映射到本地端口后抓包看到的却是正确的"text/xml",在AWS本地用 curl -d xxx.xxx.xxx.xxx测试公众号服务程序而抓到的包也是正确的。通过代码没看出什么端倪,因为逻辑上显式设置Header的Content- Type后,Go标准库不会在sniff内容的格式了。

通过ngrok映射本地80端口后,得到的HTTP Post Response抓包分析文字:

HTTP/1.1 200 OK\r\n
Content-Type: text/xml\r\n
Date: Sat, 20 Dec 2014 04:29:16 GMT\r\n
Content-Length: 220\r\n

xml数据包这里忽略。

四、CDATA的使用

从抓包可以看到,我们回复的响应中的XML数据包是不带CDATA,即便这样微信客户端接收也没有问题。但这并未严遵循协议样例。

XML下CDATA含义是:在标记CDATA下,所有的标记、实体引用都被忽略,而被XML处理程序一视同仁地当做字符数据看待,CDATA的形 式如下:

<![CDATA[文本内容]]>

我们尝试加上为每个文本类型的字段值上直接添加CDATA标记。

func value2CDATA(v string) string {
        return "<![CDATA[" + v + "]]>"
}

func makeTextResponseBody(fromUserName, toUserName, content string) ([]byte, error) {
        textResponseBody := &TextResponseBody{}
        textResponseBody.FromUserName = value2CDATA(fromUserName)
        textResponseBody.ToUserName = value2CDATA(toUserName)
        textResponseBody.MsgType = value2CDATA("text")
        textResponseBody.Content = value2CDATA(content)
        textResponseBody.CreateTime = time.Duration(time.Now().Unix())
        return xml.MarshalIndent(textResponseBody, " ", "  ")
}

这样修改后,我们试着发一条消息给微信公众号平台,不过结果并不正确。手机微信无法收到响应信息,并显示“该公众号暂时无法提供服务,请稍后再 试”。通过Println输出Body可以看到:

<xml><ToUserName>&lt;![CDATA[oBQcwuAbKpiSAbbvd_DEZg7q27QI]]&gt;&lt;![CDATA[gh_1fd4719f81fe]]&gt;</FromUserName><CreateTime>1419051400</CreateTime><MsgType>&lt;![CDATA[text]]&gt;</MsgType><Content>&lt;![CDATA[Hello, oBQcwuAbKpiSAbbvd_DEZg7q27QI]]&gt;</Content></xml>

可以看到左右尖括号分别被转义为&lt;和&gt;了,这显然不是我们想要的结果。那如何加入CDATA标记呢。Golang并 不直接显式支持生成CDATA字段的xml流,我们只能间接实现。前面提到过struct定义时的struct tag,golang xml包规定:"a field with tag ",innerxml" is written verbatim, not subject to the usual marshalling procedure"。 大致的意思是如果一个字段的struct tag是",innerxml",则Marshal时字段值原封不动,不提交给通常的marshalling程序。我们就利用innerxml来实现 CDATA标记。

type TextResponseBody struct {
        XMLName      xml.Name `xml:"xml"`
        ToUserName   CDATAText
        FromUserName CDATAText
        CreateTime   time.Duration
        MsgType      CDATAText
        Content      CDATAText
}

type CDATAText struct {
        Text string `xml:",innerxml"`
}

func value2CDATA(v string) CDATAText {
        return CDATAText{"<![CDATA[" + v + "]]>"}
}

编译程序后测试,这回CDATA标记正确了,微信客户端也收到的响应信息。

五、用ngrok在本地调试微信公众平台接口

在“接入验证”一文中,我们建议申请诸如AWS EC2来应对微信公众平台接口开发,但其方便程度毕竟不如本地。网上一开源工具ngrok可以帮助我们实现本地调试微信公众平台接口。

使用ngrok的步骤如下:

1、下载ngrok
 ngrok也是使用golang实现的,因此主流平台都支持。ngrok下载后就是一个可执行的二进制文件,可直接执行(放在PATH路径 下)。

2、注册ngrok
到ngrok.com上注册一个账号,注册成功后,就能看到ngrok.com为你分配的auth token,把这个auth token放到~/.ngrok中:

auth_token:YOUR_AUTH_TOKEN

3、执行ngrok

$ngrok 80

ngrok                                                                                                                                                           (Ctrl+C to quit)

Tunnel Status                 online
Version                       1.7/1.6
Forwarding                    http://xxxxxxxx.ngrok.com -> 127.0.0.1:80
Forwarding                    https://xxxxxxxx.ngrok.com -> 127.0.0.1:80
Web Interface                 127.0.0.1:4040
# Conn                        1
Avg Conn Time                 1.90ms

其中"xxxxxxxx.ngrok.com"就是ngrok为你分配的子域名。

在你的微信开发者中心将这个地址配置到URL字段中,提交验证,验证消息就会顺着ngrok建立的隧道流到你的local机器的80端口上。

另外本地调试抓包,要用loopback网口,比如:
$sudo tcpdump -w http.cap -i lo0 tcp port 80

本篇文章涉及的代码在这里可以找到。




这里是Tony Bai的个人Blog,欢迎访问、订阅和留言!订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:


如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:


以太币:


如果您喜欢通过微信App浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:



本站Powered by Digital Ocean VPS。

选择Digital Ocean VPS主机,即可获得10美元现金充值,可免费使用两个月哟!

著名主机提供商Linode 10$优惠码:linode10,在这里注册即可免费获得。

阿里云推荐码:1WFZ0V立享9折!

View Tony Bai's profile on LinkedIn


文章

评论

  • 正在加载...

分类

标签

归档











更多