色总的微信小程序开发记录（三）--消息推送
微信小程序开发记录（三）--消息推送
- 消息推送--开发者服务器接收消息推送
- 填写服务器配置
- 验证服务器地址的有效性
- Controller 微信小程序消息验证和配置
- ServiceImpl 逻辑实现
- 接收消息和事件，实现业务逻辑
- Controller 微信小程序客服消息自动回复
- ServiceImpl 逻辑实现
前面通过code到微信服务器换取到了微信用户身份openid，将微信和已存在的平台账号关联起来。关联起来后，就可以做自己想做的操作了。但有时候需要小程序自动回复客户的问题，也就是微信的消息推送功能了。这里针对开发者服务器接收消息推送讲一讲，云函数接收消息推送就不多说了，自己去微信公众平台看API。
消息推送–开发者服务器接收消息推送
开发者需要按照如下步骤完成：
- 填写服务器配置
- 验证服务器地址的有效性
- 接收消息和事件，实现业务逻辑
填写服务器配置
登录小程序后台后，在「开发」-「开发设置」-「消息推送」中，管理员扫码启用消息服务，填写服务器地址（URL）、令牌（Token） 和 消息加密密钥（EncodingAESKey）等信息。
- URL: 开发者用来接收微信消息和事件的接口 URL。开发者所填写的URL 必须以 http:// 或 https:// 开头，分别支持80 端口和 443 端口。
- Token: 可由开发者可以任意填写，用作生成签名（该 Token 会和接口 URL 中包含的 Token 进行比对，从而验证安全性）。
- EncodingAESKey: 由开发者手动填写或随机生成，将用作消息体加解密密钥。
同时，开发者可选择消息加解密方式：明文模式（默认）、兼容模式和安全模式。可以选择消息数据格式：XML 格式（默认）或 JSON 格式。
验证服务器地址的有效性
开发者点击提交按钮，模式的选择与服务器配置在提交成功后都会立即生效。但是怎么提交成功呢？？直接点提交就行了吗？并不是这样的，微信会验证开发者填写的URL是否正确，正确才能提交成功，保存设置。
微信服务器会发送一个GET请求到填写的服务器地址URL，就是上面填写的URL。这个请求就是用来验证开发者填写的URL是否正确的，如果不正确就无法提交成功。注意这个请求只和URL和Token有关。而EncodingAESKey和加密方式、数据格式是为后面服务器用来将加密后的原文进行解密准备的。
微信服务器将发送GET请求到填写的服务器地址URL上，GET请求携带参数如下表所示：
| 参数 | 描述 |
|---|---|
| signature | 微信加密签名，signature结合了开发者填写的token参数和请求中的timestamp参数、nonce参数。 |
| timestamp | 时间戳 |
| nonce | 随机数 |
| echostr | 随机字符串 |
实质上是微信对开发者填写的服务器地址URL发出GET请求，这个get请求带有四个参数，signature 是由微信结合开发者填写的Token、还有同时传过来的timestamp参数、nonce参数加密生成的一个字符串。开发者在填写的URL接口的逻辑中将自己填写的Token、还有接收到的timestamp参数、nonce参数这三个参数进行加密，加密后获取的字符串与signature 对比，一样的话就返回传过来的echostr参数，表示接入成功，否则返回空或其他，表示接入失败。微信接收到返回值，如果是echostr参数，那么就可以提交成功，保存消息推送配置。如果不是，则在Token（令牌）一行会显示“Token校验失败，请检查确认”。
加密/校验流程如下（来自微信公众平台API）：
- 将token、timestamp、nonce三个参数进行字典序排序
- 将三个参数字符串拼接成一个字符串进行sha1加密
- 开发者获得加密后的字符串可与signature对比，若校验成功则原样返回echostr，表示接入成功，否则接入失败
Controller 微信小程序消息验证和配置
/**
* 开放接口--微信小程序消息验证和配置
* @return
*/
@ResponseBody
@ApiOperation(value="微信小程序消息验证和配置", response = SimpleMessage.class)
@RequestMapping(value = "/message" ,method = RequestMethod.GET)
public String getProcess(HttpServletRequest request, HttpServletResponse response) {
return weChatCustomerService.getProcess(request,response);
}
ServiceImpl 逻辑实现
import java.security.MessageDigest;
/**
* 微信小程序消息验证和配置
* @param request
* @param response
* @return
*/
@Override
public String getProcess(HttpServletRequest request, HttpServletResponse response) {
// 微信加密签名
String signature = request.getParameter("signature");
// 时间戳
String timestamp = request.getParameter("timestamp");
// 随机数
String nonce = request.getParameter("nonce");
// 随机字符串
String echostr = request.getParameter("echostr");
// 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
if (this.checkSignature(signature, timestamp, nonce)) {
return echostr;
}
return null;
}
/**
* 工具--通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
* @param signature
* @param timestamp
* @param nonce
* @return
*/
private boolean checkSignature(String signature, String timestamp, String nonce) {
String[] arr = new String[] { messageToken, timestamp, nonce };//messageToken为常值，就是开发者自己填写的Token（令牌）
// 将token、timestamp、nonce三个参数进行字典序排序
Arrays.sort(arr);
StringBuilder content = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
content.append(arr[i]);
}
MessageDigest md = null;
String tmpStr = null;
try {
md = MessageDigest.getInstance("SHA-1");
// 将三个参数字符串拼接成一个字符串进行sha1加密
byte[] digest = md.digest(content.toString().getBytes());
tmpStr = byteToStr(digest);
} catch (Exception e) {
e.printStackTrace();
}
content = null;
// 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
return tmpStr != null ? tmpStr.equals(signature.toUpperCase()) : false;
}
/**
* 工具--将字节数组转换为十六进制字符串
* @author 13
* @param byteArray
* @return
*/
private static String byteToStr(byte[] byteArray) {
String strDigest = "";
for (int i = 0; i < byteArray.length; i++) {
strDigest += byteToHexStr(byteArray[i]);
}
return strDigest;
}
/**
* 工具--将字节转换为十六进制字符串
* @author 13
* @param mByte
* @return
*/
private static String byteToHexStr(byte mByte) {
char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
'B', 'C', 'D', 'E', 'F' };
char[] tempArr = new char[2];
tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
tempArr[1] = Digit[mByte & 0X0F];
String s = new String(tempArr);
return s;
}
接收消息和事件，实现业务逻辑
当验证服务器地址的有效性后，提交消息推送配置即成功。之后只要当用户操作引发事件推送时（如用户向小程序客服发送消息、或者进入会话等情况），微信服务器会将消息（或事件）的数据包以 POST 请求发送到开发者配置的 URL，开发者可以依据自身业务逻辑进行响应。这里请求的还是之前开发者配置的URL，只是由GET请求变成了POST请求。
微信服务器在将用户的消息发给开发者服务器地址后，微信服务器在五秒内收不到响应会断掉连接，并且重新发起请求，总共重试三次。如果在调试中，发现用户无法收到响应的消息，可以检查是否消息处理超时。这里的重试三次，可能造成开发者服务器连续接到多次的相同请求，所以还需要进行消息的排重。关于重试的消息排重，有 msgid 的消息推荐使用 msgid 排重。事件类型消息推荐使用 FromUserName + CreateTime 排重。
服务器收到请求必须做出下述回复，这样微信服务器才不会对此作任何处理，并且不会发起重试，否则，将出现严重的错误提示。详见下面说明：
- 直接回复success（推荐方式）
- 直接回复空串（指字节长度为0的空字符串，而不是结构体中content字段的内容为空）
- 若接口文档有指定返回内容，应按文档说明返回
对于客服消息，一旦遇到以下情况，微信会在小程序会话中向用户下发系统提示“该小程序客服暂时无法提供服务，请稍后再试”：
- 开发者在5秒内未回复任何内容
- 开发者回复了异常数据
如果开发者希望增强安全性，可以在开发者中心处开启消息加密，这样，用户发给小程序的消息以及小程序被动回复用户消息都会继续加密。
看下图就知道我们选择了进行消息加密，安全模式，数据格式为xml。所以在验证服务器地址的有效性时，GET请求只和URL和Token有关。而EncodingAESKey和消息加密方式、数据格式都是为这时开发者服务器用来接收POST请求准备的。
后面的代码很多，主要的是接受微信转过来的用户消息，将用户加密的信息进行解密，得到真实的消息，然后根据消息进行开发者自己的逻辑处理，我这里是根据用户的消息，自动回复图片。自动回复字符串很简单，只需要写在代码里，但是回复图片就不行了，微信要求先上传到微信，得到一个图片id，把id存在数据库中，要回复哪个图片就向要回复的消息模板里添加哪个图片的id。
Controller 微信小程序客服消息自动回复
/**
* 开放接口--微信小程序客服消息自动回复
* @return
*/
@ResponseBody
@ApiOperation(value="微信小程序客服消息自动回复", response = SimpleMessage.class)
@RequestMapping(value = "/message", method = RequestMethod.POST)
public String replyMessage(@RequestBody String encrypt_msg , HttpServletRequest request, HttpServletResponse response) throws Exception {
return weChatCustomerService.replyMessage(encrypt_msg,request,response);
}
ServiceImpl 逻辑实现
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import com.alibaba.fastjson.JSONObject;
/**
* 小程序平台填写的43位EncodingAESKey
*/
@Value("${spring.wx.encodingAesKey}")
private String EncodingAESKey;
/**
* 小程序平台消息推送填写的Token(令牌)
*/
@Value("${spring.wx.messageToken}")
private String messageToken;
/**
* 小程序发送客服消息给用户请求地址--https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=
*/
@Value("${spring.wx.customerServiceSend}")
private String customerServiceSend;
@Autowired
private WeChatUtil weChatUtil;
private static final String[] keyWord = {"1", "2", "3"};
private static final String[] keyWordContent = {"你好，这是1", "你好，这是2", "你好，这是3"};
private static final List<String> keyList = Arrays.asList(keyWord);
/**
* 微信小程序客服消息自动回复
* @param encrypt_msg 加密后的原文
* @param request
* @param response
* @return
* @throws Exception
*/
@Override
public String replyMessage(String encrypt_msg, HttpServletRequest request, HttpServletResponse response) throws Exception {
//将加密后的原文进行解密重新封装
String d=decryptMsg(request,encrypt_msg);
Map<String, String> msg = new HashMap<>(6);
//将解密后的xml消息转为Map
Document doc = DocumentHelper.parseText(d);
Element root = doc.getRootElement();
List<Element> list = root.elements();
for (Element e : list) {
msg.put(e.getName(), e.getText());
}
//获取消息排重结果
Boolean r=weChatUtil.getDuplicateMessage(msg);
if(r){
return "SUCCESS";
}
logger.info("客服消息自动回复-----------------start");
logger.info("客服消息自动回复msg-----------------{}",msg);
String openId = msg.get("FromUserName");
Map<String, String> contentMap = new HashMap<String, String>();
//发送结果
String result = "";
String content = msg.get("Content") == null ? "" : msg.get("Content");
//判断文字中是否包含关键词，若包含则提前自动回复
boolean flag = false;
int keyWord = 0;
for (String string : keyList) {
if (content.equals(string)) {
flag = true;
keyWord=Integer.parseInt(string);
break;
}
}
//若用户消息包含关键字则自动回复
if (flag) {
//关键字对应内容
String text=keyWordContent[keyWord-1];
//若没有关键字对应内容则不进行操作
if (StringUtils.isBlank(mediaId)) {
// 此处将消息转发至人工客服，不然人工客服窗会没有消息
Map<String, Object> tranMap = new HashMap<String, Object>();
tranMap.put("ToUserName", msg.get("FromUserName"));
tranMap.put("FromUserName", msg.get("ToUserName"));
tranMap.put("CreateTime", msg.get("CreateTime"));
tranMap.put("MsgType", "transfer_customer_service");
String messageJson = JSONObject.toJSONString(tranMap);
logger.info("消息转发至人工客服-----------------");
return messageJson;
}
contentMap.put("content", text);
result = sendMessage(openId, "text", contentMap);
}
//若用户消息没有包含关键字则自动回复操作提示
if (!flag) {
String text="回复1获取公众号二维码进行关注\n回复2获取Android二维码进行下载\n回复3获取ios二维码进行下载";
contentMap.put("content", text);
result = sendMessage(openId, "text", contentMap);
//此处将消息转发至人工客服，不然人工客服窗会没有消息
Map<String, Object> tranMap = new HashMap<String, Object>();
tranMap.put("ToUserName", msg.get("FromUserName"));
tranMap.put("FromUserName", msg.get("ToUserName"));
tranMap.put("CreateTime", msg.get("CreateTime"));
tranMap.put("MsgType", "transfer_customer_service");
String messageJson = JSONObject.toJSONString(tranMap);
logger.info("消息转发至人工客服-----------------");
return messageJson;
}
logger.info("客服自动回复结果-----------------{}",result);
return "SUCCESS";
}
/**
* 工具--将加密后的原文进行解密重新封装
* @param request
* @param originalXml 原xml
* @return 重新解密后的xml
*/
private String decryptMsg(HttpServletRequest request, String originalXml) {
// 微信加密签名
String msgSignature = request.getParameter("msg_signature");
// 时间戳
String timestamp = request.getParameter("timestamp");
// 随机数
String nonce = request.getParameter("nonce");
try {
WXBizMsgCrypt pc = new WXBizMsgCrypt(messageToken, EncodingAESKey,AppId);
//检验消息的真实性，并且获取解密后的明文
return pc.decryptMsg(msgSignature, timestamp, nonce, originalXml);
} catch (AesException e) {
e.printStackTrace();
}
return null;
}
/**
* 工具--客服消息自动回复
* @param opendId
* @param msgtype
* @param contentMap
* @return
* @throws UnsupportedEncodingException
*/
private String sendMessage(String opendId, String msgtype, Map<String, String> contentMap) throws Exception {
Map<String, Object> replyMessageMap = new HashMap<String, Object>();
replyMessageMap.put("touser", opendId);
replyMessageMap.put("msgtype", msgtype);
replyMessageMap.put(msgtype, contentMap);
String messageJson = JSONObject.toJSONString(replyMessageMap);
messageJson = new String(messageJson.getBytes(), "UTF-8");
// weChatUtil.getToken()是去获取小程序全局唯一后台接口调用凭据access_token，如果本地redis有就拿，没有就请求微信重新获取，具体如何获取可以看我微信小程序开发日记的第二篇
String url = customerServiceSend + weChatUtil.getToken();
// 发送结果
JSONObject obj= ConnectUtil.HttpPostWithJson(url, messageJson);
String messageObj = JSONObject.toJSONString(obj);
return messageObj;
}
色总的微信小程序开发记录（二）–获取access_token
消息加解密 WXBizMsgCrypt 这个当时我也是在网上找的，也不知道是谁写的，感谢作者分享。
/**
* 对公众平台发送给公众账号的消息加解密示例代码.
*
* @copyright Copyright (c) 1998-2014 Tencent Inc.
*/
// ------------------------------------------------------------------------
/**
* 针对org.apache.commons.codec.binary.Base64，
* 需要导入架包commons-codec-1.9（或commons-codec-1.8等其他版本）
* 官方下载地址：http://commons.apache.org/proper/commons-codec/download_codec.cgi
*/
package com.hanboard.educloud.utils.WeChatDecryptUtil;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Random;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
/**
* 提供接收和推送给公众平台消息的加解密接口(UTF8编码的字符串).
*
* - 第三方回复加密消息给公众平台
* - 第三方收到公众平台发送的消息，验证消息的安全性，并对消息进行解密。
*
* 说明：异常java.security.InvalidKeyException:illegal Key Size的解决方案
*
* - 在官方网站下载JCE无限制权限策略文件（JDK7的下载地址：
* http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html
* - 下载后解压，可以看到local_policy.jar和US_export_policy.jar以及readme.txt
* - 如果安装了JRE，将两个jar文件放到%JRE_HOME%\lib\security目录下覆盖原来的文件
* - 如果安装了JDK，将两个jar文件放到%JDK_HOME%\jre\lib\security目录下覆盖原来文件
*
*/
public class WXBizMsgCrypt {
static Charset CHARSET = Charset.forName("utf-8");
Base64 base64 = new Base64();
byte[] aesKey;
String token;
String appId;
/**
* 构造函数
* @param token 公众平台上，开发者设置的token
* @param encodingAesKey 公众平台上，开发者设置的EncodingAESKey
* @param appId 公众平台appid
*
* @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
*/
public WXBizMsgCrypt(String token, String encodingAesKey, String appId) throws AesException {
if (encodingAesKey.length() != 43) {
throw new AesException(AesException.IllegalAesKey);
}
this.token = token;
this.appId = appId;
aesKey = Base64.decodeBase64(encodingAesKey + "=");
}
// 生成4个字节的网络字节序
byte[] getNetworkBytesOrder(int sourceNumber) {
byte[] orderBytes = new byte[4];
orderBytes[3] = (byte) (sourceNumber & 0xFF);
orderBytes[2] = (byte) (sourceNumber >> 8 & 0xFF);
orderBytes[1] = (byte) (sourceNumber >> 16 & 0xFF);
orderBytes[0] = (byte) (sourceNumber >> 24 & 0xFF);
return orderBytes;
}
// 还原4个字节的网络字节序
int recoverNetworkBytesOrder(byte[] orderBytes) {
int sourceNumber = 0;
for (int i = 0; i < 4; i++) {
sourceNumber <<= 8;
sourceNumber |= orderBytes[i] & 0xff;
}
return sourceNumber;
}
// 随机生成16位字符串
String getRandomStr() {
String base = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 16; i++) {
int number = random.nextInt(base.length());
sb.append(base.charAt(number));
}
return sb.toString();
}
/**
* 对明文进行加密.
*
* @param text 需要加密的明文
* @return 加密后base64编码的字符串
* @throws AesException aes加密失败
*/
String encrypt(String randomStr, String text) throws AesException {
ByteGroup byteCollector = new ByteGroup();
byte[] randomStrBytes = randomStr.getBytes(CHARSET);
byte[] textBytes = text.getBytes(CHARSET);
byte[] networkBytesOrder = getNetworkBytesOrder(textBytes.length);
byte[] appidBytes = appId.getBytes(CHARSET);
// randomStr + networkBytesOrder + text + appid
byteCollector.addBytes(randomStrBytes);
byteCollector.addBytes(networkBytesOrder);
byteCollector.addBytes(textBytes);
byteCollector.addBytes(appidBytes);
// ... + pad: 使用自定义的填充方式对明文进行补位填充
byte[] padBytes = PKCS7Encoder.encode(byteCollector.size());
byteCollector.addBytes(padBytes);
// 获得最终的字节流, 未加密
byte[] unencrypted = byteCollector.toBytes();
try {
// 设置加密模式为AES的CBC模式
Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES");
IvParameterSpec iv = new IvParameterSpec(aesKey, 0, 16);
cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
// 加密
byte[] encrypted = cipher.doFinal(unencrypted);
// 使用BASE64对加密后的字符串进行编码
String base64Encrypted = base64.encodeToString(encrypted);
return base64Encrypted;
} catch (Exception e) {
e.printStackTrace();
throw new AesException(AesException.EncryptAESError);
}
}
/**
* 对密文进行解密.
*
* @param text 需要解密的密文
* @return 解密得到的明文
* @throws AesException aes解密失败
*/
String decrypt(String text) throws AesException {
byte[] original;
try {
// 设置解密模式为AES的CBC模式
Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
SecretKeySpec key_spec = new SecretKeySpec(aesKey, "AES");
IvParameterSpec iv = new IvParameterSpec(Arrays.copyOfRange(aesKey, 0, 16));
cipher.init(Cipher.DECRYPT_MODE, key_spec, iv);
// 使用BASE64对密文进行解码
byte[] encrypted = Base64.decodeBase64(text);
// 解密
original = cipher.doFinal(encrypted);
} catch (Exception e) {
e.printStackTrace();
throw new AesException(AesException.DecryptAESError);
}
String xmlContent, from_appid;
try {
// 去除补位字符
byte[] bytes = PKCS7Encoder.decode(original);
// 分离16位随机字符串,网络字节序和AppId
byte[] networkOrder = Arrays.copyOfRange(bytes, 16, 20);
int xmlLength = recoverNetworkBytesOrder(networkOrder);
xmlContent = new String(Arrays.copyOfRange(bytes, 20, 20 + xmlLength), CHARSET);
from_appid = new String(Arrays.copyOfRange(bytes, 20 + xmlLength, bytes.length),
CHARSET);
} catch (Exception e) {
e.printStackTrace();
throw new AesException(AesException.IllegalBuffer);
}
// appid不相同的情况
if (!from_appid.equals(appId)) {
throw new AesException(AesException.ValidateAppidError);
}
return xmlContent;
}
/**
* 将公众平台回复用户的消息加密打包.
*
* - 对要发送的消息进行AES-CBC加密
* - 生成安全签名
* - 将消息密文和安全签名打包成xml格式
*
*
* @param replyMsg 公众平台待回复用户的消息，xml格式的字符串
* @param timeStamp 时间戳，可以自己生成，也可以用URL参数的timestamp
* @param nonce 随机串，可以自己生成，也可以用URL参数的nonce
*
* @return 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串
* @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
*/
public String encryptMsg(String replyMsg, String timeStamp, String nonce) throws AesException {
// 加密
String encrypt = encrypt(getRandomStr(), replyMsg);
// 生成安全签名
if (timeStamp == "") {
timeStamp = Long.toString(System.currentTimeMillis());
}
String signature = SHA1.getSHA1(token, timeStamp, nonce, encrypt);
// System.out.println("发送给平台的签名是: " + signature[1].toString());
// 生成发送的xml
String result = XMLParse.generate(encrypt, signature, timeStamp, nonce);
return result;
}
/**
* 检验消息的真实性，并且获取解密后的明文.
*
* - 利用收到的密文生成安全签名，进行签名验证
* - 若验证通过，则提取xml中的加密消息
* - 对消息进行解密
*
*
* @param msgSignature 签名串，对应URL参数的msg_signature
* @param timeStamp 时间戳，对应URL参数的timestamp
* @param nonce 随机串，对应URL参数的nonce
* @param postData 密文，对应POST请求的数据
*
* @return 解密后的原文
* @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
*/
public String decryptMsg(String msgSignature, String timeStamp, String nonce, String postData)
throws AesException {
// 密钥，公众账号的app secret
// 提取密文
Object[] encrypt = XMLParse.extract(postData);
// 验证安全签名
String signature = SHA1.getSHA1(token, timeStamp, nonce, encrypt[1].toString());
// 和URL中的签名比较是否相等
// System.out.println("第三方收到URL中的签名：" + msg_sign);
// System.out.println("第三方校验签名：" + signature);
if (!signature.equals(msgSignature)) {
throw new AesException(AesException.ValidateSignatureError);
}
// 解密
String result = decrypt(encrypt[1].toString());
return result;
}
/**
* 验证URL
* @param msgSignature 签名串，对应URL参数的msg_signature
* @param timeStamp 时间戳，对应URL参数的timestamp
* @param nonce 随机串，对应URL参数的nonce
* @param echoStr 随机串，对应URL参数的echostr
*
* @return 解密之后的echostr
* @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
*/
public String verifyUrl(String msgSignature, String timeStamp, String nonce, String echoStr)
throws AesException {
String signature = SHA1.getSHA1(token, timeStamp, nonce, echoStr);
if (!signature.equals(msgSignature)) {
throw new AesException(AesException.ValidateSignatureError);
}
String result = decrypt(echoStr);
return result;
}
}
获取消息排重结果 weChatUtil 这里用的是redis进行记录
@Value("${spring.wx.redisFolderName}")
private String redisFolderName;//自己随便编一个用于redis命名
/**
* redis Token分层文件夹名称
*/
private static final String weChatAccessToken="weChat_access_token";
/**
* redis 消息排重分层文件夹名称
*/
private static final String duplicateMessage="duplicate_message:";
@Autowired
private RedisTemplate redisTemplate;
/**
* 方法--获取消息排重结果
* @param msg
* @return
*/
public Boolean getDuplicateMessage(Map<String, String> msg){
String FromUserName=msg.get("FromUserName");
String CreateTime=msg.get("CreateTime");
String MsgId=msg.get("MsgId");
String value=FromUserName+CreateTime;
//获取duplicateMessage,进行消息排重
Boolean hasKey=redisTemplate.hasKey(redisFolderName+duplicateMessage+MsgId);
if(hasKey){
//有参数
String value1=(String)redisTemplate.opsForValue().get(redisFolderName+duplicateMessage+MsgId);
if(value1.equals(value)){
return true;
}
return false;
}else {
//redis新增duplicateMessage
redisTemplate.opsForValue().set(redisFolderName+duplicateMessage+MsgId, value, 20, TimeUnit.SECONDS);
return false;
}
}