微信公众号开发——获取AccessToken接口调用凭据

😊 @ 作者： 一恍过去

💖 @ 主页： https://blog.csdn.net/zhuocailing3390

🎊 @ 社区： Java技术栈交流

🎉 @ 主题： 微信公众号开发——获取AccessToken接口调用凭据

⏱️ @ 创作时间： 2022年12月11日

准备工作

在调用微信接口获取AccessToken时，需要使用到微信公众号的appid及secret，获取方式如下：

• 已有公众号： 有属于自己的公众号账户，登录微信公众平台(https://mp.weixin.qq.com)，在左侧菜单栏下方的设置与开发中的基本配置菜单中即可获取；
  
  

• 测试公众号： 如果没有现成的公众号账户，或者只是测试公众号功能，可从微信提供的沙箱测试环境(http://mp.weixin.qq.com/debug/cgi-bin/sandboxinfo)中获取appid及secret；
  

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

1、公众平台接口调试示例

示例地址：https://mp.weixin.qq.com/debug/cgi-bin/apiinfo

2、Java代码实现

1、配置Yaml

wx:
  appid: wx79xxxxxxxx11b9
  secret: 1c79a1xxxxxxxxxxxxxx2a73a08
  apiUrl: https://api.weixin.qq.com/

2、配置参数Bean对象

@Component
@ConfigurationProperties(prefix = "wx")
@Data
public class WxBean {
    private String appid;
    private String secret;
    private String apiUrl;
}

3、封装请求与响应参数

AccessTokenRep:

@Data
public class AccessTokenRep {
    /**
     * 获取access_token填写client_credential
     */
    private String grant_type;

    /**
     * 第三方用户唯一凭证
     */
    private String appid;

    /**
     * 第三方用户唯一凭证密钥，即appsecret
     */
    private String secret;
}

AccessTokenRes:

@Data 
public class AccessTokenRes {
    /**
     * 获取到的凭证
     */
    private String access_token;

    /**
     * 凭证有效时间，单位：秒
     */
    private Integer expires_in;
}

4、配置工具类

public class MapUtils {

    /**
     * Map转换为 Entity
     *
     * @param params 包含参数的Map
     * @param t      需要赋值的实体
     * @param <T>    类型
     */
    public static <T> T mapToEntity(Map<String, Object> params, T t) {
        if (null == params) {
            return t;
        }
        Class<?> clazz = t.getClass();
        Field[] declaredFields = clazz.getDeclaredFields();
        try {
            for (Field declaredField : declaredFields) {
                declaredField.setAccessible(true);
                String name = declaredField.getName();
                if (null != params.get(name)) {
                    declaredField.set(t, params.get(name));
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("属性设置失败！");
        }
        return t;
    }

    /**
     * 将对象转换为HashMap
     *
     * @param t   转换为Map的对象
     * @param <T> 转换为Map的类
     * @return Map
     */
    public static <T> Map<String, Object> entityToMap(T t) {
        Class<?> clazz = t.getClass();
        List<Field> allField = getAllField(clazz);
        Map<String, Object> hashMap = new HashMap<>(allField.size());
        try {
            for (Field declaredField : allField) {
                declaredField.setAccessible(true);
                Object o = declaredField.get(t);
                if (null != o) {
                    hashMap.put(declaredField.getName(), o);
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("属性获取失败！");
        }
        return hashMap;
    }

    /**
     * 获取所有属性
     *
     * @param clazz class
     * @param <T>   泛型
     * @return List<Field>
     */
    public static <T> List<Field> getAllField(Class<T> clazz) {
        List<Field> fields = new ArrayList<>();
        Class<?> superClazz = clazz;
        while (null != superClazz) {
            fields.addAll(Arrays.asList(superClazz.getDeclaredFields()));
            superClazz = superClazz.getSuperclass();
        }
        return fields;
    }

    /**
     * 将Map参数转换为字符串
     *
     * @param map
     * @return
     */
    public static String mapToString(Map<String, Object> map) {
        StringBuffer sb = new StringBuffer();
        map.forEach((key, value) -> {
            sb.append(key).append("=").append(value.toString()).append("&");
        });
        String str = sb.toString();
        str = str.substring(0, str.length() - 1);
        return str;
    }

    /**
     * 将Bean对象转换Url请求的字符串
     *
     * @param t
     * @param <T>
     * @return
     */
    public static <T> String getUrlByBean(T t) {
        String pre = "?";
        Map<String, Object> map = entityToMap(t);
        return pre + mapToString(map);
    }
}

5、配置RestTemplate请求

@Component
public class RestHttpRequest {

    private final RestTemplate restTemplate;

    public RestHttpRequest(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public Map doHttp(String url, HttpMethod method, Object obj) {
        HttpHeaders headers = new HttpHeaders();
        HttpEntity entity = new HttpEntity(obj, headers);
        ResponseEntity<Map> exchange = restTemplate.exchange(url, method, entity, Map.class);
        return exchange.getBody();
    }
}

6、请求示例

代码中为了避免频繁的请求，将获取的accessToken存入Redis中，如果Redis中存在数据，则直接从Redis中获取而不是请求微信接口获取。

@Slf4j
@Controller
@ResponseBody
public class WeChantController {
    @GetMapping("/accessToken")
    public String getAccessToken() {
        String accessTokenKey = "access_token";
        log.info("#### 获取公众号 AccessToken ####");
        RedisUtils.del(accessTokenKey);
        if (RedisUtils.hasKey(accessTokenKey)) {
            log.info("#### 从缓存中获取AccessToken ####");
            return RedisUtils.get(accessTokenKey).toString();
        }
        String url = wxBean.getApiUrl() + "cgi-bin/token";
        //封装url请求参数
        AccessTokenRep rep = new AccessTokenRep();
        rep.setAppid(wxBean.getAppid());
        rep.setSecret(wxBean.getSecret());
        rep.setGrant_type("client_credential");
        url = url + MapUtils.getUrlByBean(rep);
        Map map = restHttpRequest.doHttp(url, HttpMethod.GET, null);
        // 处理返回对象
        AccessTokenRes res = new AccessTokenRes();
        MapUtils.mapToEntity(map, res);
        // 加入Redis缓存
        String accessToken = res.getAccess_token();
        Integer expires = res.getExpires_in();
        RedisUtils.setEx(accessTokenKey, accessToken, expires / 2, TimeUnit.SECONDS);
        // 返回
        return accessToken;
    }
}