spring-boot企业微信第三方开发!拿来就能用!(附源码)

前言

        网上虽说有很多例子，但是都说的太片面或者就贴出一些核心的代码！

        废话不多说！直接上干货！(如果不想看，可直接下载源码到自己工程：点我获取！！！)

1.需要的工具类和核心类

1.1 企业微信配置类 WeChatConstants (以下参数需要配置的都注明了，都能在企微配置里面拿到)

public class WeChatConstants {

    // 企业微信授权码获取时间
    public static final Long EXPIRES_IN = 24 * 60 * 60 * 1000L;
    //24 * 60 * 60 * 1000L 7200L * 1000

    /**
     * 服务商CorpID(需要在企微拿)
     */
    public static final String CORP_ID = "xxx";
    /**
     * 服务商身份的调用凭证(需要在企微拿)
     */
    public static final String PROVIDER_SECRET = "xxx";

    /**
     * 应用的唯一身份标识(需要在企微拿)
     */
    public static final String SUITE_ID = "xxx";
    /**
     * 应用的调用身份密钥(需要在企微拿)
     */
    public static final String SUITE_SECRET = "xxx";

    /**
     * 应用的ticket(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String SUITE_TICKET = "SUITE_TICKET";

    /**
     * 应用的auth_code(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String AUTH_CODE = "AUTH_CODE";

    /**
     * 第三方应用凭证token(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String SUITE_TOKEN = "suiteToken";

    /**
     * 授权方（企业）token(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String ACCESS_TOKEN = "ACCESS_TOKEN";

    /**
     * 提供商 授权方服务token(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String PROVIDER_ACCESS_TOKEN = "PROVIDER_ACCESS_TOKEN";

    /**
     * 应用企业corpid(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String AUTH_CORPID = "AUTH_CORPID";

    /**
     * 企业名称(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String CORP_NAME = "CORPNAME";

    /**
     * 授权方的网页应用ID，在具体的网页应用中查看(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String AGENT_ID = "AGENTID";

    /**
     * 用户id(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */
    public static final String USER_ID = "userId";

    // 回调相关
    /**
     * 回调/通用开发参数Token(需要在企微拿)
     */
    public static final String TOKENS = "xxx";

    /**
     * 回调/通用开发参数EncodingAESKey(需要在企微拿)
     */
    public static final String ENCODING_AES_KEY = "xxx";
    /**
     * 登录跳转的地址(需要配置，开发文档中有参考)
     */

    public static final String REDIRECT_URI = "REDIRECT_URI";

    /**
     * 重定向地址，自己设置
     */
    public static final String REDIRECT_URL = "xxx";

    // 第三方应用id（即ww或wx开头的suite_id）(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
    public static final String APP_ID= "APPID";
 /**
     * 永久授权码(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
     */

    public static final String PERMANENT_CODE = "PERMANENT_CODE"; 

    // 通过成员授权获取到的code(此值在内存中拿,后面代码有这个存放的类,我会贴出来,不用更改)
    public static final String CODE = "CODE";

1.2字符串工具类StringUtils

import cn.hutool.core.text.StrFormatter;

import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * 字符串工具类
 * 
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
    /** 空字符串 */
    private static final String NULLSTR = "";

    private static final String NULLSTRING = "NULL";
    private static final String NULLLOWERCASESTRING = "null";

    /** 下划线 */
    private static final char SEPARATOR = '_';

    /** 星号 */
    private static final String START = "*";

    /**
     * 获取参数不为空值
     * 
     * @param value defaultValue 要判断的value
     * @return value 返回值
     */
    public static <T> T nvl(T value, T defaultValue)
    {
        return value != null ? value : defaultValue;
    }

    /**
     * * 判断一个Collection是否为空， 包含List，Set，Queue
     * 
     * @param coll 要判断的Collection
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Collection<?> coll)
    {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * 判断一个Collection是否非空，包含List，Set，Queue
     * 
     * @param coll 要判断的Collection
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Collection<?> coll)
    {
        return !isEmpty(coll);
    }

    /**
     * * 判断一个对象数组是否为空
     * 
     * @param objects 要判断的对象数组
     ** @return true：为空 false：非空
     */
    public static boolean isEmpty(Object[] objects)
    {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * 判断一个对象数组是否非空
     * 
     * @param objects 要判断的对象数组
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Object[] objects)
    {
        return !isEmpty(objects);
    }

    /**
     * * 判断一个Map是否为空
     * 
     * @param map 要判断的Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map)
    {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * 判断一个Map是否为空
     * 
     * @param map 要判断的Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map)
    {
        return !isEmpty(map);
    }

    /**
     * * 判断一个字符串是否为空串
     * 
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str)
    {
        return isNull(str) || NULLSTR.equals(str.trim()) || NULLSTRING.equalsIgnoreCase(str) || NULLLOWERCASESTRING.equals(str);
    }

    /**
     * 验证是否都为空
     * @param str
     * @return
     */
    public static boolean isAllEmpty(String ... str)
    {
        for (String s :str) {
            if (!isEmpty(s)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 验证是否包含为空
     * @param str
     * @return
     */
    public static boolean haveEmpty(String ... str)
    {
        for (String s :str) {
            if (isEmpty(s)) {
                return true;
            }
        }
        return false;
    }

    /**
     * * 判断一个字符串是否为非空串
     * 
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }

    /**
     * * 判断一个对象是否为空
     * 
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object)
    {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     * 
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object)
    {
        return !isNull(object);
    }

    /**
     * * 判断一个对象是否是数组类型（Java基本型别的数组）
     * 
     * @param object 对象
     * @return true：是数组 false：不是数组
     */
    public static boolean isArray(Object object)
    {
        return isNotNull(object) && object.getClass().isArray();
    }

    /**
     * 去空格
     */
    public static String trim(String str)
    {
        return (str == null ? "" : str.trim());
    }

    /**
     * 截取字符串
     * 
     * @param str 字符串
     * @param start 开始
     * @return 结果
     */
    public static String substring(final String str, int start)
    {
        if (str == null)
        {
            return NULLSTR;
        }

        if (start < 0)
        {
            start = str.length() + start;
        }

        if (start < 0)
        {
            start = 0;
        }
        if (start > str.length())
        {
            return NULLSTR;
        }

        return str.substring(start);
    }

    /**
     * 截取字符串
     * 
     * @param str 字符串
     * @param start 开始
     * @param end 结束
     * @return 结果
     */
    public static String substring(final String str, int start, int end)
    {
        if (str == null)
        {
            return NULLSTR;
        }

        if (end < 0)
        {
            end = str.length() + end;
        }
        if (start < 0)
        {
            start = str.length() + start;
        }

        if (end > str.length())
        {
            end = str.length();
        }

        if (start > end)
        {
            return NULLSTR;
        }

        if (start < 0)
        {
            start = 0;
        }
        if (end < 0)
        {
            end = 0;
        }

        return str.substring(start, end);
    }

    /**
     * 格式化文本, {} 表示占位符<br>
     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
     * 例：<br>
     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
     * 
     * @param template 文本模板，被替换的部分用 {} 表示
     * @param params 参数值
     * @return 格式化后的文本
     */
    public static String format(String template, Object... params)
    {
        if (isEmpty(params) || isEmpty(template))
        {
            return template;
        }
        return StrFormatter.format(template, params);
    }

    /**
     * 下划线转驼峰命名
     */
    public static String toUnderScoreCase(String str)
    {
        if (str == null)
        {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        // 前置字符是否大写
        boolean preCharIsUpperCase = true;
        // 当前字符是否大写
        boolean curreCharIsUpperCase = true;
        // 下一字符是否大写
        boolean nexteCharIsUpperCase = true;
        for (int i = 0; i < str.length(); i++)
        {
            char c = str.charAt(i);
            if (i > 0)
            {
                preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
            }
            else
            {
                preCharIsUpperCase = false;
            }

            curreCharIsUpperCase = Character.isUpperCase(c);

            if (i < (str.length() - 1))
            {
                nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
            }

            if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
            {
                sb.append(SEPARATOR);
            }
            else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
            {
                sb.append(SEPARATOR);
            }
            sb.append(Character.toLowerCase(c));
        }

        return sb.toString();
    }

    /**
     * 是否包含字符串
     * 
     * @param str 验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs)
    {
        if (str != null && strs != null)
        {
            for (String s : strs)
            {
                if (str.equalsIgnoreCase(trim(s)))
                {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
     * 
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String convertToCamelCase(String name)
    {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty())
        {
            // 没必要转换
            return "";
        }
        else if (!name.contains("_"))
        {
            // 不含下划线，仅将首字母大写
            return name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String[] camels = name.split("_");
        for (String camel : camels)
        {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty())
            {
                continue;
            }
            // 首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
        }
        return result.toString();
    }

    /**
     * 驼峰式命名法 例如：user_name->userName
     */
    public static String toCamelCase(String s)
    {
        if (s == null)
        {
            return null;
        }
        s = s.toLowerCase();
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++)
        {
            char c = s.charAt(i);

            if (c == SEPARATOR)
            {
                upperCase = true;
            }
            else if (upperCase)
            {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            }
            else
            {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
     * 
     * @param str 指定字符串
     * @param strs 需要检查的字符串数组
     * @return 是否匹配
     */
    public static boolean matches(String str, List<String> strs)
    {
        if (isEmpty(str) || isEmpty(strs))
        {
            return false;
        }
        for (String testStr : strs)
        {
            if (matches(str, testStr))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * 查找指定字符串是否匹配指定字符串数组中的任意一个字符串
     * 
     * @param str 指定字符串
     * @param strs 需要检查的字符串数组
     * @return 是否匹配
     */
    public static boolean matches(String str, String... strs)
    {
        if (isEmpty(str) || isEmpty(strs))
        {
            return false;
        }
        for (String testStr : strs)
        {
            if (matches(str, testStr))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * 查找指定字符串是否匹配
     * 
     * @param str 指定字符串
     * @param pattern 需要检查的字符串
     * @return 是否匹配
     */
    public static boolean matches(String str, String pattern)
    {
        if (isEmpty(pattern) || isEmpty(str))
        {
            return false;
        }

        pattern = pattern.replaceAll("\\s*", ""); // 替换空格
        int beginOffset = 0; // pattern截取开始位置
        int formerStarOffset = -1; // 前星号的偏移位置
        int latterStarOffset = -1; // 后星号的偏移位置

        String remainingURI = str;
        String prefixPattern = "";
        String suffixPattern = "";

        boolean result = false;
        do
        {
            formerStarOffset = indexOf(pattern, START, beginOffset);
            prefixPattern = substring(pattern, beginOffset, formerStarOffset > -1 ? formerStarOffset : pattern.length());

            // 匹配前缀Pattern
            result = remainingURI.contains(prefixPattern);
            // 已经没有星号，直接返回
            if (formerStarOffset == -1)
            {
                return result;
            }

            // 匹配失败，直接返回
            if (!result)
                return false;

            if (!isEmpty(prefixPattern))
            {
                remainingURI = substringAfter(str, prefixPattern);
            }

            // 匹配后缀Pattern
            latterStarOffset = indexOf(pattern, START, formerStarOffset + 1);
            suffixPattern = substring(pattern, formerStarOffset + 1, latterStarOffset > -1 ? latterStarOffset : pattern.length());

            result = remainingURI.contains(suffixPattern);
            // 匹配失败，直接返回
            if (!result)
                return false;

            if (!isEmpty(suffixPattern))
            {
                remainingURI = substringAfter(str, suffixPattern);
            }

            // 移动指针
            beginOffset = latterStarOffset + 1;

        }
        while (!isEmpty(suffixPattern) && !isEmpty(remainingURI));

        return true;
    }

    @SuppressWarnings("unchecked")
    public static <T> T cast(Object obj)
    {
        return (T) obj;
    }

    /**
     * 字符串拼接
     * @author: wqsong
     * @date: 2021/8/31
     * @param: str 字符串参数
     * @returns:
     */
    public static String appendStr(String ... str){
        StringBuffer sb = new StringBuffer();
        for (String s : str) {
            sb.append(s);
        }
        return sb.toString();
    }

    //object转String
    public static String toString(Object obj){
        if(obj == null){
            return null;
        }else {
            return obj.toString();
        }
    }

    /**
     * String转int 直到遇到非数字（90-01 ——> 90）
     * @author wy
     * @date 2021/12/7
     * @param str
     * @return int
     */
    public static Integer string2Int(String str) {
        char[] chars = str.toCharArray();
        int n = 0;
        for (int i = 0; i < chars.length; i++) {
            if (!Character.isDigit(chars[i])) {
                break;
            }
            n = n * 10 + Character.getNumericValue(chars[i]);
        }
        return n;
    }
}

1.3企业工具类 WeChatUtils

public class WeChatUtils {
    /**
     * 第三方应用api start
     */
    // 获取第三方应用凭证
    public final static String THIRD_BUS_WECHAT_SUITE_TOKEN = "https://qyapi.weixin.qq.com/cgi-bin/service/get_suite_token";

    // 获取企业永久授权码
    public final static String THIRD_BUS_WECHAT_ACCESS_TOKEN = "https://qyapi.weixin.qq.com/cgi-bin/service/get_permanent_code?suite_access_token=SUITE_ACCESS_TOKEN";

    // 第三方 构造扫码登录链接
    public final static String THIRD_BUS_WECHAT_LOGIN = "https://open.work.weixin.qq.com/wwopen/sso/3rd_qrConnect?appid=CORPID&redirect_uri=REDIRECT_URI&state=web_login&usertype=member";

    // 第三方 获取登录用户信息 POST
    public final static String THIRD_BUS_WECHAT_GET_LOGIN_INFO = "https://qyapi.weixin.qq.com/cgi-bin/service/get_login_info?access_token=PROVIDER_ACCESS_TOKEN";

    // 第三方 构造网页授权链接
    public final static String THIRD_BUS_WECHAT_AUTHORIZE_URL = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=APPID&redirect_uri=REDIRECT_URI&response_type=code&scope=snsapi_privateinfo&state=STATE#wechat_redirect";

    // 第三方 获取访问用户身份 GET
    public final static String THIRD_BUS_WECHAT_GET_USER_INFO = "https://qyapi.weixin.qq.com/cgi-bin/service/getuserinfo3rd?suite_access_token=SUITE_TOKEN&code=CODE";

    // 第三方 获取访问用户敏感信息 post
    public final static String THIRD_BUS_WECHAT_GET_USER_DETAIL3RD = "https://qyapi.weixin.qq.com/cgi-bin/service/getuserdetail3rd?suite_access_token=SUITE_ACCESS_TOKEN";

    // 第三方 获取部门列表
    public final static String THIRD_BUS_WECHAT_DEPART_LIST = "https://qyapi.weixin.qq.com/cgi-bin/department/list?access_token=ACCESS_TOKEN&id=ID";

    // 第三方 获取部门成员
    public final static String THIRD_BUS_WECHAT_DEPART_USER = "https://qyapi.weixin.qq.com/cgi-bin/user/simplelist?access_token=ACCESS_TOKEN&department_id=DEPARTMENT_ID&fetch_child=FETCH_CHILD";

    // 第三方 获取部门成员详情
    public final static String THIRD_BUS_WECHAT_DEPART_USER_DETAIL = "https://qyapi.weixin.qq.com/cgi-bin/user/list?access_token=ACCESS_TOKEN&department_id=DEPARTMENT_ID&fetch_child=FETCH_CHILD";

    // 第三方 读取成员 GET
    public final static String THIRD_BUS_WECHAT_GET_USER = "https://qyapi.weixin.qq.com/cgi-bin/user/get?access_token=ACCESS_TOKEN&userid=USERID";

    // 服务商的token
    public final static String THIRD_BUS_WECHAT_GET_PROVIDER_TOKEN = "https://qyapi.weixin.qq.com/cgi-bin/service/get_provider_token";

    // 获取企业凭证
    public final static String THIRD_BUS_WECHAT_GET_CORP_TOKEN = "https://qyapi.weixin.qq.com/cgi-bin/service/get_corp_token?suite_access_token=SUITE_ACCESS_TOKEN";

    // 发送应用消息
    public final static String THIRD_BUS_WECHAT_SEND = "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=ACCESS_TOKEN";

    // 获取应用的jsapi_ticket
    public final static String THIRD_BUS_GET_JSAPI_TICKET = "https://qyapi.weixin.qq.com/cgi-bin/ticket/get?access_token=ACCESS_TOKEN&type=agent_config";

    // 获取企业的jsapi_ticket
    public final static String THIRD_BUS_GET_JSAPI_TICKET_BUS = "https://qyapi.weixin.qq.com/cgi-bin/get_jsapi_ticket?access_token=ACCESS_TOKEN";
    /**
     * 第三方应用api end
     */

}

1.4解析微信发来的请求xmlstr

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * TODO 解析微信发来的请求（xmlStr）
 *
 */
public class WxUtil {
    /**
     * @desc ：2.解析微信发来的请求（xmlStr）,获取请求参数
     *
     * @param xmlStr
     * @return
     * @throws Exception Map<String,String>
     */
    public static Map<String, String> parseXml(String xmlStr) throws Exception {
        // 将解析结果存储在HashMap中
        Map<String, String> map = new HashMap<String, String>();


        //1.将字符串转为Document
        Document document = DocumentHelper.parseText(xmlStr);

        //2.获取根元素的所有子节点
        // 得到xml根元素
        Element root = document.getRootElement();
        // 得到根元素的所有子节点
        List<Element> elementList = root.elements();

        //3.遍历所有子节点
        for (Element e : elementList){
            map.put(e.getName(), e.getText());
        }

        return map;
    }
}

2.1  缓存类 CacheData

import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import com.wechat.common.WeChatConstants;

/**
 * 缓存
 */
public class CacheData {
    public static Cache<String, Object> wechat_token_cache = CacheUtil.newTimedCache(WeChatConstants.EXPIRES_IN);

    public static void put(String key, Object obj) {
        wechat_token_cache.put(key, obj);
    }

    public static Object get(String key) {
        return wechat_token_cache.get(key);
    }
}

2.2切面类(@Pointcut需要改成你自己的类)

import com.wechat.service.IWeChatThirdTokenService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 定义切面
 */
@Slf4j
@Aspect
@Component
public class WeChatAop {
    @Autowired
    private IWeChatThirdTokenService weChatThirdTokenService;

    /**
     * 定义切入点，切入点为com.wechat.service.impl.WeChatServiceImpl所有方法
     */
    @Pointcut("execution(public * com.wechat.service.impl.WeChatServiceImpl..*.*(..))")
    public void method(){}

    /**
     * 前置通知：在连接点之前执行的通知
     */
    @Before(value = "method()")
    public void getToken(){
        weChatThirdTokenService.getSuiteToken();
        weChatThirdTokenService.getProviderToken();
    }

    /**
     * 处理完后返回内存
     */
    @AfterReturning(returning = "ret",pointcut = "method()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        log.debug("RESPONSE:" + ret);
    }
}

以上是需要的各种配置类和核心类(可先复制放到自己的工程里面)

---

实现(以下代码都可以复制到自己工程)

从Controller开始

1.1数据回调和指令回调 SystemController

import com.ruoyi.web.controller.common.CacheData;
import com.ruoyi.web.controller.common.WeChatConstants;
import com.ruoyi.web.service.IConfigService;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.Map;

/**
 * 控制层
 */
@Slf4j
@RestController
@RequestMapping(value = "/corpWx/callback")
public class SystemController {

    @Autowired
    private IConfigService configService;

    /**
     * 验证通用开发参数及应用回调
     * @param: request
     * @param: response
     * @returns: void
     */
    @ApiOperation(value = "验证通用开发参数及应用回调")
    @GetMapping(value = "/getData")
    public void doGetCallback(HttpServletRequest request, HttpServletResponse response) throws Exception {
        log.debug("doGetCallback->验证通用开发参数及应用回调");
        // 微信加密签名
        String msgSignature = request.getParameter("msg_signature");
        // 时间戳
        String timestamp = request.getParameter("timestamp");
        // 随机数
        String nonce = request.getParameter("nonce");
        // 随机字符串
        // 如果是刷新，需返回原echostr
        String echoStr = request.getParameter("echostr");
        String sEchoStr=  "";
        PrintWriter out;
        log.debug("msgSignature: " + msgSignature+"timestamp="+timestamp+"nonce="+nonce+"echoStr="+echoStr);
        try {
            sEchoStr = configService.doGetCallback(msgSignature,timestamp,nonce,echoStr); //需要返回的明文;
            log.debug("doGetCallback->echostr: " + sEchoStr);
            //验证URL成功，将sEchoStr返回
            out = response.getWriter();
            out.print(sEchoStr);
        } catch (Exception e) {
            //验证URL失败，错误原因请查看异常
            e.printStackTrace();
        }
    }

    /**
     * 刷新ticket，AuthCode
     */
    @ApiOperation(value = "刷新ticket，AuthCode")
    @PostMapping(value = "/getData")
    public String doPostCallback(HttpServletRequest request) throws Exception {
        log.debug("doGetCallback->刷新ticket，AuthCode");
        // 微信加密签名
        String msgSignature = request.getParameter("msg_signature");
        // 时间戳
        String timestamp = request.getParameter("timestamp");
        // 随机数
        String nonce = request.getParameter("nonce");
        // 类型
        //type和企业id需要在数据回调增加/getData?type=data&corpid=$CORPID$
        String type = request.getParameter("type");
        // 企业id
        //首先将数据回调URL加上 &corpid=$CORPID$ ，微信服务器会自动将 $CORPID$ 的内容替换为该企业的corpid
        String corpId = request.getParameter("corpid");
        log.debug("corpId==========>>"+corpId);
        ServletInputStream in = request.getInputStream();
        // 刷新ticket，AuthCode
        String success = configService.doPostCallback(msgSignature, timestamp, nonce, type, corpId, in);
        return success;
    }

}

1.2第三方应用操作WeChatThirdController 

import com.wechat.entity.wechat.WeChatLoginUrl;
import com.wechat.entity.wechat.WeChatUserinfo3rd;
import com.wechat.entity.wechat.WechatUserInfo;
import com.wechat.service.IWeChatService;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 第三方应用操作
 *
 */
@Slf4j
@RestController
@RequestMapping(value = "wechat")
public class WeChatThirdController {

    @Autowired
    private IWeChatService weChatService;


    /**
     * 获取扫码登录地址
     */
    @ApiOperation(value = "获取扫码登录地址")
    @PostMapping(value = "login")
    public WeChatLoginUrl login(){
        //获取扫码登录地址
        return weChatService.thirdLoginUrl();
    }

    /**
     * 企业微信内登录地址
     */
    @ApiOperation(value = "企业微信内登录")
    @PostMapping(value = "wechatLogin")
    public WeChatLoginUrl wechatLogin(){
        //获取企业微信内登录地址
        return weChatService.wechatLoginUrl();
    }

    /**
     * 前端回调->扫码授权登录-获取访问用户身份
     */
    @ApiOperation(value = "获取访问用户身份")
    @PostMapping(value = "getUserInfo")
    public WechatUserInfo getUserInfo(String code){
        //获取访问用户身份
        return weChatService.getUserInfo(code);
    }

    /**
     * 前端回调->网页授权登录-获取访问用户身份
     */
    @ApiOperation(value = "获取访问用户身份")
    @PostMapping(value = "getUserinfo3rd")
    public WeChatUserinfo3rd getUserinfo3rd(String code){
        //获取访问用户身份
        return weChatService.getUserinfo3rd(code);
    }
}

1.3第三方应用操作WeChatThirdTokenController

import com.wechat.service.IWeChatThirdTokenService;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 第三方应用操作
 *
 */
@Slf4j
@RestController
@RequestMapping(value = "wechatToken")
public class WeChatThirdTokenController {

    @Autowired
    private IWeChatThirdTokenService weChatThirdTokenService;


    /**
     * 获取扫码登录地址
     */
    @ApiOperation(value = "获取扫码登录地址")
    @PostMapping(value = "getSuiteToken")
    public void getSuiteToken(){
        //获取扫码登录地址
        weChatThirdTokenService.getSuiteToken();
    }

    /**
     * 企业微信内登录地址
     */
    @ApiOperation(value = "企业微信内登录")
    @PostMapping(value = "getProviderToken")
    public void getProviderToken(){
        //获取企业微信内登录地址
        weChatThirdTokenService.getProviderToken();
    }

    /**
     * 前端回调->获取访问用户身份
     */
    @ApiOperation(value = "获取访问用户身份")
    @PostMapping(value = "getCorpToken")
    public void getCorpToken(){
        weChatThirdTokenService.getCorpToken();
    }
}

以上是controller

---

实体类(可以直接复制)

1.1自定义异常类

public class AesException extends Exception {

    public final static int OK = 0;
    public final static int ValidateSignatureError = -40001;
    public final static int ParseXmlError = -40002;
    public final static int ComputeSignatureError = -40003;
    public final static int IllegalAesKey = -40004;
    public final static int ValidateCorpidError = -40005;
    public final static int EncryptAESError = -40006;
    public final static int DecryptAESError = -40007;
    public final static int IllegalBuffer = -40008;

    private int code;

    private static String getMessage(int code) {
        switch (code) {
            case ValidateSignatureError:
                return "签名验证错误";
            case ParseXmlError:
                return "xml解析失败";
            case ComputeSignatureError:
                return "sha加密生成签名失败";
            case IllegalAesKey:
                return "SymmetricKey非法";
            case ValidateCorpidError:
                return "corpid校验失败";
            case EncryptAESError:
                return "aes加密失败";
            case DecryptAESError:
                return "aes解密失败";
            case IllegalBuffer:
                return "解密后得到的buffer非法";
            default:
                return null; // cannot be
        }
    }
    public int getCode() {
        return code;
    }
    AesException(int code) {
        super(getMessage(code));
        this.code = code;
    }
}

1.2字节处理类

import java.util.ArrayList;

class ByteGroup {
	ArrayList<Byte> byteContainer = new ArrayList<Byte>();

	public byte[] toBytes() {
		byte[] bytes = new byte[byteContainer.size()];
		for (int i = 0; i < byteContainer.size(); i++) {
			bytes[i] = byteContainer.get(i);
		}
		return bytes;
	}

	public ByteGroup addBytes(byte[] bytes) {
		for (byte b : bytes) {
			byteContainer.add(b);
		}
		return this;
	}

	public int size() {
		return byteContainer.size();
	}
}

1.3提供基于PKCS7算法的加解密接口类

import java.nio.charset.Charset;
import java.util.Arrays;

/**
 * 提供基于PKCS7算法的加解密接口.
 */
class PKCS7Encoder {
	static Charset CHARSET = Charset.forName("utf-8");
	static int BLOCK_SIZE = 32;

	/**
	 * 获得对明文进行补位填充的字节.
	 * 
	 * @param count 需要进行填充补位操作的明文字节个数
	 * @return 补齐用的字节数组
	 */
	static byte[] encode(int count) {
		// 计算需要填充的位数
		int amountToPad = BLOCK_SIZE - (count % BLOCK_SIZE);
		if (amountToPad == 0) {
			amountToPad = BLOCK_SIZE;
		}
		// 获得补位所用的字符
		char padChr = chr(amountToPad);
		String tmp = new String();
		for (int index = 0; index < amountToPad; index++) {
			tmp += padChr;
		}
		return tmp.getBytes(CHARSET);
	}

	/**
	 * 删除解密后明文的补位字符
	 * 
	 * @param decrypted 解密后的明文
	 * @return 删除补位字符后的明文
	 */
	static byte[] decode(byte[] decrypted) {
		int pad = (int) decrypted[decrypted.length - 1];
		if (pad < 1 || pad > 32) {
			pad = 0;
		}
		return Arrays.copyOfRange(decrypted, 0, decrypted.length - pad);
	}

	/**
	 * 将数字转化成ASCII码对应的字符，用于对明文进行补码
	 * 
	 * @param a 需要转化的数字
	 * @return 转化得到的字符
	 */
	static char chr(int a) {
		byte target = (byte) (a & 0xFF);
		return (char) target;
	}

}

1.4计算消息签名接口

class SHA1 {

	/**
	 * 用SHA1算法生成安全签名
	 * @param token 票据
	 * @param timestamp 时间戳
	 * @param nonce 随机字符串
	 * @param encrypt 密文
	 * @return 安全签名
	 * @throws AesException 
	 */
	public static String getSHA1(String token, String timestamp, String nonce, String encrypt) throws AesException
			  {
		try {
			String[] array = new String[] { token, timestamp, nonce, encrypt };
			StringBuffer sb = new StringBuffer();
			// 字符串排序
			Arrays.sort(array);
			for (int i = 0; i < 4; i++) {
				sb.append(array[i]);
			}
			String str = sb.toString();
			// SHA1签名生成
			MessageDigest md = MessageDigest.getInstance("SHA-1");
			md.update(str.getBytes());
			byte[] digest = md.digest();

			StringBuffer hexstr = new StringBuffer();
			String shaHex = "";
			for (int i = 0; i < digest.length; i++) {
				shaHex = Integer.toHexString(digest[i] & 0xFF);
				if (shaHex.length() < 2) {
					hexstr.append(0);
				}
				hexstr.append(shaHex);
			}
			return hexstr.toString();
		} catch (Exception e) {
			e.printStackTrace();
			throw new AesException(AesException.ComputeSignatureError);
		}
	}
}

1.5提供接收和推送给企业微信消息的加解密接口(UTF8编码的字符串).

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Random;

/**
 * 提供接收和推送给企业微信消息的加解密接口(UTF8编码的字符串).
 * <ol>
 * 	<li>第三方回复加密消息给企业微信</li>
 * 	<li>第三方收到企业微信发送的消息，验证消息的安全性，并对消息进行解密。</li>
 * </ol>
 * 说明：异常java.security.InvalidKeyException:illegal Key Size的解决方案
 * <ol>
 * 	<li>在官方网站下载JCE无限制权限策略文件（JDK7的下载地址：
 *      http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html</li>
 * 	<li>下载后解压，可以看到local_policy.jar和US_export_policy.jar以及readme.txt</li>
 * 	<li>如果安装了JRE，将两个jar文件放到%JRE_HOME%\lib\security目录下覆盖原来的文件</li>
 * 	<li>如果安装了JDK，将两个jar文件放到%JDK_HOME%\jre\lib\security目录下覆盖原来文件</li>
 * </ol>
 */
public class WXBizMsgCrypt {
	static Charset CHARSET = Charset.forName("utf-8");
	Base64 base64 = new Base64();
	byte[] aesKey;
	String token;
	String receiveid;

	/**
	 * 构造函数
	 * @param token 企业微信后台，开发者设置的token
	 * @param encodingAesKey 企业微信后台，开发者设置的EncodingAESKey
	 * @param receiveid, 不同场景含义不同，详见文档
	 * 
	 * @throws AesException 执行失败，请查看该异常的错误码和具体的错误信息
	 */
	public WXBizMsgCrypt(String token, String encodingAesKey, String receiveid) throws AesException {
		if (encodingAesKey.length() != 43) {
			throw new AesException(AesException.IllegalAesKey);
		}

		this.token = token;
		this.receiveid = receiveid;
		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[] receiveidBytes = receiveid.getBytes(CHARSET);

		// randomStr + networkBytesOrder + text + receiveid
		byteCollector.addBytes(randomStrBytes);
		byteCollector.addBytes(networkBytesOrder);
		byteCollector.addBytes(textBytes);
		byteCollector.addBytes(receiveidBytes);

		// ... + 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_receiveid;
		try {
			// 去除补位字符
			byte[] bytes = PKCS7Encoder.decode(original);

			// 分离16位随机字符串,网络字节序和receiveid
			byte[] networkOrder = Arrays.copyOfRange(bytes, 16, 20);

			int xmlLength = recoverNetworkBytesOrder(networkOrder);

			xmlContent = new String(Arrays.copyOfRange(bytes, 20, 20 + xmlLength), CHARSET);
			from_receiveid = new String(Arrays.copyOfRange(bytes, 20 + xmlLength, bytes.length),
					CHARSET);
		} catch (Exception e) {
			e.printStackTrace();
			throw new AesException(AesException.IllegalBuffer);
		}

		// receiveid不相同的情况
		if (!from_receiveid.equals(receiveid)) {
			throw new AesException(AesException.ValidateCorpidError);
		}
		return xmlContent;

	}

	/**
	 * 将企业微信回复用户的消息加密打包.
	 * <ol>
	 * 	<li>对要发送的消息进行AES-CBC加密</li>
	 * 	<li>生成安全签名</li>
	 * 	<li>将消息密文和安全签名打包成xml格式</li>
	 * </ol>
	 * 
	 * @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;
	}

	/**
	 * 检验消息的真实性，并且获取解密后的明文.
	 * <ol>
	 * 	<li>利用收到的密文生成安全签名，进行签名验证</li>
	 * 	<li>若验证通过，则提取xml中的加密消息</li>
	 * 	<li>对消息进行解密</li>
	 * </ol>
	 * 
	 * @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;
	}

}

1.6提供提取消息格式中的密文及生成回复消息格式的接口

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.StringReader;

/**
 * XMLParse class
 *
 * 提供提取消息格式中的密文及生成回复消息格式的接口.
 */
class XMLParse {

	/**
	 * 提取出xml数据包中的加密消息
	 * @param xmltext 待提取的xml字符串
	 * @return 提取出的加密消息字符串
	 * @throws AesException 
	 */
	public static Object[] extract(String xmltext) throws AesException     {
		Object[] result = new Object[3];
		try {
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			
			String FEATURE = null;
			// This is the PRIMARY defense. If DTDs (doctypes) are disallowed, almost all XML entity attacks are prevented
			// Xerces 2 only - http://xerces.apache.org/xerces2-j/features.html#disallow-doctype-decl
			FEATURE = "http://apache.org/xml/features/disallow-doctype-decl";
			dbf.setFeature(FEATURE, true);
			
			// If you can't completely disable DTDs, then at least do the following:
			// Xerces 1 - http://xerces.apache.org/xerces-j/features.html#external-general-entities
			// Xerces 2 - http://xerces.apache.org/xerces2-j/features.html#external-general-entities
			// JDK7+ - http://xml.org/sax/features/external-general-entities 
			FEATURE = "http://xml.org/sax/features/external-general-entities";
			dbf.setFeature(FEATURE, false);
			
			// Xerces 1 - http://xerces.apache.org/xerces-j/features.html#external-parameter-entities
			// Xerces 2 - http://xerces.apache.org/xerces2-j/features.html#external-parameter-entities
			// JDK7+ - http://xml.org/sax/features/external-parameter-entities 
			FEATURE = "http://xml.org/sax/features/external-parameter-entities";
			dbf.setFeature(FEATURE, false);
			
			// Disable external DTDs as well
			FEATURE = "http://apache.org/xml/features/nonvalidating/load-external-dtd";
			dbf.setFeature(FEATURE, false);
			
			// and these as well, per Timothy Morgan's 2014 paper: "XML Schema, DTD, and Entity Attacks"
			dbf.setXIncludeAware(false);
			dbf.setExpandEntityReferences(false);
			
			// And, per Timothy Morgan: "If for some reason support for inline DOCTYPEs are a requirement, then 
			// ensure the entity settings are disabled (as shown above) and beware that SSRF attacks
			// (http://cwe.mitre.org/data/definitions/918.html) and denial 
			// of service attacks (such as billion laughs or decompression bombs via "jar:") are a risk."
			
			// remaining parser logic
			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");
			result[0] = 0;
			result[1] = nodelist1.item(0).getTextContent();
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			throw new AesException(AesException.ParseXmlError);
		}
	}

	/**
	 * 生成xml消息
	 * @param encrypt 加密后的消息密文
	 * @param signature 安全签名
	 * @param timestamp 时间戳
	 * @param nonce 随机字符串
	 * @return 生成的xml字符串
	 */
	public static String generate(String encrypt, String signature, String timestamp, String nonce) {

		String format = "<xml>\n" + "<Encrypt><![CDATA[%1$s]]></Encrypt>\n"
				+ "<MsgSignature><![CDATA[%2$s]]></MsgSignature>\n"
				+ "<TimeStamp>%3$s</TimeStamp>\n" + "<Nonce><![CDATA[%4$s]]></Nonce>\n" + "</xml>";
		return String.format(format, encrypt, signature, timestamp, nonce);

	}
}

1.7登录url地址实体类

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 登录url地址
 *
 * @author: wx
 * @date: 2022/2/21
 */
@NoArgsConstructor
@Data
public class WeChatLoginUrl {
    private String loginUrl;
}

1.8获取企业永久授权码

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

/**
 * 获取企业永久授权码
 *
 * @author: wx
 * @date: 2022/2/17
 */
@NoArgsConstructor
@Data
public class WeChatPermanentCodeReturn {
    private Integer errcode;
    private String errmsg;
    private String access_token;
    private Long expires_in;
    private String permanent_code;

    private AuthCorpInfo auth_corp_info;

    public static class AuthCorpInfo{
        private String corpid;
        private String corp_name;

        public String getCorpid() {
            return corpid;
        }

        public void setCorpid(String corpid) {
            this.corpid = corpid;
        }

        public String getCorp_name() {
            return corp_name;
        }

        public void setCorp_name(String corp_name) {
            this.corp_name = corp_name;
        }
    }

    private AuthInfo auth_info;

    public static class AuthInfo{
        private List<Agent> agent;

        public List<Agent> getAgent() {
            return agent;
        }

        public void setAgent(List<Agent> agent) {
            this.agent = agent;
        }

        public static class Agent{
            private Long agentid;
            private String name;

            public Long getAgentid() {
                return agentid;
            }

            public void setAgentid(Long agentid) {
                this.agentid = agentid;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
    }

    private AuthUserInfo auth_user_info;

    public static class AuthUserInfo{
        private String userid;
        private String name;

        public String getUserid() {
            return userid;
        }

        public void setUserid(String userid) {
            this.userid = userid;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }


    public Integer getErrcode() {
        return errcode;
    }

    public void setErrcode(Integer errcode) {
        this.errcode = errcode;
    }

    public String getErrmsg() {
        return errmsg;
    }

    public void setErrmsg(String errmsg) {
        this.errmsg = errmsg;
    }

    public String getAccess_token() {
        return access_token;
    }

    public void setAccess_token(String access_token) {
        this.access_token = access_token;
    }

    public Long getExpires_in() {
        return expires_in;
    }

    public void setExpires_in(Long expires_in) {
        this.expires_in = expires_in;
    }

    public String getPermanent_code() {
        return permanent_code;
    }

    public void setPermanent_code(String permanent_code) {
        this.permanent_code = permanent_code;
    }

    public AuthCorpInfo getAuth_corp_info() {
        return auth_corp_info;
    }

    public void setAuth_corp_info(AuthCorpInfo auth_corp_info) {
        this.auth_corp_info = auth_corp_info;
    }

    public AuthInfo getAuth_info() {
        return auth_info;
    }

    public void setAuth_info(AuthInfo auth_info) {
        this.auth_info = auth_info;
    }

    public AuthUserInfo getAuth_user_info() {
        return auth_user_info;
    }

    public void setAuth_user_info(AuthUserInfo auth_user_info) {
        this.auth_user_info = auth_user_info;
    }

    @Override
    public String toString() {
        return "WeChatPermanentCodeReturn{" +
                "errcode=" + errcode +
                ", errmsg='" + errmsg + '\'' +
                ", access_token='" + access_token + '\'' +
                ", expires_in=" + expires_in +
                ", permanent_code='" + permanent_code + '\'' +
                ", auth_corp_info=" + auth_corp_info +
                ", auth_info=" + auth_info +
                ", auth_user_info=" + auth_user_info +
                '}';
    }
}

1.9服务商的access_token

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 服务商的access_token
 *
 * @author: wx
 * @date: 2022/2/21
 */
@NoArgsConstructor
@Data
public class WeChatProviderAccessToken {
    private Integer errcode;
    private String errmsg;
    private String provider_access_token;
    private Long expires_in;
}

2.0企业微信token返回值

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 企业微信token返回值
 *
 * @author: wx
 * @date: 2021/12/13
 */
@NoArgsConstructor
@Data
public class WeChatReturn {
    private Integer errcode;
    private String errmsg;
    private String access_token;
    private Long expires_in;
}

2.1获取第三方应用凭证

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 获取第三方应用凭证
 *
 * @author: wx
 * @date: 2022/2/17
 */
@NoArgsConstructor
@Data
public class WeChatSuiteReturn {
    private Integer errcode;
    private String errmsg;
    private String suite_access_token;
    private Long expires_in;
}

2.2获取访问用户身份返回值

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 获取访问用户身份返回值
 *
 * @author: wx
 * @date: 2021/12/31
 */
@NoArgsConstructor
@Data
public class WechatUserInfo {
    private Integer errcode;
    private String errmsg;
    private String userId;
    private UserInfo user_info;
    private CorpInfo corp_info;
    private Integer status;

    public static class UserInfo{
        private String userid;
        private String open_userid;
        private String name;

        public String getUserid() {
            return userid;
        }

        public void setUserid(String userid) {
            this.userid = userid;
        }

        public String getOpen_userid() {
            return open_userid;
        }

        public void setOpen_userid(String open_userid) {
            this.open_userid = open_userid;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    public static class CorpInfo{
        private String corpid;

        public String getCorpid() {
            return corpid;
        }

        public void setCorpid(String corpid) {
            this.corpid = corpid;
        }
    }
}

2.3获取访问用户身份

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 获取访问用户身份
 * 网页登录
 *
 * @author: wx
 * @date: 2022/2/23
 */
@NoArgsConstructor
@Data
public class WeChatUserinfo3rd {
    private Integer errcode;
    private String errmsg;
    private String CorpId;
    private String UserId;
    private String DeviceId;
    private String user_ticket;
    private String open_userid;
    private Integer status;
}

以上是实体类

---

实现类和实现接口类(service和serviceImpl)

1.1企业微信第三方服务的service

import javax.servlet.ServletInputStream;

/**
 * 企业微信第三方服务service
 */
public interface IConfigService {

    /**
     * 验证通用开发参数及应用回调
     * @returns: java.lang.String
     */
    String doGetCallback(String msgSignature, String timestamp, String nonce, String echoStr);

    /**
     * 获取SuiteTicket，AuthCode
     */
    String doPostCallback(String msgSignature, String timestamp, String nonce, String type, String corpId, ServletInputStream in);


}

1.2第三方应用服务层的service

import com.wechat.entity.wechat.WeChatLoginUrl;
import com.wechat.entity.wechat.WeChatUserinfo3rd;
import com.wechat.entity.wechat.WechatUserInfo;

/**
 * 第三方应用服务层
 */
public interface IWeChatService {
    /**
     * 获取企业永久码
     */
    void getPermanentCode(String authCode);

    /**
     * 扫码登录-获取用户信息
     */
    WechatUserInfo getUserInfo(String code);

    /**
     * 网页授权登录-获取用户信息
     */
    WeChatUserinfo3rd getUserinfo3rd(String code);

    /**
     * 获取扫码登录地址
     */
    WeChatLoginUrl thirdLoginUrl();

    /**
     * 获取企业微信内登录地址
     */
    WeChatLoginUrl wechatLoginUrl();
}

1.3获取token的service

/**
 * 获取token
 */
public interface IWeChatThirdTokenService {

    /**
     * 获取第三方应用凭证
     */
    void getSuiteToken();

    /**
     * 服务商的token
     */
    void getProviderToken();

    /**
     * 获取企业凭证
     */
    void getCorpToken();
}

1.4 实现类IConfigService

import com.alibaba.druid.support.json.JSONUtils;
import com.wechat.common.StringUtils;
import com.wechat.common.WeChatConstants;
import com.wechat.common.WxUtil;
import com.wechat.common.cache.CacheData;
import com.wechat.entity.aes.AesException;
import com.wechat.entity.aes.WXBizMsgCrypt;
import com.wechat.service.IConfigService;
import com.wechat.service.IWeChatService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.ServletInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Map;

/**
 * 回调service
 */
@Slf4j
@Service
public class ConfigServiceImpl implements IConfigService {

    @Autowired
    private IWeChatService weChatService;

    /**
     * 验证通用开发参数及应用回调
     * @returns: java.lang.String
     */
    @Override
    public String doGetCallback(String msgSignature, String timestamp, String nonce, String echoStr) {
        //需要返回的明文
        String sEchoStr="";
        try {
            log.debug(WeChatConstants.TOKENS, WeChatConstants.ENCODING_AES_KEY, WeChatConstants.CORP_ID);
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(WeChatConstants.TOKENS, WeChatConstants.ENCODING_AES_KEY, WeChatConstants.CORP_ID);
            sEchoStr = wxcpt.VerifyURL(msgSignature, timestamp, nonce, echoStr);
        } catch (AesException e) {
            e.printStackTrace();
        }
        return sEchoStr;
    }

    /**
     * 获取SuiteTicket，AuthCode
     * @param: msgSignature 微信加密签名
     * @param: timestamp 时间戳
     * @param: nonce  随机数
     * @param: type 类型
     * @param: corpId 企业id
     * @param: in
     * @returns: java.lang.String
     */
    @Override
    public String doPostCallback(String msgSignature, String timestamp, String nonce, String type, String corpId, ServletInputStream in) {
        String id = "";
        // 访问应用和企业回调传不同的ID
        if(!StringUtils.isNull(type) && type.equals("data")){
            id = corpId;
            log.debug("======corpId==="+id);
        } else {
            id = WeChatConstants.SUITE_ID;
            log.debug("======SuiteId===" + id);
        }
        try {
            WXBizMsgCrypt wxcpt = new WXBizMsgCrypt(WeChatConstants.TOKENS, WeChatConstants.ENCODING_AES_KEY, id);
            String postData="";   // 密文，对应POST请求的数据
            //1.获取加密的请求消息：使用输入流获得加密请求消息postData
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String tempStr = "";   //作为输出字符串的临时串，用于判断是否读取完毕
            while(null != (tempStr=reader.readLine())){
                postData+=tempStr;
            }
            log.debug("====msg_signature===="+msgSignature+"====timestamp==="+timestamp+"====nonce==="+nonce+"====postData==="+postData);
            String suiteXml = wxcpt.DecryptMsg(msgSignature, timestamp, nonce, postData);
            log.debug("suiteXml: " + suiteXml);
            Map suiteMap = WxUtil.parseXml(suiteXml);
            log.debug("==suiteMap=="+ JSONUtils.toJSONString(suiteMap));
            if(suiteMap.get("SuiteTicket") != null) {
                String suiteTicket = (String) suiteMap.get("SuiteTicket");
                CacheData.put(WeChatConstants.SUITE_TICKET, suiteTicket);
                log.debug("====SuiteTicket=====" + suiteTicket);
            } else if(suiteMap.get("AuthCode") != null){
                String authCode = (String) suiteMap.get("AuthCode");
                log.debug("doPostValid->AuthCode:" + authCode);
                //根据authcode获取企业永久授权码
                weChatService.getPermanentCode(authCode);
                CacheData.put(WeChatConstants.AUTH_CODE, authCode);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "success";
    }
}

1.5 IWeChatService实现类

import cn.hutool.http.ContentType;
import cn.hutool.http.HttpRequest;
import cn.hutool.json.JSONUtil;
import com.wechat.common.WeChatConstants;
import com.wechat.common.WeChatUtils;
import com.wechat.common.cache.CacheData;
import com.wechat.entity.wechat.WeChatLoginUrl;
import com.wechat.entity.wechat.WeChatPermanentCodeReturn;
import com.wechat.entity.wechat.WeChatUserinfo3rd;
import com.wechat.entity.wechat.WechatUserInfo;
import com.wechat.service.IWeChatService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;

/**
 * 第三方应用服务层
 */
@Slf4j
@Service
public class WeChatServiceImpl implements IWeChatService {

    /**
     * 构造扫码登录链接
     */
    @Override
    public WeChatLoginUrl thirdLoginUrl() {
        WeChatLoginUrl login = new WeChatLoginUrl();
        // 企业微信的CorpID
        String corpId = WeChatConstants.CORP_ID;
        // 重定向url
        String redirectUrl = WeChatConstants.REDIRECT_URL;
        log.debug("登录地址url:"+redirectUrl+"企业微信corpId->"+corpId);
        // 重定向地址
        String redirectUri = "";
        try {
            redirectUri = URLEncoder.encode((redirectUrl), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }
        // 获取扫码登录链接
        String getWechatLogin = WeChatUtils.THIRD_BUS_WECHAT_LOGIN;
        // 转换成登录地址
        String loginUrl = getWechatLogin.replace(WeChatConstants.CORP_ID, corpId).replace(WeChatConstants.REDIRECT_URI,redirectUri);
        login.setLoginUrl(loginUrl);
        log.debug("重定向后登录地址url:"+login);
        return login;
    }

    /**
     * 构造企业微信内登录链接
     */
    @Override
    public WeChatLoginUrl wechatLoginUrl() {
        log.debug("wechatLogin->start");
        WeChatLoginUrl login = new WeChatLoginUrl();
        // 	第三方应用id（即ww或wx开头的suite_id）。
        String suiteId = WeChatConstants.SUITE_ID;
        // 重定向地址
        String redirectUrl = WeChatConstants.REDIRECT_URL;
        log.debug("suiteId:"+suiteId+"==redirectUrl:"+redirectUrl);
        // 重定向地址
        try {
            redirectUrl = URLEncoder.encode(redirectUrl, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }
        //第三方 构造网页授权链接
        String getWechatLogin = WeChatUtils.THIRD_BUS_WECHAT_AUTHORIZE_URL;
        // 转换成登录地址
        String loginUrl = getWechatLogin.replace(WeChatConstants.APP_ID, suiteId).replace(WeChatConstants.REDIRECT_URI,redirectUrl);
        login.setLoginUrl(loginUrl);
        log.debug("企业微信内登录重定向url:"+loginUrl);
        return login;
    }

    /**
     * 获取企业永久码
     */
    @Override
    public void getPermanentCode(String authCode) {
        // 永久授权码
        log.debug("获取企业永久授权码->getPermanentCode->start");
        // 	第三方应用access_token
        String suiteToken = (String)CacheData.get("SUITE_TOKEN");
        // 获取企业永久授权码url
        String accessTokenUrl = WeChatUtils.THIRD_BUS_WECHAT_ACCESS_TOKEN;
        // 替换值
        accessTokenUrl = accessTokenUrl.replace("SUITE_ACCESS_TOKEN", suiteToken);
        try {
            Map<String, Object> map = new HashMap<>();
            map.put("auth_code", authCode);
            log.debug("获取企业永久授权码accessTokenUrl:"+accessTokenUrl+"->auth_code:"+authCode);
            String body = HttpRequest.post(accessTokenUrl).body(JSONUtil.toJsonStr(map), ContentType.JSON.getValue()).execute().body();
            WeChatPermanentCodeReturn weChat = JSONUtil.toBean(body, WeChatPermanentCodeReturn.class);
            log.debug("获取企业永久授权码转换成bean->weChat:"+weChat);
            //授权方（企业）access_token
            String accessToken = weChat.getAccess_token();
            //授权方企业微信id
            String corpId = weChat.getAuth_corp_info().getCorpid();
            //授权方企业微信名称
            String corpName = weChat.getAuth_corp_info().getCorp_name();
            //授权方应用id
            Long agentId = weChat.getAuth_info().getAgent().get(0).getAgentid();
            //用户id
            String userId = weChat.getAuth_user_info().getUserid();
            //企业永久授权码
            String permanentCode = weChat.getPermanent_code();
            //存放到cache中
            CacheData.put(WeChatConstants.ACCESS_TOKEN, accessToken);
            //授权方企业微信id
            CacheData.put(WeChatConstants.AUTH_CORPID, corpId);
            //授权方企业微信名称
            CacheData.put(WeChatConstants.CORP_NAME, corpName);
            //授权方应用id
            CacheData.put(WeChatConstants.AGENT_ID, agentId);
            //用户id
            CacheData.put(WeChatConstants.USER_ID, userId);
            //获取企业永久授权码
            CacheData.put(WeChatConstants.PERMANENT_CODE, permanentCode);
            log.debug("获取企业永久授权码->PERMANENT_CODE:"+permanentCode);
        } catch (Exception e) {
            log.debug("获取accessToken失败errcode");
            throw new RuntimeException();
        }
        log.debug("获取企业永久授权码->getPermanentCode->end");
    }

    /**
     * 获取用户信息
     */
    @Override
    public WechatUserInfo getUserInfo(String code) {
        // 	授权登录服务商的网站时，使用应用提供商的provider_access_toke
        String providerSccessToken = (String) CacheData.get(WeChatConstants. PROVIDER_ACCESS_TOKEN);
        // 获取扫码登录链接url
        String getUserInfo = WeChatUtils.THIRD_BUS_WECHAT_GET_LOGIN_INFO;
        // 获取登录用户信息
        String getUserInfoUrl = getUserInfo.replace(WeChatConstants.PROVIDER_ACCESS_TOKEN, providerSccessToken);
        log.debug("getUserInfo->获取登录用户信息Url->"+getUserInfoUrl);
        // 使用http请求调用
        Map<String, Object> mapCode = new HashMap<>();
        mapCode.put("auth_code", code);
        String body = HttpRequest.post(getUserInfoUrl).body(JSONUtil.toJsonStr(mapCode), ContentType.JSON.getValue()).execute().body();
        WechatUserInfo userInfo = null;
        String userId = "";
        try {
            // 获取用户信息
            userInfo = JSONUtil.toBean(body, WechatUserInfo.class);
            log.debug("getUserInfo->获取用户信息转换成bean:"+JSONUtil.toJsonStr(userInfo));
            if(userInfo.getErrcode() == null || userInfo.getErrcode() == 0){
                // 用户id
                userId = userInfo.getUser_info().getUserid();
                userInfo.setUserId(userId);
            } else{
                throw new RuntimeException(userInfo.getErrmsg());
            }
            log.debug("获取访问用户身份成功");
        } catch (Exception e) {
            log.debug("获取访问用户身份失败");
            throw new RuntimeException(userInfo.getErrmsg());
        }
        log.debug("getUserInfo->end->userInfo:"+JSONUtil.toJsonStr(userInfo));
        return userInfo;
    }

    /**
     * 网页授权登录-获取用户信息
     */
    @Override
    public WeChatUserinfo3rd getUserinfo3rd(String code) {
        //授权登录服务商的网站时，第三方应用access_token
        String suiteToken = (String) CacheData.get(WeChatConstants.SUITE_TOKEN);
        // 获取扫码登录链接url
        String getUserinfo3rdUrl = WeChatUtils.THIRD_BUS_WECHAT_GET_USER_INFO;
        // 替换
        getUserinfo3rdUrl = getUserinfo3rdUrl.replace(WeChatConstants.SUITE_TOKEN, suiteToken).replace(WeChatConstants.CODE, code);
        log.debug("获取访问用户身份url:"+getUserinfo3rdUrl);
        // 使用http请求调用
        String body = HttpRequest.get(getUserinfo3rdUrl).execute().body();
        WeChatUserinfo3rd userInfo = null;
        String userId = "";
        try {
            // 取部门列表信息
            userInfo = JSONUtil.toBean(body, WeChatUserinfo3rd.class);
            log.debug("获取访问用户身份userInfo转换成bean:"+JSONUtil.toJsonStr(userInfo));
            if(userInfo.getErrcode() == null || userInfo.getErrcode() == 0){
                // 用户id
                userId = userInfo.getUserId();
                userInfo.setUserId(userId);
            } else{
                throw new RuntimeException(userInfo.getErrmsg());
            }
            String success = String.format("获取访问用户身份成功", userId ,userInfo.getErrcode());
            log.debug(success);
        } catch (Exception e) {
            String error = String.format("获取访问用户身份失败", userInfo.getErrcode() ,userInfo.getErrmsg());
            log.debug(error);
            throw new RuntimeException(userInfo.getErrmsg());
        }
        log.debug("getUserinfo3rd->end:"+JSONUtil.toJsonStr(userInfo));
        return userInfo;
    }
}

1.6  IWeChatThirdTokenService实现类

import cn.hutool.http.ContentType;
import cn.hutool.http.HttpRequest;
import cn.hutool.json.JSONUtil;
import com.alibaba.druid.support.json.JSONUtils;
import com.wechat.common.WeChatConstants;
import com.wechat.common.WeChatUtils;
import com.wechat.common.cache.CacheData;
import com.wechat.entity.wechat.WeChatProviderAccessToken;
import com.wechat.entity.wechat.WeChatReturn;
import com.wechat.entity.wechat.WeChatSuiteReturn;
import com.wechat.service.IWeChatThirdTokenService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

/**
 * 获取token
 */
@Slf4j
@Service
public class WeChatThirdTokenServiceImpl implements IWeChatThirdTokenService {

    /**
     * 获取第三方应用凭证
     */
    @Override
    public void getSuiteToken() {
        // 获取第三方应用凭证url
        String suiteTokenUrl = WeChatUtils.THIRD_BUS_WECHAT_SUITE_TOKEN;
        // 	第三方应用access_token
        String suiteToken = "";
        try {
            Map<String,Object> map = new HashMap<>();
            //以ww或wx开头应用id
            map.put("suite_id", WeChatConstants.SUITE_ID);
            //应用secret
            map.put("suite_secret", WeChatConstants.SUITE_SECRET);
            //企业微信后台推送的ticket
            map.put("suite_ticket", CacheData.get(WeChatConstants.SUITE_TICKET));
            log.debug("getSuiteToken获取第三方应用凭证url入参:"+ JSONUtil.toJsonStr(map));
            String body = HttpRequest.post(suiteTokenUrl).body(JSONUtil.toJsonStr(map), ContentType.JSON.getValue()).execute().body();
            log.debug("getSuiteToken获取第三方应用凭证出参:"+JSONUtil.toJsonStr(body));
            WeChatSuiteReturn weChat = JSONUtil.toBean(body, WeChatSuiteReturn.class);
            log.debug("getSuiteToken获取第三方应用凭证出参转换成bea:"+JSONUtil.toJsonStr(weChat));
            if(weChat.getErrcode() == null || weChat.getErrcode() == 0){
                suiteToken = weChat.getSuite_access_token();
                CacheData.put(WeChatConstants.SUITE_TOKEN, suiteToken);
            }
            // 打印消息
            log.debug("获取suite token成功:"+suiteToken);
        } catch (Exception e) {
            log.debug("获取suite token失败errcode:"+suiteToken);
            throw new RuntimeException();
        }
    }

    /**
     * 服务商的token
     */
    @Override
    public void getProviderToken() {
        // 服务商的secret，在服务商管理后台可见
        String providerSecret = WeChatConstants.PROVIDER_SECRET;
        // 服务商的corpid
        String corpId = WeChatConstants.CORP_ID;
        // 获取服务商的tokenurl
        String providerTokenUrl = WeChatUtils.THIRD_BUS_WECHAT_GET_PROVIDER_TOKEN;
        String providerAccessToken = null;
        try {
            Map<String, Object> map = new HashMap<>();
            map.put("corpid", corpId);
            map.put("provider_secret", providerSecret);
            log.debug("getProviderToken入参:"+ JSONUtils.toJSONString(map));
            String body = HttpRequest.post(providerTokenUrl).body(JSONUtil.toJsonStr(map), ContentType.JSON.getValue()).execute().body();
            log.debug("getProviderToken出参"+body);
            WeChatProviderAccessToken weChat = JSONUtil.toBean(body, WeChatProviderAccessToken.class);
            if(weChat.getErrcode() == null || weChat.getErrcode() == 0){
                providerAccessToken = weChat.getProvider_access_token();
                CacheData.put("PROVIDER_ACCESS_TOKEN",providerAccessToken);
            }
            // 打印消息
            log.debug("获取providerAccessTokenn成功:"+ providerAccessToken);
        } catch (Exception e) {
            log.error("获取providerAccessToken失败:"+ providerAccessToken);
            throw new RuntimeException();
        }
    }

    /**
     * 如果企业凭证到期后
     * 根据授权方corpid，企业永久码获取获取企业凭证
     */
    @Override
    public void getCorpToken() {
        log.debug("获取企业凭证getCorpToken==========start============");
        //永久码
        String permanentCode =  (String)CacheData.get(WeChatConstants.PERMANENT_CODE);
        //第三方应用access_token
        String suiteAccessToken = (String) CacheData.get(WeChatConstants.SUITE_TOKEN);
        //应用企业corpid
        String authCorpId = (String)CacheData.get(WeChatConstants.AUTH_CORPID);
        //获取企业凭证
        String corpTokenUrl = WeChatUtils.THIRD_BUS_WECHAT_GET_CORP_TOKEN;
        corpTokenUrl = corpTokenUrl.replace("SUITE_ACCESS_TOKEN", suiteAccessToken);
        //授权方（企业）access_token
        String accessToken = null;
        try {
            Map<String, Object> map = new HashMap<>();
            //授权方corpid
            map.put("auth_corpid", authCorpId);
            //永久授权码
            map.put("permanent_code", permanentCode);
            log.debug("获取企业凭证 getCorpToken 入参："+suiteAccessToken+"==map："+JSONUtils.toJSONString(map));
            String body = HttpRequest.post(corpTokenUrl).body(JSONUtil.toJsonStr(map), ContentType.JSON.getValue()).execute().body();
            WeChatReturn weChat = JSONUtil.toBean(body, WeChatReturn.class);
            log.debug("获取企业凭证 getCorpToken 出参转换成bean=="+JSONUtil.toJsonStr(weChat));
            accessToken = weChat.getAccess_token();
            CacheData.put(WeChatConstants.ACCESS_TOKEN,accessToken);
            CacheData.put(WeChatConstants.AUTH_CORPID,authCorpId);
            //打印消息
            log.debug("获取accessToken成功:" + accessToken);
        } catch (Exception e) {
            log.debug("获取paccessToken失败:" + accessToken);
            throw new RuntimeException();
        }
        log.debug("获取企业凭证getCorpToken==========end============");
    }
}

以上代码是impl实现类和接口service

---

结语

如有问题欢迎留言

拜了个拜！