微信消息推送消息加解密（golang）

已于 2023-03-05 23:22:03 修改
阅读量2.5k 收藏 3
点赞数 5
分类专栏： 日常 文章标签： 微信 golang 开发语言
于 2022-01-21 16:02:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Vae_sun/article/details/122622705
版权

本篇介绍如何使用golang对微信消息推送进行加解密，后续会补充，目前先写个原理，大概自己看一下，其他的自己应该也能写。老套路，分为三步，为啥写，教程，总结。懒得看的直接看第二步就行。

为什么突然写这个？

由于项目需要，需要用go做一个微服务，一个微信的授权中心，管理所有微信授权。在微信官方文档没有go的demo，本来想着搜一搜别人写的，直接用，一搜全是csdn里的文章，大概看了一下，都是差不多一致的，csdn目前的常态啊，不得不说，乱且不好用，看了看，还是自己来吧，完全跟着官方的demo逻辑，个人感觉自己写的还是挺清晰的，go自己也接触不久，有啥问题的也欢迎指出。

微信消息加解密

大概分为四个文件

wechat_err_code.go
package wechat

var SuccessCode = 0
var ValidateSignatureError = -40001
var ParseXmlError = -40002
var ComputeSignatureError = -40003
var IllegalAesKey = -40004
var ValidateAppidError = -40005
var EncryptAESError = -40006
var DecryptAESError = -40007
var IllegalBuffer = -40008
message.go（消息）
package wechat

import (
	"bytes"
	"encoding/binary"
	"encoding/xml"
	"errors"
	"strconv"
	"time"
)

var EventTicket = "component_verify_ticket"    //ticket推送
var EventUnauthorized = "unauthorized"         //取消授权
var EventUpdateAuthorized = "updateauthorized" //更新授权
var EventAuthorized = "authorized"             //授权成功

var MsgTypeText = "text"   //文本消息
var MsgTypeImage = "image" //文本消息
var MsgTypeVoice = "voice" //语音消息
var MsgTypeVideo = "Video" //视频消息
var MsgTypeMusic = "music" //音乐消息
var MsgTypeNews = "news"   //图文消息

//EventMessageBody 事件推送
type EventMessageBody struct {
	XMLName                      xml.Name `xml:"xml"`
	AppId                        string   `xml:"AppId" json:"app_id"`
	CreateTime                   int      `xml:"CreateTime" json:"create_time"`
	InfoType                     string   `xml:"InfoType" json:"info_type"`
	ComponentVerifyTicket        string   `xml:"ComponentVerifyTicket" json:"component_verify_ticket"`
	AuthorizerAppid              string   `xml:"AuthorizerAppid" json:"authorizer_appid"`
	AuthorizationCode            string   `xml:"AuthorizationCode" json:"authorization_code"`
	AuthorizationCodeExpiredTime string   `xml:"AuthorizationCodeExpiredTime" json:"authorization_code_expired_time"`
	PreAuthCode                  string   `xml:"PreAuthCode" json:"pre_auth_code"`
}

//MessageBodyDecrypt 消息体
type MessageBodyDecrypt struct {
	XMLName      xml.Name `xml:"xml"`
	ToUserName   string   `xml:"ToUserName"`
	FromUserName string   `xml:"FromUserName"`
	CreateTime   string   `xml:"CreateTime"`
	MsgType      string   `xml:"MsgType"`
	Url          string   `xml:"Url"`
	PicUrl       string   `xml:"PicUrl"`
	MediaId      string   `xml:"MediaId"`
	ThumbMediaId string   `xml:"ThumbMediaId"`
	Content      string   `xml:"Content"`
	MsgId        int      `xml:"MsgId"`
	Location_X   string   `xml:"Location_x"`
	Location_Y   string   `xml:"Location_y"`
	Label        string   `xml:"Label"`
}

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

type MessageText struct {
	XMLName      xml.Name `xml:"xml"`
	ToUserName   CDATA    `xml:"ToUserName"`
	FromUserName CDATA    `xml:"FromUserName"`
	CreateTime   string   `xml:"CreateTime"`
	MsgType      CDATA    `xml:"MsgType"`
	Content      CDATA    `xml:"Content"`
}

type MessageImage struct {
	XMLName      xml.Name `xml:"xml"`
	ToUserName   CDATA    `xml:"ToUserName"`
	FromUserName CDATA    `xml:"FromUserName"`
	CreateTime   string   `xml:"CreateTime"`
	MsgType      CDATA    `xml:"MsgType"`
	Image        Media    `xml:"Image"`
}

type MessageVoice struct {
	XMLName      xml.Name `xml:"xml"`
	ToUserName   CDATA    `xml:"ToUserName"`
	FromUserName CDATA    `xml:"FromUserName"`
	CreateTime   string   `xml:"CreateTime"`
	MsgType      CDATA    `xml:"MsgType"`
	Voice        Media    `xml:"Voice"`
}

type MessageVideo struct {
	XMLName      xml.Name `xml:"xml"`
	ToUserName   CDATA    `xml:"ToUserName"`
	FromUserName CDATA    `xml:"FromUserName"`
	CreateTime   string   `xml:"CreateTime"`
	MsgType      CDATA    `xml:"MsgType"`
	Video        Video    `xml:"Video"`
}

type MessageMusic struct {
	XMLName      xml.Name `xml:"xml"`
	ToUserName   CDATA    `xml:"ToUserName"`
	FromUserName CDATA    `xml:"FromUserName"`
	CreateTime   string   `xml:"CreateTime"`
	MsgType      CDATA    `xml:"MsgType"`
	Music        Music    `xml:"Music"`
}

type MessageArticle struct {
	XMLName      xml.Name      `xml:"xml"`
	ToUserName   CDATA         `xml:"ToUserName"`
	FromUserName CDATA         `xml:"FromUserName"`
	CreateTime   string        `xml:"CreateTime"`
	MsgType      CDATA         `xml:"MsgType"`
	ArticleCount string        `xml:"ArticleCount"`
	Articles     []ArticleItem `xml:"Articles"`
}

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

type Media struct {
	MediaId CDATA `xml:"MediaId"`
}

type Video struct {
	MediaId     CDATA `xml:"MediaId"`
	Title       CDATA `xml:"Title"`
	Description CDATA `xml:"Description"`
}

type Music struct {
	Title        CDATA `xml:"Title"`
	Description  CDATA `xml:"Description"`
	MusicUrl     CDATA `xml:"MusicUrl"`
	HQMusicUrl   CDATA `xml:"HQMusicUrl"`
	ThumbMediaId CDATA `xml:"ThumbMediaId"`
}

type ArticleItem struct {
	Title       CDATA `xml:"Title"`
	Description CDATA `xml:"Description"`
	PicUrl      CDATA `xml:"PicUrl"`
	Url         CDATA `xml:"Url"`
}

func FormatMessage(plainText []byte, data interface{}) (*interface{}, error) {
	length := GetMessageLength(plainText)
	err := xml.Unmarshal(plainText[20:20+length], data)
	if err != nil {
		return nil, errors.New("格式化消息失败：format message error")
	}
	return &data, nil
}

func GetMessageLength(plainText []byte) int32 {
	// Read length
	buf := bytes.NewBuffer(plainText[16:20])
	var length int32
	err := binary.Read(buf, binary.BigEndian, &length)
	if err != nil {
		panic("获取消息长度失败：read message length error")
	}
	return length
}

func ValueToCDATA(content string) CDATA {
	return CDATA{"<![CDATA[" + content + "]]>"}
}

//FormatTextMessage 格式化文本消息
func FormatTextMessage(fromUserName string, toUserName string, content string) []byte {
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	textMessage := MessageText{FromUserName: ValueToCDATA(fromUserName), ToUserName: ValueToCDATA(toUserName), Content: ValueToCDATA(content), CreateTime: timestamp, MsgType: ValueToCDATA(MsgTypeText)}
	messageBytes, err := xml.MarshalIndent(textMessage, " ", "  ")
	if err != nil {
		panic("格式化文本消息失败：xml marsha1 error；" + err.Error())
	}
	return messageBytes
}

//FormatImageMessage 格式化图片消息
func FormatImageMessage(fromUserName string, toUserName string, mediaId string) []byte {
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	imageMessage := MessageImage{FromUserName: ValueToCDATA(fromUserName), ToUserName: ValueToCDATA(toUserName), CreateTime: timestamp, MsgType: ValueToCDATA(MsgTypeImage), Image: Media{ValueToCDATA(mediaId)}}
	messageBytes, err := xml.MarshalIndent(imageMessage, " ", "  ")
	if err != nil {
		panic("格式化图片消息失败：xml marsha1 error；" + err.Error())
	}
	return messageBytes
}

//FormatVoiceMessage 格式语音消息
func FormatVoiceMessage(fromUserName string, toUserName string, mediaId string) []byte {
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	voiceMessage := MessageVoice{FromUserName: ValueToCDATA(fromUserName), ToUserName: ValueToCDATA(toUserName), CreateTime: timestamp, MsgType: ValueToCDATA(MsgTypeVoice), Voice: Media{ValueToCDATA(mediaId)}}
	messageBytes, err := xml.MarshalIndent(voiceMessage, " ", "  ")
	if err != nil {
		panic("格式化语音消息失败：xml marsha1 error；" + err.Error())
	}
	return messageBytes
}

//FormatVideoMessage 格式化视频消息
func FormatVideoMessage(fromUserName string, toUserName string, mediaId string, title string, description string) []byte {
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	videoMessage := MessageVideo{FromUserName: ValueToCDATA(fromUserName), ToUserName: ValueToCDATA(toUserName), CreateTime: timestamp, MsgType: ValueToCDATA(MsgTypeVideo), Video: Video{
		MediaId:     ValueToCDATA(mediaId),
		Title:       ValueToCDATA(title),
		Description: ValueToCDATA(description),
	}}
	messageBytes, err := xml.MarshalIndent(videoMessage, " ", "  ")
	if err != nil {
		panic("格式化语音消息失败：xml marsha1 error；" + err.Error())
	}
	return messageBytes
}

//FormatMusicMessage 格式化音乐消息
func FormatMusicMessage(fromUserName string, toUserName string, thumbMediaId string, title string, description string, musicUrl string, hQMusicUrl string) []byte {
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	musicMessage := MessageMusic{FromUserName: ValueToCDATA(fromUserName), ToUserName: ValueToCDATA(toUserName), CreateTime: timestamp, MsgType: ValueToCDATA(MsgTypeMusic), Music: Music{
		Title:        ValueToCDATA(title),
		Description:  ValueToCDATA(description),
		MusicUrl:     ValueToCDATA(musicUrl),
		HQMusicUrl:   ValueToCDATA(hQMusicUrl),
		ThumbMediaId: ValueToCDATA(thumbMediaId),
	}}
	messageBytes, err := xml.MarshalIndent(musicMessage, " ", "  ")
	if err != nil {
		panic("格式化音乐消息失败：xml marsha1 error；" + err.Error())
	}
	return messageBytes
}

//FormatArticlesMessage 格式化音乐消息
func FormatArticlesMessage(fromUserName string, toUserName string, items []ArticleItem) []byte {
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	articleNum := strconv.Itoa(len(items))
	musicMessage := MessageArticle{FromUserName: ValueToCDATA(fromUserName), ToUserName: ValueToCDATA(toUserName), CreateTime: timestamp, MsgType: ValueToCDATA(MsgTypeNews), Articles: items, ArticleCount: articleNum}
	messageBytes, err := xml.MarshalIndent(musicMessage, " ", "  ")
	if err != nil {
		panic("格式化图文消息失败：xml marsha1 error；" + err.Error())
	}
	return messageBytes
}

//FormatEncryptData 格式化微信加密数据
func FormatEncryptData(encrypted string, token string) MessageEncryptBody {
	nonce := makeRandomString(16)
	timestamp := strconv.Itoa(int(time.Now().Unix()))
	data := MessageEncryptBody{Encrypt: ValueToCDATA(encrypted), Nonce: ValueToCDATA(nonce), MsgSignature: ValueToCDATA(GetSignature(timestamp, nonce, encrypted, token)), TimeStamp: timestamp}
	return data
}
wechat_message.go
package wechat

import (
	"bytes"
	"encoding/base64"
	"encoding/binary"
	"encoding/xml"
	"errors"
	"fmt"
)

type msgCrypt struct {
	token  string
	aesKey string
	appid  string
}

//EventEncryptRequest 微信事件推送结构体
type EventEncryptRequest struct {
	XMLName xml.Name `xml:"xml"`
	Encrypt string   `xml:"Encrypt"`
	Appid   string   `xml:"Appid"`
}

//MessageEncryptRequest 微信消息加密结构体
type MessageEncryptRequest struct {
	XMLName      xml.Name `xml:"xml"`
	Encrypt      string   `xml:"Encrypt"`
	MsgSignature string   `xml:"MsgSignature"`
	TimeStamp    string   `xml:"TimeStamp"`
	Nonce        string   `xml:"Nonce"`
}

//NewWechatMsgCrypt 实例化微信加解密
func NewWechatMsgCrypt(token string, aesKey string, appid string) *msgCrypt {
	instance := new(msgCrypt)
	instance.token = token
	instance.aesKey = aesKey
	instance.appid = appid
	return instance
}

//WechatEventDecrypt 微信事件推送解密
func (w *msgCrypt) WechatEventDecrypt(eventRequest EventEncryptRequest, msgSignature string, timestamp, nonce string) interface{} {
	errCode, data := w.decryptMsg(msgSignature, timestamp, nonce, eventRequest.Encrypt)
	if errCode != SuccessCode {
		panic(fmt.Sprintf("消息解密失败，code：%d", errCode))
	}
	message := EventMessageBody{}
	_, err := FormatMessage(data, &message)
	if err != nil {
		panic(fmt.Sprintf("消息格式化失败，%s", err.Error()))
	}
	return message
}

//WechatMessageDecrypt 微信消息解密
func (w *msgCrypt) WechatMessageDecrypt(messageEncryptRequest MessageEncryptRequest) interface{} {
	errCode, data := w.decryptMsg(messageEncryptRequest.MsgSignature, messageEncryptRequest.TimeStamp, messageEncryptRequest.Nonce, messageEncryptRequest.Encrypt)
	if errCode != SuccessCode {
		panic(fmt.Sprintf("消息解密失败，code：%d", errCode))
	}
	message := MessageBodyDecrypt{}
	_, err := FormatMessage(data, &message)
	if err != nil {
		panic(fmt.Sprintf("消息格式化失败，%s", err.Error()))
	}
	return message
}

//WechatTextMessage 微信文本消息加密
func (w *msgCrypt) WechatTextMessage(fromUserName string, toUserName string, content string) MessageEncryptBody {
	message := FormatTextMessage(fromUserName, toUserName, content)
	encrypted, err := w.encryptMsg(message)
	if err != nil {
		panic("消息加密失败：" + err.Error())
	}
	data := FormatEncryptData(encrypted, w.token)
	return data
}

//WechatImageMessage 微信图片消息加密
func (w *msgCrypt) WechatImageMessage(fromUserName string, toUserName string, mediaId string) MessageEncryptBody {
	message := FormatImageMessage(fromUserName, toUserName, mediaId)
	encrypted, err := w.encryptMsg(message)
	if err != nil {
		panic("消息加密失败：" + err.Error())
	}
	data := FormatEncryptData(encrypted, w.token)
	return data
}

//WechatVoiceMessage 微信语音消息加密
func (w *msgCrypt) WechatVoiceMessage(fromUserName string, toUserName string, mediaId string) MessageEncryptBody {
	message := FormatVoiceMessage(fromUserName, toUserName, mediaId)
	encrypted, err := w.encryptMsg(message)
	if err != nil {
		panic("消息加密失败：" + err.Error())
	}
	data := FormatEncryptData(encrypted, w.token)
	return data
}

//WechatVideoMessage 微信视频消息加密
func (w *msgCrypt) WechatVideoMessage(fromUserName string, toUserName string, mediaId string, title string, description string) MessageEncryptBody {
	message := FormatVideoMessage(fromUserName, toUserName, mediaId, title, description)
	encrypted, err := w.encryptMsg(message)
	if err != nil {
		panic("消息加密失败：" + err.Error())
	}
	data := FormatEncryptData(encrypted, w.token)
	return data
}

//WechatMusicMessage 微信音乐消息加密
func (w *msgCrypt) WechatMusicMessage(fromUserName string, toUserName string, thumbMediaId string, title string, description string, musicUrl string, hQMusicUrl string) MessageEncryptBody {
	message := FormatMusicMessage(fromUserName, toUserName, thumbMediaId, title, description, musicUrl, hQMusicUrl)
	encrypted, err := w.encryptMsg(message)
	if err != nil {
		panic("消息加密失败：" + err.Error())
	}
	data := FormatEncryptData(encrypted, w.token)
	return data
}

//WechatArticlesMessage 微信图文消息加密
func (w *msgCrypt) WechatArticlesMessage(fromUserName string, toUserName string, items []ArticleItem) MessageEncryptBody {
	message := FormatArticlesMessage(fromUserName, toUserName, items)
	encrypted, err := w.encryptMsg(message)
	if err != nil {
		panic("消息加密失败：" + err.Error())
	}
	data := FormatEncryptData(encrypted, w.token)
	return data
}

//decryptMsg aes消息解密
func (w *msgCrypt) decryptMsg(msgSignature string, timestamp, nonce string, encrypted string) (int, []byte) {
	//验证aes
	if len(w.aesKey) != 43 {
		return IllegalAesKey, nil
	}
	//判断签名是否一致
	if err := w.validSignature(msgSignature, timestamp, nonce, encrypted); err != nil {
		return ValidateSignatureError, nil
	}
	//解密
	prp := NewPrpCrypt(w.aesKey)
	plainText, err := prp.decrypt(encrypted)
	if err != nil {
		return DecryptAESError, nil
	}
	//验证appid是否一致（消息来源是否一致）
	if err := w.validMessageSource(plainText); err != nil {
		return ValidateAppidError, nil
	}
	return SuccessCode, plainText
}

//encryptMsg aes消息加密
func (w *msgCrypt) encryptMsg(message []byte) (string, error) {
	//计算消息长度
	buf := new(bytes.Buffer)
	err := binary.Write(buf, binary.BigEndian, int32(len(message)))
	if err != nil {
		return "", err
	}
	messageLength := buf.Bytes()
	//生成随机字符串
	randBytes := []byte(makeRandomString(16))
	plainData := bytes.Join([][]byte{randBytes, messageLength, message, []byte(w.appid)}, nil)
	prp := NewPrpCrypt(w.aesKey)
	//消息加密
	encrypted, err := prp.encrypt(plainData)
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(encrypted), nil
}

//validSignature 验证签名是否一致
func (w *msgCrypt) validSignature(msgSignature string, timestamp, nonce string, encrypted string) error {
	validSignature := GetSignature(timestamp, nonce, encrypted, w.token)
	if validSignature != msgSignature {
		return errors.New("签名不一致：valid sign error")
	}
	return nil
}

//validMessageSource 验证消息来源
func (w *msgCrypt) validMessageSource(plainText []byte) error {
	messageLength := GetMessageLength(plainText)
	//获取appid位置
	appIdStartPos := 20 + messageLength
	id := plainText[appIdStartPos : int(appIdStartPos)+len(w.appid)]
	if string(id) != w.appid {
		return errors.New("消息来源不一致：Appid is invalid")
	}
	return nil
}
prpcrypt.go
package wechat

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"io"
)

type prpCrypt struct {
	Key []byte
	Iv  []byte
}

func NewPrpCrypt(aesKey string) *prpCrypt {
	instance := new(prpCrypt)
	//网络字节序
	instance.Key, _ = base64.StdEncoding.DecodeString(aesKey + "=")
	instance.Iv = randomIv()
	return instance
}

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

func (prp *prpCrypt) decrypt(encrypted string) ([]byte, error) {
	encryptedBytes, _ := base64.StdEncoding.DecodeString(encrypted)
	k := len(prp.Key) //PKCS#7
	if len(encryptedBytes)%k != 0 {
		panic("ciphertext size is not multiple of aes key length")
	}
	block, err := aes.NewCipher(prp.Key)
	if err != nil {
		return nil, err
	}
	blockMode := cipher.NewCBCDecrypter(block, prp.Iv)
	plainText := make([]byte, len(encryptedBytes))
	blockMode.CryptBlocks(plainText, encryptedBytes)
	return plainText, nil
}

func (prp *prpCrypt) encrypt(plainText []byte) ([]byte, error) {
	k := len(prp.Key)
	if len(plainText)%k != 0 {
		plainText = pKCS7Pad(plainText, k)
	}
	block, err := aes.NewCipher(prp.Key)
	if err != nil {
		return nil, err
	}
	cipherData := make([]byte, len(plainText))
	blockMode := cipher.NewCBCEncrypter(block, prp.Iv)
	blockMode.CryptBlocks(cipherData, plainText)
	return cipherData, nil
}
helpers.go（工具）
package wechat

import (
	"bytes"
	"crypto/sha1"
	"fmt"
	"io"
	"math/rand"
	"sort"
	"strings"
)

//GetSignature 获取签名
func GetSignature(timestamp, nonce string, encrypted string, token string) string {
	data := []string{
		encrypted,
		token,
		timestamp,
		nonce,
	}
	sort.Strings(data)
	s := sha1.New()
	_, err := io.WriteString(s, strings.Join(data, ""))
	if err != nil {
		panic("签名错误：sign error")
	}
	return fmt.Sprintf("%x", s.Sum(nil))
}

func makeRandomString(length int) string {
	randStr := ""
	strSource := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyl"
	maxLength := len(strSource) - 1
	for i := 0; i < length; i++ {
		randomNum := rand.Intn(maxLength)
		randStr += strSource[randomNum : randomNum+1]
	}
	return randStr
}

func pKCS7Pad(plainText []byte, blockSize int) []byte {
	// block size must be bigger or equal 2
	if blockSize < 1<<1 {
		panic("block size is too small (minimum is 2 bytes)")
	}
	// block size up to 255 requires 1 byte padding
	if blockSize < 1<<8 {
		// calculate padding length
		padLen := padLength(len(plainText), blockSize)

		// define PKCS7 padding block
		padding := bytes.Repeat([]byte{byte(padLen)}, padLen)

		// apply padding
		padded := append(plainText, padding...)
		return padded
	}
	// block size bigger or equal 256 is not currently supported
	panic("unsupported block size")
}

func padLength(sliceLength, blockSize int) int {
	padLen := blockSize - sliceLength%blockSize
	if padLen == 0 {
		padLen = blockSize
	}
	return padLen
}

最后加一个demo运行

instance := wechat.NewWechatMsgCrypt("token", "aesKey", "appid")
data := instance.WechatTextMessage("示例内容", "示例内容2", "你好")
fmt.Println("加密结果：", data)
bytes, _ := xml.Marshal(data)
xmlData := wechat.MessageEncryptRequest{}
_ = xml.Unmarshal(bytes, &xmlData)
fmt.Println("解析结果：", xmlData)
fmt.Println("解密结果：", instance.WechatMessageDecrypt(xmlData))

总结

思路还是挺清晰的，大概就这样，没啥特别，这样用起来清晰点，应该不难看懂，有问题再提出来，不想一搜全是那些，看着头疼，这样我还怎么面向百度编程。

go语言消息推送服务器,Golang 消息推送系统
weixin_31560545的博客
07-31 1466
## Golang 消息推送系统- 使用 websocket 协议，实现全局推送，和分房间推送,实现用户加入房间，退出房间- gateway 长连接网关服务器，管理全部的链接，以及房间等相关操作- logic 逻辑服务器 管理发送全局推送，单个房间推送，加入房间，离开房间等相关操作- 代码目录详情```bash├── gateway // 长连接网关服务器│ ├── push_job.go ...
微信小游戏推送（小游戏礼包功能）服务器端接入开发经验总结
热门推荐
网易搬砖头
06-13 3万+
小游戏开发者的游戏内道具，可通过接入平台「礼包系统」，在微信平台各场景发放游戏礼包。发放场景包括：游戏圈、活动运营工具、发现-游戏-福利中心、广告、搜索等道具礼包发货基于微信小游戏统一的消息推送能力，因此在使用礼包中心的发货回调时，需要开发者服务器处理好消息推送的协议。注意：MP配置消息回调地址只有1个，所有消息推送场景都会使用该通道，所以需要先根据MsgType与Event来判断消息类型，进行相应的处理。下面是发送和返回的格式：更多详情可以查看文档：小游戏礼包 | 微信开放文档。
wechat-crypter:微信开放平台加解密库 (Golang)
06-16
wechat-crypter 微信开放平台加解密库 (Golang) Usage $ go get github.com/heroicyang/wechat-crypter import "github.com/heroicyang/wechat-crypter" token := "RMNlACHlV5ThzfRlVS4D4" corpID := "wx5823bf96d3bd56c7" encodingAESKey := "jWmYm7qr5nMoAUwZRjGtBxmz3KA1tkAj3ykkR6q2B2C" msgCrypter, _ := crypter.NewMessageCrypter(token, encodingAESKey, corpID) msgDecrypt, corpID, err := msgCrypter.Decrypt("msgEncrypt") Doc
微信消息加解密（GoLang）-- 接收和回复加密消息
weixin_30924087的博客
01-18 1365
接收微信消息的接口内容： //"r"为*http.Request r.ParseForm() timestamp := strings.Join(r.Form["timestamp"], "") nonce := strings.Join(r.Form["nonce"], "") signature := strings.Join(r.Form["sign...
Golang SSE 服务器端推送事件
最新发布
qq_19954983的博客
02-13 223
本应该在EventStream的怎么都在响应这里出现后面通过查找问题知道EventSreamdata: [返回的内容]\n\n返回success字符串SSE（Server-Sent Event）是一种用于客户端与服务器端实时通讯的技术。它允许服务器端发送事件到客户端，客户端可以通过 EventSource 接口来接收这些事件。通常情况下，SSE 是基于 HTTP 协议实现的，它不需要建立和维护长连接，但服务器可以长时间向客户端推送数据，而客户端只需要等待并处理收到的数据即可。
golang实现微信模板消息推送
LH7777的博客
07-03 6011
Golang实现发送微信模板消息（每日一句和天气预报）前言运行环境获取接口数据1、每日一句接口2、获取天气预报接口二、微信公众平台接口测试帐号1、每日一句模板2、天气预报模板三、发送微信模板消息的程序四、设置定时发送 前言 本文是基于https://www.cnblogs.com/connect/p/python-wechat-iciba.html 这篇博客写成的。该博客实现了用python将金山词霸的每日一句推送到微信公众测试号，我想既然python能实现，那么用Golang也可以。 运行环境 1、阿里云
Go最全Golang：使用 FCM 实现推送通知_golang fcm，2024年最新2024最新Golang面试题目
2401_84923269的博客
05-12 513
注意：应用端使用的 firebase 配置文件（android 为 google_services.json 文件，iOS 为 GoogleService-Info.plist）和 service_account 密钥必须从 firebase 控制台为同一个项目创建。在这里，FIREBASE_AUTH_KEY 包含一个 base64 编码的服务帐户密钥。在本文中，我们将探讨如何使用 Golang 和 Firebase 发送推送通知。上述方法将返回解码后的服务帐户密钥，该密钥将在下一步中使用。
企业微信加密消息体_加解密方案说明
weixin_32236881的博客
01-17 4134
[TOC]概述企业微信在推送消息给企业时，会对消息内容做AES加密，以XML格式POST到企业应用的URL上。企业在被动响应时，也需要对数据加密，以XML格式返回给企业微信。本章节即是对加解密方法的说明。阅读本章节前，需要了解以下术语：msg_signature： 消息签名，用于验证请求是否来自企业微信(防止攻击者伪造)。EncodingAESKey：用于消息体的加密，长度固定为43个字符，从a-...
基于golang的微信机器人.zip
05-08
3. **数据接收**：微信机器人实时监听微信服务器的消息推送，通过Websocket或者长轮询技术，接收包括文字、图片、语音、视频等各种类型的消息。 4. **发送文本内容**：机器人可以接收命令或消息，然后向指定的联系...
Go语言实现企业微信自定义消息回复教程
为了处理来自企业微信的事件或消息，你需要设置一个回调URL，企业微信会将消息推送至此URL。`github.com/xen0n/go-workwx`库提供了一个回调函数的示例，展示了如何解析和响应这些事件。 6. 学习资料： 提供的链接...
企业微信回调验证、消息交互、审批状态回调及审批查询
yzhbyssgdbd123的博客
08-02 1万+
审批接口调用总是伴随着状态回调的通知，设置接收消息，可以让自建应用和企业微信之间进行双向通信。 当然在此之前，我们需要确定，企业微信后台是否开启了审批状态通知。 一. 企业微信回调验证 二. 企业微信消息交互（重要） 三. 审批状态回调 四. 查询审批状态 注意： 想要成功接收到企业微信回调的信息 ，解密Encrypt，得到明文的消息结构体尤为重要，当然解密后得...
Go-gorush-一个Go(Golang)的推送通知服务器
08-14
gorush - 一个Go (Golang)的推送通知服务器使用APNs2和google GCM实现
Go-msgserver-消息推送服务端golang实现
08-14
一种基于socket的消息推送服务端，服务端保持与客户端tcp长连接，实现消息的推送或提醒。
微信小程序加密数据解密算法Go版
08-10
微信小程序加密数据解密算法Go版
Go-wechatpusherGo实现的微信模板消息推送服务
08-13
wechat_pusher：Go 实现的微信模板消息推送服务
Go语言高并发实战：构建千万级在线的实时消息推送服务
05-28
Go语言高并发实战：构建千万级在线的实时消息推送服务
Golang 搭建 WebSocket 应用（五） - 消息推送日志
rubys007的博客
01-19 1295
本人文章可能文字会比较多，但是其中都是个人在此过程中的一些思考，相比直接告诉大家怎么做，有可能知道为什么这么做更重要。消息推送这个功能，技术上其实我们已经实现了，但是我们还得考虑很多非功能性的需求，这些非功能性的需求决定了我们的架构。依赖倒置原则可以指导我们设计出具有扩展性的代码：本文中的日志记录抽象出了一个，需要的时候我们可以自行实现然后替换掉框架提供的实现。错误处理：为了方便后续维护，处理处理我们也是抽象出了一个func类型，实现了关注点的分离，也在一定程度上给后续的扩展提供了可能。
Golang 搭建 WebSocket 应用（三） - 实现一个消息推送中心
rubys007的博客
01-18 2256
有了前两篇的铺垫，相信大家已经对 Golang 中WebSocket的使用有一定的了解了，今天我们以一个更加真实的例子来学习如何在 Golang 中使用WebSocket。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值