画板

实现思路

  1. 第一步：我们要先到微信开发者后台管理系统维护回调地址。主要作用：当用户对公众号做操作时，微信服务器会把相应的事件和参数回调至我们内部定制的接口，我们可以真对微信回调的时间和参数进行定制操作。详细可参考官网。
  2. 第二步：真对回调的项目地址，开发对应的服务。回调同一个地址分为GET和POST两个不同请求。
  • GET请求处理，配置微信回调地址时的，对微信服务的请求认证。
  • POST请求处理，认证成功后，后续微信服务器对于所有的事件和参数的回调都是POST请求
  1. @RestController
  2. public class WeChatController {
  3.     @Resource
  4.     private IWeChatService weChatService;
  6.     /**
  7.      * 微信公众号回调地址验证
  8.      */
  9.     @ApiOperation(value = "微信公众号回调地址验证", httpMethod = "GET")
  10.     @GetMapping("/callback")
  11.     public String callback(String signature, String timestamp, String nonce, String echostr) {
  12.         log.info("signature:[{}]，timestamp:[{}]，nonce:[{}]，echostr:[{}]", signature, timestamp, nonce, echostr);
  13.         // 验证请求是否来自微信服务器
  14.         if (!SignatureUtil.checkSignature(signature, timestamp, nonce, projectApp.getWxServerToken())) {
  15.             return null;
  16.         }
  17.         return echostr;
  18.     }
  20.     @ApiOperation(value = "公众号事件触发回调地址", httpMethod = "POST")
  21.     @PostMapping("/callback")
  22.     public String callback(HttpServletRequest request, HttpServletResponse response) throws Exception {
  23.         // 处理微信服务器发来的消息
  24.         Map<String, String> map = XmlParserUtil.parseXml(request.getInputStream());
  25.         log.info("WeChatController callback res:[{}]", JSON.toJSONString(map));
  26.         //监听微信请求的事件类型，做出对应处理
  27.         String result = weChatService.handleEvent(projectApp, map);
  28.         //处理响应乱码问题
  29.         response.setHeader("Content-type", "text/html;charset=UTF-8");
  30.         response.setCharacterEncoding("UTF-8");
  31.         return result;
  32.     }
  34. }
  36. //Service层方法
  37. @Transactional(rollbackFor = Exception.class)
  38. @Override
  39. public void handleEvent(ProjectApp projectApp, Map<String, String> map) {
  40.     //公众号消息类型
  41.     String msgType = map.get("MsgType");
  42.     //推送事件类型
  43.     String event = map.get("Event");
  44.     String openId = map.get("FromUserName");
  45.     //扫码关注，传入的参数
  46.     String eventKey = map.get("EventKey");
  47.     return "success";
  48. }
  1. public class XmlParserUtil {
  3.     /**
  4.      * xml字符串解析为Map
  5.      *
  6.      * @return Map
  7.      * @throws IOException
  8.      */
  9.     public static Map<String, String> parseXml(InputStream is) {
  10.         //将输入流解析成Map
  11.         Map<String, String> map = new HashMap<>();
  12.         try {
  13.             //读取输入流获取文档对象
  14.             SAXReader reader = new SAXReader();
  15.             Document document = reader.read(is);
  17.             //根据文档对象获取根节点
  18.             Element root = document.getRootElement();
  19.             //获取所有的子节点
  20.             List<Element> elements = root.elements();
  21.             for (Element e : elements) {
  22.                 map.put(e.getName(), e.getStringValue());
  23.             }
  24.         } catch (DocumentException e) {
  25.             e.printStackTrace();
  26.         }
  27.         return map;
  28.     }
  30.     /**
  31.      * 将 JavaBean 转换为 XML 字符串
  32.      *
  33.      * @param obj JavaBean 对象
  34.      * @return XML 字符串
  35.      */
  36.     public static String beanToXml(Object obj) throws JAXBException {
  37.         JAXBContext context = JAXBContext.newInstance(obj.getClass());
  38.         Marshaller marshaller = context.createMarshaller();
  39.         marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, false);
  40.         marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
  41.         // 省略文档头
  42.         marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
  43.         StringWriter writer = new StringWriter();
  44.         marshaller.marshal(obj, writer);
  45.         return writer.toString();
  46.     }
  47. }

第一次GET请求认证通过后，返回微信服务器的请求入参echostr，微信服务器接收到后，代表认证成功。至此微信服务器对开发者服务器的认证操作完成。

  1. 第三步：当用户关注微信公众号时，微信服务器会回调开发者服务器，我们只需根据相应的事件和参数结合自身项目的业务取值适配即可。

目前最常用的两种触发关注公众号的操作是：

  • 公域搜索到公众号，然后直接点击关注，进行回调处理 官网参考
  • 通过微信公众号的二维码，去扫码进入关注页面，进行关注，进行回调处理 官网参考

两者的区别是，扫码关注，可以带参数，通常会运用到关注公众号后会建立某种绑定关系的情况。根据自身的业务取衡量取决于那种方式即可。

  • 获取微信公众号的openID

真对微信服务器回调我们的参数，进行处理，即可拿到流程流转的一些必要值域。例如OpenID，就是关注事件参数中的（FromUserName）。如果公众号和小程序已经在开发者平台绑定，可以通过这里的openID，去换取unionID 官网参考

  1. /**
  2.  * 通过单个OpenID来获取用户基本信息(UnionID机制)
  3.  * @param openId 传入公众号openId
  4.  */
  5. public WeChatUserInfo getUserInfo(String openId, String accessToken) throws Exception {
  6.     if (StringUtils.isBlank(openId)) {
  7.         throw new Exception("传入openId不能为空");
  8.     }
  9.     String userInfoOpenidUri = "https://api.weixin.qq.com/cgi-bin/user/info?access_token={0}&openid={1}&lang=zh_CN";
  10.     String url = MessageFormat.format(userInfoOpenidUri, accessToken, openId);
  11.     try {
  12.         JSONObject json = RequestUtil.get(url);
  13.         log.info("公众号用户openID：[{}]获取的unionID信息：[{}]", openId, json.toJSONString());
  14.         if (Objects.nonNull(json.get("errcode")) && Objects.isNull(json.get("data"))) {
  15.             return null;
  16.         }
  17.         WeChatUserInfo weChatUserInfo = JSON.to(WeChatUserInfo.class, json);
  18.         if (Objects.nonNull(weChatUserInfo)) {
  19.             return weChatUserInfo;
  20.         }
  21.     } catch (Exception e) {
  22.         e.printStackTrace();
  23.     }
  24.     return null;
  25. }
  27. /**
  28.  * @Author HaiJia.Chen
  29.  * @Description 获取用户的基本信息明细
  30.  * @Date 2023-04-10 15:13
  31.  **/
  32. @Data
  33. public class WeChatUserInfo {
  34.     private Integer subscribe;
  35.     private String openid;
  36.     private String language;
  37.     private String unionid;
  38.     private String remark;
  39.     private String groupid;
  40.     private String subscribe_scene;
  41. }

获取到OpenID和UnionID后，根据项目的业务设定，去做相应的关系存储即可。处理完成后，会对微信服务器进行响应，然后微信服务器把最终结果响应给用户。

关注公众号推送小程序卡片

通常是在处理回调事件的结尾，去掉微信公众号官方的接口，去实现小程序卡片的推送 官网参考【发送小程序卡片（要求小程序与公众号已关联）】。代码如下：

  1. /**
  2.  * 关注公众号后，推送小程序卡
  3.  */
  4. public boolean sendCardMsg(String accessToken, SendCardMsg cardMsg) {
  5.     if (StringUtils.isBlank(accessToken) || Objects.isNull(cardMsg)) {
  6.         return false;
  7.     }
  8.     String sendCardUri = configProperties.getWexin().getSendCardMessageUri();
  9.     String url = MessageFormat.format(sendCardUri, accessToken);
  10.     try {
  11.         JSONObject json = RequestUtil.post(url, cardMsg);
  12.         log.info("微信公众号推送小程序卡片返回：[{}]", json.toJSONString());
  13.         if (Objects.equals(0, json.get("errcode"))) {
  14.             return true;
  15.         }
  16.     } catch (Exception e) {
  17.         e.printStackTrace();
  18.     }
  19.     return false;
  20. }
  22. public void sendCardMsg(String openId, String accessToken, String saleId) {
  23.     SendCardMsg sendCardMsg = new SendCardMsg();
  24.     sendCardMsg.setTouser(openId);
  25.     sendCardMsg.setMsgtype(WeChatEnum.SEND_CARD_MSGTYPE_MINIPROGRAMPAGE.getCode());
  26.     SendCardDetailMsg detailMsg = new SendCardDetailMsg();
  27.     detailMsg.setAppid("小程序APPID");
  28.     detailMsg.setTitle("卡片标题名称");
  29.     detailMsg.setPagepath("小程序跳转路径");
  30.     detailMsg.setThumb_media_id("图片ID");
  31.     sendCardMsg.setMiniprogrampage(detailMsg);
  32.     weChatUtil.sendCardMsg(accessToken, sendCardMsg);
  33. }

如果我们选择了这样做，会带来一个问题，开发者管理后台无法设置的关注公众号自动推送一段欢迎语。

这时候假如我们既要推送卡片链接，又要推送一句欢迎语，该如何实现呢。答案是：使用被动回复功能 官网参考

被动回复：很简单也就是我们根据官方文档给微信请求我们的回调接口做返回值，即可实现欢迎语。

  1. public String sendTextMsg(ProjectApp projectApp, String openId, String toUserName) {
  2.     TextMessage textMessage = new TextMessage();
  3.     textMessage.setToUserName(openId);
  4.     textMessage.setFromUserName(toUserName);
  5.     textMessage.setCreateTime(System.currentTimeMillis());
  6.     textMessage.setMsgType(WeChatEnum.RESP_MESSAGE_TYPE_TEXT.getCode());
  7.     textMessage.setContent("欢迎关注小陈公众号~");
  8.     String result = "";
  9.     try {
  10.         result = XmlParserUtil.beanToXml(textMessage);
  11.     } catch (JAXBException e) {
  12.         e.printStackTrace();
  13.     }
  14.     return result;
  15. }

生成带参数的公众号二维码

上面的开发流程中讲到了两种常用的扫码关注公众号的两种方式，那公众号二维码是如何生成的呢，又是如何带参数的呢？官网参考

  1. /**
  2.  * 获取微信公众号带参数的二维码
  3.  */
  4. public String generateQrCode(String accessToken, WeChatQrCode weChatQrCode) {
  5.     // 1. 创建二维码ticket
  6.     String genQrcodeUri = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token={0}";
  7.     String showQrCodeUri = "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket={0}";
  8.     String uri = MessageFormat.format(genQrcodeUri, accessToken);
  9.     try {
  10.         JSONObject json = RequestUtil.post(uri, weChatQrCode);
  11.         log.info("获取公众号二维码请求入参[{}]响应结果[{}]", json.toJSONString(), JSON.toJSONString(weChatQrCode));
  12.         if (Objects.nonNull(json.get("errcode")) && Objects.isNull(json.get("ticket"))) {
  13.             return null;
  14.         }
  15.         String qrCodeUrl = MessageFormat.format(showQrCodeUri, json.get("ticket"));
  16.         log.info("获取公众号二维码地址：[{}]", qrCodeUrl);
  17.         //获取上传位置
  18.         String path = "/xiao/chen";
  19.         FileUtil.createFolder(path);
  20.         String savePath = path + System.currentTimeMillis() + ".jpg";;
  21.         InputStream in = null;
  22.         FileOutputStream out = null;
  23.         long fileSizeInBytes = 0L;
  24.         try {
  25.             URL url = new URL(qrCodeUrl);
  26.             URLConnection conn = url.openConnection();
  27.             in = conn.getInputStream();
  28.             fileSizeInBytes = conn.getContentLengthLong();
  29.             byte[] buffer = new byte[1024];
  30.             int len;
  31.             out = new FileOutputStream(savePath);
  32.             while ((len = in.read(buffer)) != -1) {
  33.                 out.write(buffer, 0, len);
  34.             }
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.         } finally {
  38.             if (Objects.nonNull(in)) {
  39.                 in.close();
  40.             }
  41.             if (Objects.nonNull(out)) {
  42.                 out.close();
  43.             }
  44.         }
  45.         //写入数据库，返回保存地址
  46.         //……
  47.         return previewUrl;
  48.     } catch (Exception e) {
  49.         e.printStackTrace();
  50.     }
  51.     return null;
  52. }
  55. @Test
  56. public void genQRCode() {
  57.     String accessToken = weChatUtil.getAccessToken("test", 123L,"appId", "appSecret");
  58.     WeChatQrCode weChatQRCode = new WeChatQrCode();
  59.     weChatQRCode.setActionName("QR_LIMIT_SCENE");
  60.     Map<String, Object> test = new HashMap<>();
  61.     Map<String, Object> t = new HashMap<>();
  62.     t.put("scene_id", 3);
  63.     test.put("scene", t);
  64.     weChatQRCode.setActionInfo(test);
  65.     String Tes = weChatUtil.generateWxQrCode(accessToken, weChatQRCode);
  66.     System.out.println(Tes);
  67. }
  70. @Data
  71. public class WeChatQrCode {
  72.     @ApiModelProperty(name = "expireSeconds", value = "二维码有效时间")
  73.     @JsonProperty("expire_seconds")
  74.     private int expireSeconds;
  75.     @ApiModelProperty(name = "actionName", value = "二维码类型")
  76.     @JsonProperty("action_name")
  77.     private String actionName;
  78.     @ApiModelProperty(name = "actionInfo", value = "二维码详细信息")
  79.     @JsonProperty("action_info")
  80.     private Object actionInfo;
  81. }

微信公众号后台自定义菜单失效

开启服务器配置，允许微信服务器回调我们自己服务器的时候会导致失效。

微信公众号开发 - 图2