Java对接微信公众平台详解

• 1.公众平台概述
• • 1.1 公众平台概述
  • 1.2 入门指引
• 2.对接流程
• • 2.1 接入概述
  • 2.2 填写服务器配置
  • 2.3 接口域名说明
  • 2.4 获取Access token
• 3.项目实现
• • 3.1 创建项目
  • 3.2 项目依赖
  • 3.3 项目配置
  • 3.4 加解密工具
  • 3.5 代码实现
• 4.测试验证

微信公众平台是运营者通过公众号为微信用户提供资讯和服务的平台，而公众平台开发接口则是提供服务的基础，开发者在公众平台网站中创建公众号、获取接口权限后，实现后台接口对接微信公众号的。

官方文档：
https://developers.weixin.qq.com/doc/offiaccount/Getting_Started/Overview.html

为了降低门槛，弥补不足，我们编写了《开发者指引》来讲解微信开放平台的基础常见功能，旨在帮助大家入门微信开放平台的开发者模式。

已熟知接口使用或有一定公众平台开发经验的开发者，请直接跳过本文。这篇文章不会给你带来厉害的编码技巧亦或接口的深层次讲解。对于现有接口存在的疑问，可访问 #公众号社区 发帖交流、联系腾讯客服或使用微信反馈。

对接公众平台与对接开放平台相比比较简单，整个过程只需要配置好开发配置，通过AppID与AppSecret获取token即可，后续所有接口都是通过token调用。

开发者指引：
https://developers.weixin.qq.com/doc/offiaccount/Getting_Started/Getting_Started_Guide.html

接入微信公众平台开发，开发者需要按照如下步骤完成：
1、填写服务器配置
2、验证服务器地址的有效性
3、依据接口文档实现业务逻辑

注意：
1.填写服务器配置前提是注册公众号，并拥有相关的权限，注册不同公众号类型，是否认证权限不同。
2.配置服务器还需要能够对接外网回调，这个需要提前内网穿透（Sunny-Ngrok使用教程），或者云服务器也可。

不同类型公众号权限说明：
https://developers.weixin.qq.com/doc/offiaccount/Getting_Started/Explanation_of_interface_privileges.html

全局返回码说明：
https://developers.weixin.qq.com/doc/offiaccount/Getting_Started/Global_Return_Code.html

开发者工具
https://mp.weixin.qq.com/cgi-bin/frame?t=advanced/dev_tools_frame&nav=10049&token=809046757&lang=zh_CN

1.配置说明
登录微信公众平台官网后，在公众平台官网的开发-基本设置页面，勾选协议成为开发者，点击“修改配置”按钮，填写服务器地址（URL）、Token和EncodingAESKey，其中URL是开发者用来接收微信消息和事件的接口URL。Token可由开发者可以任意填写，用作生成签名（该Token会和接口URL中包含的Token进行比对，从而验证安全性）。EncodingAESKey由开发者手动填写或随机生成，将用作消息体加解密密钥。

同时，开发者可选择消息加解密方式：明文模式、兼容模式和安全模式。模式的选择与服务器配置在提交后都会立即生效，请开发者谨慎填写及选择。加解密方式的默认状态为明文模式，选择兼容模式和安全模式需要提前配置好相关加解密代码，详情请参考消息体签名及加解密部分的文档 。

填写服务器配置说明：
https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Access_Overview.html

2.配置信息状态

3.注意事项

服务器配置开启状态则菜单配置不可用，关闭状态才能后台配置，也就是接口调用与后台配置互斥。

因为个人订阅号无法认证，所以可以使用添加测试账号。
路径：公众号 - 设置与开发 - 开发者工具 – 公众平台测试账号
https://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo?action=showinfo&t=sandbox/index

公众平台接口域名说明
开发者可以根据自己的服务器部署情况，选择最佳的接入域名（延时更低，稳定性更高）。除此之外，可以将其他接入域名用作容灾用途，当网络链路发生故障时，可以考虑选择备用域名来接入。请开发者使用域名进行API接口请求，不要使用IP作为访问。若有需要开通网络策略，开发者可以从获取微信服务器IP地址定期获取最新的IP信息。

通用域名(api.weixin.qq.com)，使用该域名将访问官方指定就近的接入点；
通用异地容灾域名(api2.weixin.qq.com)，当上述域名不可访问时可改访问此域名；
上海域名(sh.api.weixin.qq.com)，使用该域名将访问上海的接入点；
深圳域名(sz.api.weixin.qq.com)，使用该域名将访问深圳的接入点；
香港域名(hk.api.weixin.qq.com)，使用该域名将访问香港的接入点。

公众平台接口域名说明:
https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Interface_field_description.html

access_token是公众号的全局唯一接口调用凭据，公众号调用各接口时都需使用access_token。开发者需要进行妥善保存。access_token的存储至少要保留512个字符空间。access_token的有效期目前为2个小时，需定时刷新，重复获取将导致上次获取的access_token失效。

获取Access token:
https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_access_token.html

创建springboot项目，代码还有很多可以优化的地方，比如消息可以做策略，代码中的枚举类型，常量，授权信息可以放缓存等等，因为这里只做测试，可以结合测试自行优化。
为了方便测试，这些授权参数放到集合内存里面了，所以每次重启丢失，后期是要优化到redis缓存持久化的，验证票据有效期12小时所以为了测试可以写死，其他的从内存取就可以了。

另外可以有许多开源的微信开发框架可以参考学习使用，这里依赖引入微信开发框架weixin-Java-tools binarywang只是为了学习研究，并为使用。
weixin-Java-tools：https://gitee.com/itwu/weixin-java-tools#https://mp.weixin.qq.com/s/nIk_xOf6dxkhKfqq830Cuw

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.5.4
         
    
    com.zrj
    wechat
    0.0.1-SNAPSHOT
    wechat
    Demo project for Spring Boot
    
        1.8
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.1.4
        
        
            mysql
            mysql-connector-java
            runtime
        
        
            org.springframework.boot
            spring-boot-starter-jdbc
        
        
        
            com.google.guava
            guava
            30.1.1-jre
        
        
            cn.hutool
            hutool-all
            5.6.3
        
        
            org.projectlombok
            lombok
            true
        
        
            com.alibaba
            fastjson
            1.2.72
        
        
            com.google.code.gson
            gson
            2.8.6
        
        
        
            io.springfox
            springfox-swagger2
            2.6.1
        
        
            io.springfox
            springfox-swagger-ui
            2.6.1
        
        
        
            commons-codec
            commons-codec
            1.9
        
        
            junit
            junit
            4.13.2
        
        
            org.dom4j
            dom4j
            2.1.1
        
        
        
            javax.validation
            validation-api
            2.0.1.Final
        
        
            org.hibernate.validator
            hibernate-validator
            6.0.13.Final
        
        
            org.apache.httpcomponents
            httpcore
            4.4.14
        
        
            org.apache.httpcomponents
            httpclient
            4.5.13
        
        
        
            com.github.binarywang
            weixin-java-common
            4.1.0
        
        
            com.github.binarywang
            weixin-java-mp
            4.1.0
        
        
            com.github.binarywang
            weixin-java-open
            4.1.0
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok
                        
                    
                
            
        
    

这里暂时没用到

消息加解密说明：
https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/Before_Develop/Message_encryption_and_decryption.html

加解密工具下载地址：https://res.wx.qq.com/op_res/-serEQ6xSDVIjfoOHcX78T1JAYX-pM_fghzfiNYoD8uHVd3fOeC0PC_pvlg4-kmP

1.下载解压后根据对应的语言选择对应的工具类，直接打成jar包放入私服引用或者直接放入项目引用即可。
2.需要导入架包commons-codec-1.9（或commons-codec-1.8等其他版本）
3.这里需要注意的是加解密的时候与公众号加解密参数不同，因为返回的xml不一样，如果使用公众号的加解密会出现空指针，需要根据返回结果调整，公众号加密后xml是ToUser与Encrypt标签，开放平台的返回是AppId与Encrypt标签，其中Encrypt是加密内容。

依赖替换

加解密调整类XMLParse

// ------------------------------------------------------------------------

package com.zrj.wechat.aes;

import java.io.StringReader;

import javax.xml.parsers.documentBuilder;
import javax.xml.parsers.documentBuilderFactory;

import org.w3c.dom.document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;


class XMLParse {

    
    public static Object[] extract(String xmltext) throws AesException {
        Object[] result = new Object[3];
        try {
            documentBuilderFactory dbf = documentBuilderFactory.newInstance();
            dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
            dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
            dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
            dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            dbf.setXIncludeAware(false);
            dbf.setExpandEntityReferences(false);
            documentBuilder db = dbf.newdocumentBuilder();
            StringReader sr = new StringReader(xmltext);
            InputSource is = new InputSource(sr);
            document document = db.parse(is);

            Element root = document.getdocumentElement();
            //公众平台解密字段
            NodeList nodelist1 = root.getElementsByTagName("Encrypt");
            NodeList nodelist2 = root.getElementsByTagName("ToUserName");

            //开放平台解密字段
            //NodeList nodelist1 = root.getElementsByTagName("Encrypt");
            //NodeList nodelist2 = root.getElementsByTagName("AppId");
            result[0] = 0;
            result[1] = nodelist1.item(0).getTextContent();
            result[2] = nodelist2.item(0).getTextContent();
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            throw new AesException(AesException.ParseXmlError);
        }
    }

    
    public static Object[] extractOP(String xmltext) throws AesException {
        Object[] result = new Object[3];
        try {
            documentBuilderFactory dbf = documentBuilderFactory.newInstance();
            dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
            dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
            dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
            dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            dbf.setXIncludeAware(false);
            dbf.setExpandEntityReferences(false);
            documentBuilder db = dbf.newdocumentBuilder();
            StringReader sr = new StringReader(xmltext);
            InputSource is = new InputSource(sr);
            document document = db.parse(is);

            Element root = document.getdocumentElement();
            NodeList nodelist1 = root.getElementsByTagName("Encrypt");
            //NodeList nodelist2 = root.getElementsByTagName("ToUserName");
            NodeList nodelist2 = root.getElementsByTagName("AppId");
            result[0] = 0;
            result[1] = nodelist1.item(0).getTextContent();
            result[2] = nodelist2.item(0).getTextContent();
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            throw new AesException(AesException.ParseXmlError);
        }
    }

    
    public static String generate(String encrypt, String signature, String timestamp, String nonce) {

        String format = "n" + "n"
                + "n"
                + "%3$sn" + "n" + "";
        return String.format(format, encrypt, signature, timestamp, nonce);

    }
}

WechatUtils

package com.zrj.wechat.utils;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.dom4j.document;
import org.dom4j.documentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.ByteArrayInputStream;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;


@Slf4j
public class WechatUtils {

    private static final String AUTHORIZER_ACCESS_TOKEN = "ACCESS_TOKEN";
    private static final String COMPONENT_ACCESS_TOKEN = "COMPONENT_ACCESS_TOKEN";

    
    public static String getAuthorizerAccessToken() {
        // 从缓存获取授权信息,使用授权码获取授权信息
        String authorizerAccessToken = "";
        return authorizerAccessToken;
    }

    
    public static String replaceComponentAccessToken(String url, String componentAccessToken) {
        if (StrUtil.isEmpty(componentAccessToken)) {
            return url;
        }
        return url.replaceAll(COMPONENT_ACCESS_TOKEN, componentAccessToken);
    }

    
    public static String replaceAuthorizerAccessToken(String url, String authorizerAccessToken) {
        return url.replaceAll(AUTHORIZER_ACCESS_TOKEN, authorizerAccessToken);
    }

    
    public static boolean validWechatResult(JSONObject jsonObject) {
        if (jsonObject == null) {
            log.error("执行失败,响应结果为空,jsonObject:{}", jsonObject);
            return false;
        }

        int errcode = jsonObject.getIntValue("errcode");
        String errmsg = jsonObject.getString("errmsg");
        if (0 != errcode) {
            log.error("执行失败,响应信息 errcode:{} errmsg:{}", errcode, errmsg);
            return false;
        }
        log.error("执行成功,响应信息 errcode:{} errmsg:{}", errcode, errmsg);
        return true;
    }

    
    public static JSONObject doGetstr(String url) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url);
        JSONObject jsonObject = null;
        try {
            CloseableHttpResponse response = httpclient.execute(httpGet);
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                String result = EntityUtils.toString(entity);
                //jsonObject =JSONObject.fromObject(result);
                jsonObject = JSONObject.parseObject(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jsonObject;
    }

    
    public static JSONObject doPoststr(String url, String outStr) {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost(url);
        JSONObject jsonObject = null;
        try {
            httpPost.setEntity(new StringEntity(outStr, "utf-8"));
            CloseableHttpResponse response = httpclient.execute(httpPost);
            String result = EntityUtils.toString(response.getEntity(), "utf-8");
            //jsonObject =JSONObject.fromObject(result);
            jsonObject = JSONObject.parseObject(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jsonObject;
    }

    
    public static Map xmlToMap(String xml) throws Exception {
        Map respMap = new HashMap<>(16);
        SAXReader reader = new SAXReader();
        document doc = reader.read(new ByteArrayInputStream(xml.getBytes("utf-8")));
        Element root = doc.getRootElement();
        xmlToMap(root, respMap);
        return respMap;
    }

    
    public static String mapToXml(Map map) throws Exception {
        document d = documentHelper.createdocument();
        Element root = d.addElement("xml");
        mapToXml(root, map);
        StringWriter sw = new StringWriter();
        XMLWriter xw = new XMLWriter(sw);
        xw.setEscapeText(false);
        xw.write(d);
        return sw.toString();
    }

    
    private static Element mapToXml(Element root, Map map) {
        for (Map.Entry entry : map.entrySet()) {
            if (entry.getValue() instanceof Map) {
                Element element = root.addElement(entry.getKey());
                mapToXml(element, (Map) entry.getValue());
            } else {
                root.addElement(entry.getKey()).addText(entry.getValue().toString());
            }
        }
        return root;
    }

    
    private static Map xmlToMap(Element tmpElement, Map respMap) {
        if (tmpElement.isTextOnly()) {
            respMap.put(tmpElement.getName(), tmpElement.getText());
            return respMap;
        }
        Iterator eItor = tmpElement.elementIterator();
        while (eItor.hasNext()) {
            Element element = eItor.next();
            xmlToMap(element, respMap);
        }
        return respMap;
    }

}

WechatMpService

package com.zrj.wechat.service;

import com.zrj.wechat.entity.Response;


public interface WechatMpService {
    
    String event(String signature, String timestamp, String nonce, String echostr, String encryptType, String msgSignature, String openid, String postData);

    
    Response getAccessToken();

    
    Response getCurrentAutoreplyInfo();

    
    Response getApiDomainIp();

    
    Response check();

    
    Response batchGetFreePublish();

    
    Response