AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

企微获客链接 中文乱码问题处理

2024-06-06 154
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【6月更文挑战第6天】企微获客链接 中文乱码问题处理

问题背景

为了推广产品，同时更好的服务客户，公司在接入企业微信后，需要用到企微获客链接相关推广操作，那么通过API 接口创建企微获客链接时，出现了中文乱码问题，比如

{"errcode":0,"errmsg":"ok","link":{"link_id":"ca8e631dfgsdg3858","link_name":"??????","url":"https://work.weixin.qq.com/ca/ca8e631dfgsdg3858","create_time":1717569991}}

而实际在通过 API 接口创建企微获客链接传入的 获客链接名称 link_name : "测试获客链接"

image.png

那么对于这样的问题如何处理呢？

问题处理

对于这种中文乱码的问题，一般来说通常可以通过设置请求头内容类型的方式来解决，那么首先查阅一下企业微信创建企微获客链接的 API 接口文档：https://developer.work.weixin.qq.com/document/path/97297#%E5%88%9B%E5%BB%BA%E8%8E%B7%E5%AE%A2%E9%93%BE%E6%8E%A5

image.png

接口文档中关于链接名称 link_name 并没有特殊的说明，那么我们只能基于以往经验通过设置请求头来进行尝试，为创建企微获客链接 的代码增加请求头信息

HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);

image.png

再次创建企微获客链接 可以看到正确返回了 中文名称的 企微获客链接

{"errcode":0,"errmsg":"ok","link":{"link_id":"cawcde5dbdafdfdaf98baf","link_name":"测试获客链接","url":"https://work.weixin.qq.com/ca/cawcde5dbdafdfdaf98baf","create_time":1717571008}}

那么到这里关于企微创建获客链接时 link_name 中文乱码的情况就解决了 。

补充内容

这里为了方便大家测试企微获客链接的 API 接口，我补充一下测试类相关代码，这样大家可以节省开发时间，测试类代码 WeChatTest.java 

package com.ruoyi.web.controller.common;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.utils.StringUtils;
import org.junit.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;

import java.util.*;

/**
 * @Description com.dongao.test
 * @Author P001
 * @Date 2022/11/1 14:38
 * @Version 1.0
 */
public class WeChatTest {

    private String accessToken;
    //企业微信的 企业id
    private final String wechatAppId = "你的企业id";
    //企业微信自建应用的 Secret
    private final String wechatSecret = "你的企业自建应用的Secret";
    /**
     * 获取accesstocken-自建应用 权限较小
     * @return
     */
    public void getAccessToken () {
        String url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid="+ wechatAppId+"&corpsecret="+wechatSecret;
        ResponseEntity<String> get = RestUtils.get(url, String.class);
        if (Objects.nonNull(get)) {
            String body = get.getBody();
            WeChatGettokenResponse res = JSON.parseObject(body, WeChatGettokenResponse.class);
            accessToken = res.getAccessToken();
        }
    }

    //创建企微获客链接   https://developer.work.weixin.qq.com/document/path/97297
    @Test
    public void createLink() {
        //获取accesstoken
        if (StringUtils.isEmpty(accessToken)) {
            getAccessToken();
        }
        if (StringUtils.isNotEmpty(accessToken)) {
            //组装参数
            JSONObject json = new JSONObject();
            json.put("link_name","测试获客链接");
            JSONObject range = new JSONObject();
            List<String> list = new ArrayList<String>();
            list.add("AoLiNa");
            range.put("user_list",list);
            json.put("range",range);
            json.put("skip_verify",false);
            String param = JSON.toJSONString(json);

            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);

            String url = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/customer_acquisition/create_link?access_token="+accessToken;
            ResponseEntity<String> post = RestUtils.post(url,httpHeaders,param,String.class);
            if (Objects.nonNull(post)) {
                String body = post.getBody();
                System.out.println(body);
            }
        }
    }

    //编辑企微获客链接   https://developer.work.weixin.qq.com/document/path/97297
    @Test
    public void updateLink() {
        //获取accesstoken
        if (StringUtils.isEmpty(accessToken)) {
            getAccessToken();
        }
        if (StringUtils.isNotEmpty(accessToken)) {
            //组装参数
            JSONObject json = new JSONObject();
            json.put("link_id","cawcde8e631eae3858");
            json.put("link_name","test2024");
            String param = JSON.toJSONString(json);

            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);

            String url = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/customer_acquisition/update_link?access_token="+accessToken;
            ResponseEntity<String> post = RestUtils.post(url,httpHeaders,param,String.class);
            if (Objects.nonNull(post)) {
                String body = post.getBody();
                System.out.println(body);
            }
        }
    }

    //获取企微获客链接   https://developer.work.weixin.qq.com/document/path/97297
    @Test
    public void getLinkList() {
        //获取accesstoken
        if (StringUtils.isEmpty(accessToken)) {
            getAccessToken();
        }
        if (StringUtils.isNotEmpty(accessToken)) {
            //组装参数
            JSONObject json = new JSONObject();
            /*json.put("limit",100);
            json.put("cursor","");*/
            String param = JSON.toJSONString(json);

            String url = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/customer_acquisition/list_link?access_token="+accessToken;
            ResponseEntity<String> post = RestUtils.post(url,param,String.class);
            if (Objects.nonNull(post)) {
                String body = post.getBody();
                System.out.println(body);
            }
        }
    }

    //获取企微获客链接详情   https://developer.work.weixin.qq.com/document/path/97297
    @Test
    public void getLinkDetailList() {
        //获取accesstoken
        if (StringUtils.isEmpty(accessToken)) {
            getAccessToken();
        }
        if (StringUtils.isNotEmpty(accessToken)) {
            //组装参数
            JSONObject json = new JSONObject();
            json.put("link_id","cawcde5db087898baf");
            String param = JSON.toJSONString(json);

            String url = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/customer_acquisition/get?access_token="+accessToken;
            ResponseEntity<String> post = RestUtils.post(url,param,String.class);
            if (Objects.nonNull(post)) {
                String body = post.getBody();
                System.out.println(body);
            }
        }
    }

    //删除企微获客链接
    @Test
    public void deleteLink() {
        //获取accesstoken
        if (StringUtils.isEmpty(accessToken)) {
            getAccessToken();
        }
        if (StringUtils.isNotEmpty(accessToken)) {
            //组装参数
            JSONObject json = new JSONObject();
            json.put("link_id","cawcde5db087898baf");
            String param = JSON.toJSONString(json);

            String url = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/customer_acquisition/delete_link?access_token="+accessToken;
            ResponseEntity<String> post = RestUtils.post(url,param,String.class);
            if (Objects.nonNull(post)) {
                String body = post.getBody();
                System.out.println(body);
            }
        }
    }

    //查询企微获客链接 剩余使用量
    @Test
    public void customerAcquisitionQuota() {
        //获取accesstoken
        if (StringUtils.isEmpty(accessToken)) {
            getAccessToken();
        }
        if (StringUtils.isNotEmpty(accessToken)) {
            String url = "https://qyapi.weixin.qq.com/cgi-bin/externalcontact/customer_acquisition_quota?access_token="+accessToken;
            ResponseEntity<String> post = RestUtils.post(url,String.class);
            if (Objects.nonNull(post)) {
                String body = post.getBody();
                System.out.println(body);
            }
        }
    }
}

这里需要用到一个接收企业微信 access_token 的实体类，WeChatGettokenResponse.java 用于接收获取到的 企业微信 access_token ，

package com.ruoyi.web.controller.common;

import com.taobao.api.internal.mapping.ApiField;

/**
 * @Description com.dongao.project.common.wechat
 * @Author P001
 * @Date 2022/10/27 17:20
 * @Version 1.0
 */
public class WeChatGettokenResponse extends WeChatResponse {
    private static final long serialVersionUID = 9059923845826321694L;
    @ApiField("access_token")
    private String accessToken;
    @ApiField("expires_in")
    private Long expiresIn;

    public String getAccessToken() {
        return accessToken;
    }

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public Long getExpiresIn() {
        return expiresIn;
    }

    public void setExpiresIn(Long expiresIn) {
        this.expiresIn = expiresIn;
    }
}

其中需要用到实体类 WeChatResponse.java  ，该实体类主要是接收企业微信请求返回的 code 码 以及 msg 信息等

package com.ruoyi.web.controller.common;

import com.taobao.api.internal.mapping.ApiField;

import java.io.Serializable;

/**
 * @Description com.dongao.project.common.wechat.response
 * @Author P001
 * @Date 2022/11/3 13:41
 * @Version 1.0
 */
public class WeChatResponse implements Serializable {
    private static final long serialVersionUID = 2109769518803249524L;
    @ApiField("errcode")
    private Long errcode;
    @ApiField("errmsg")
    private String errmsg;

    public Long getErrcode() {
        return errcode;
    }

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

    public String getErrmsg() {
        return errmsg;
    }

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

最后补充的是在获取企业微信获客链接相关信息时，需要用到的Rest请求工具类，具体的 RestUtils.java 工具类代码如下

package com.ruoyi.web.controller.common;

import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.http.client.BufferingClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.util.Collections;
import java.util.Map;
import java.util.Objects;

/**
 * @description:  RestUtils 远程调用工具类
 * @date: 2019/7/19 20:45
 * @author: dongao
 */
public class RestUtils {

    private static final RestTemplate TEMPLATE = new RestTemplate();
    private static final int CONNECT_TIMEOUT = 10 * 1000;
    private static final int READ_TIMEOUT = 10 * 1000;

    /**
     * 记录请求日志
     */
    static {
        // BufferingClientHttpRequestFactory因为我们要在拦截器和初始调用代码中都使用响应主体，所以这是必需的。默认实现只允许读取一次响应主体。 默认该流不可重复读
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        // 2022-03-10 设置统一超时时间
        requestFactory.setConnectTimeout(CONNECT_TIMEOUT);
        requestFactory.setReadTimeout(READ_TIMEOUT);
        TEMPLATE.setRequestFactory(new BufferingClientHttpRequestFactory(requestFactory));
    }

    // ----------------------------------GET-------------------------------------------------------

    /**
     * GET请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Class<T> responseType) {
        return TEMPLATE.getForEntity(url, responseType);
    }

    /**
     * GET请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) {
        return TEMPLATE.getForEntity(url, responseType, uriVariables);
    }

    /**
     * GET请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) {
        return TEMPLATE.getForEntity(url, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return get(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
        HttpEntity<?> requestEntity = new HttpEntity<>(headers);
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return get(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的GET请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<?> requestEntity = new HttpEntity<>(headers);
        return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义泛型返回GET请求调用方式
     *
     * @param url 请求URL
     * @param responseBodyType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, ParameterizedTypeReference<T> responseBodyType) {
        return exchange(url, HttpMethod.GET, HttpEntity.EMPTY, responseBodyType);
    }

    /**
     * 自定义泛型返回GET请求调用方式
     *
     * @param url 请求URL
     * @param responseBodyType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, ParameterizedTypeReference<T> responseBodyType, Object... uriVariables) {
        HttpHeaders headers = new HttpHeaders();
        //设置请求格式
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        //设置响应格式
        HttpEntity entity = new HttpEntity(headers);
        return exchange(url, HttpMethod.GET, entity, responseBodyType, uriVariables);
    }

    /**
     * 自定义泛型返回GET请求调用方式
     *
     * @param url 请求URL
     * @param responseBodyType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> get(String url, ParameterizedTypeReference<T> responseBodyType,  Map<String, ?> uriVariables) {
        return exchange(url, HttpMethod.GET, HttpEntity.EMPTY, responseBodyType, uriVariables);
    }

    /**
     * get queryString
     *
     * @param url
     * @param formData
     * @param responseType
     * @param <T>
     * @return
     */
    public static <T> ResponseEntity<T> getQueryString(String url, Map<String, ?> formData, Class<T> responseType) {
        StringBuilder queryString = new StringBuilder();
        for (Map.Entry<String, ?> entry : formData.entrySet()) {
            queryString.append("&").append(entry.getKey()).append("=");
            Object value = entry.getValue();
            if ( Objects.nonNull(value) ) {
                queryString.append(value);
            }
        }
        if ( queryString.length() > 0 ) {
            url = url.concat("?").concat(queryString.substring(1));
        }
        return get(url, responseType);
    }


    // ----------------------------------POST-------------------------------------------------------

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @return
     */
    public static <T> ResponseEntity<T> post(String url, Class<T> responseType) {
        return TEMPLATE.postForEntity(url, HttpEntity.EMPTY, responseType);
    }

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) {
        return TEMPLATE.postForEntity(url, requestBody, responseType);
    }

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
        return TEMPLATE.postForEntity(url, requestBody, responseType, uriVariables);
    }

    /**
     * POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        return TEMPLATE.postForEntity(url, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return post(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return post(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return post(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的POST请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return post(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return TEMPLATE.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的POST请求调用方式
     * 
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return TEMPLATE.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义泛型返回POST请求调用方式
     *
     * @param url 请求URL
     * @param responseBodyType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, ParameterizedTypeReference<T> responseBodyType) {
        return exchange(url, HttpMethod.POST, null, responseBodyType);
    }

    /**
     * 自定义泛型返回POST请求调用方式
     *
     * @param url 请求URL
     * @param responseBodyType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, ParameterizedTypeReference<T> responseBodyType, Object... uriVariables) {
        return exchange(url, HttpMethod.POST, null, responseBodyType, uriVariables);
    }

    /**
     * 自定义泛型返回POST请求调用方式
     *
     * @param url 请求URL
     * @param responseBodyType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> post(String url, ParameterizedTypeReference<T> responseBodyType,  Map<String, ?> uriVariables) {
        return exchange(url, HttpMethod.POST, null, responseBodyType, uriVariables);
    }

    /**
     * post form-data
     *
     * @param url
     * @param formData
     * @param responseType
     * @param <T>
     * @return
     */
    public static <T> ResponseEntity<T> postFormData(String url, Map<String, String> formData, Class<T> responseType) {
        MultiValueMap<String,String> multiFormMap = new LinkedMultiValueMap<>();
        for (Map.Entry<String, String> entry : formData.entrySet()) {
            multiFormMap.put(entry.getKey(), Collections.singletonList(entry.getValue()));
        }
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        HttpEntity<MultiValueMap<String, String>> httpEntity = new HttpEntity<>(multiFormMap, headers);
        return post(url, httpEntity, responseType);
    }

    // ----------------------------------PUT-------------------------------------------------------

    /**
     * PUT请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) {
        return put(url, HttpEntity.EMPTY, responseType, uriVariables);
    }

    /**
     * PUT请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * PUT请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return put(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return put(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的PUT请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return put(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的PUT请求调用方式
     * 
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return TEMPLATE.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的PUT请求调用方式
     * 
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return TEMPLATE.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------DELETE-------------------------------------------------------

    /**
     * DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) {
        return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
    }

    /**
     * DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) {
        return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
    }

    /**
     * DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setAll(headers);
        return delete(url, httpHeaders, requestBody, responseType, uriVariables);
    }

    /**
     * 带请求头的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param headers 请求头参数
     * @param requestBody 请求参数体
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
        HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
        return delete(url, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return TEMPLATE.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
    }

    /**
     * 自定义请求头和请求体的DELETE请求调用方式
     * 
     * @param url 请求URL
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return TEMPLATE.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
    }

    // ----------------------------------通用方法-------------------------------------------------------

    /**
     * 通用调用方式
     * 
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，按顺序依次对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
        return TEMPLATE.exchange(url, method, requestEntity, responseType, uriVariables);
    }

    /**
     * 通用调用方式
     * 
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseType 返回对象类型
     * @param uriVariables URL中的变量，与Map中的key对应
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
        return TEMPLATE.exchange(url, method, requestEntity, responseType, uriVariables);
    }

    /**
     * 通用调用方式
     *
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseBodyType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseBodyType){
        return TEMPLATE.exchange(url, method, requestEntity, responseBodyType);
    }


    /**
     * 通用调用方式
     *
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseBodyType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseBodyType, Object... uriVariables){
        return TEMPLATE.exchange(url, method, requestEntity, responseBodyType, uriVariables);
    }

    /**
     * 通用调用方式
     *
     * @param url 请求URL
     * @param method 请求方法类型
     * @param requestEntity 请求头和请求体封装对象
     * @param responseBodyType 返回对象类型
     * @return ResponseEntity 响应对象封装类
     */
    public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseBodyType, Map<String, ?> uriVariables){
        return TEMPLATE.exchange(url, method, requestEntity, responseBodyType, uriVariables);
    }

    /**
     * 获取RestTemplate实例对象，可自由调用其方法
     * 
     * @return RestTemplate实例对象
     */
    public static RestTemplate getRestTemplate() {
        return TEMPLATE;
    }

    /**
     * 校验请求是否是200
     *
     * @param responseEntity
     * @return
     */
    public static boolean reqSuccess(ResponseEntity<?> responseEntity){
        return HttpStatus.OK.equals(responseEntity.getStatusCode());
    }

    /**
     * 校验请求是否是200
     *
     * @param responseEntity
     * @return
     */
    public static boolean req2xx(ResponseEntity<?> responseEntity){
        if ( null == responseEntity || null == responseEntity.getStatusCode() ) {
            return false;
        }
        return responseEntity.getStatusCode().is2xxSuccessful();
    }

}

到这里，关于企微创建获客链接时 link_name 中文乱码的情况就处理完了，后续其实如果有关于调用企微相关 API

文章标签：
API
网络架构
六月的雨在钉钉
目录
相关文章
联营汇聚
|
搜索推荐 数据挖掘
伙伴云「页面」上线！网站、博客、资源库、文档、周报，拖拽即刻实现
一年来，伙伴云收到了许多用户对于仪表盘升级的期待，以及对新功能规划的询问。经过千百次调研、开发、内测，我们开发了一款页面构建引擎，Ta既提供了灵活的可定制性，也不像网页设计器晦涩难懂，且具有丰富的数据展现能力。
联营汇聚
172 0
草料二维码
|
28天前
|
小程序 vr&ar 数据安全/隐私保护
草料二维码｜产品推广新利器，让客户快速获取最新产品信息
在数字化时代，信息的快速传递和便捷获取已成为商业竞争的关键。二维码，作为一种新兴的信息载体，正以其独特的优势在产品推广和客户服务中扮演着越来越重要的角色。本文为大家介绍了草料二维码的产品详情介绍模板，轻松搭建产品二维码。
草料二维码
50 3
天落色
|
存储 监控 数据挖掘
企业微信开发（一）：企业微信的开通及调研
企业微信的开通及调研
天落色
315 0
企业微信开发（一）：企业微信的开通及调研
草料二维码
|
3月前
|
存储 数据采集 监控
草料用户案例｜巧用二维码，班组管理信息化
实施二维码巡检技术之后，巡检人员只需用手机扫描企业现场设置的二维码标签，便能迅速获取相关设备巡检标准信息，实时更新、查询相关数据，上传视频和照片等，开展精准和高效的巡检工作。
草料二维码
47 0
py3284
|
4月前
|
JavaScript 前端开发 UED
扫码登录全过程
扫码登录全过程
py3284
73 2
Ar.小白
|
JSON 小程序 开发者
微信小程序--数字化会议OA系统之首页搭建
微信小程序--数字化会议OA系统之首页搭建
Ar.小白
92 0
全栈技术精选
|
存储 前端开发 数据库
美多商城前三天重点内容大盘点
美多商城前三天重点内容大盘点
全栈技术精选
57 0
叫个什么名字
|
7月前
宜搭直接链接跳转至特定人员钉钉的聊天窗口
宜搭直接链接跳转至特定人员钉钉的聊天窗口
叫个什么名字
321 3
草料二维码
|
7月前
|
数据可视化 BI API
无纸化登记二维码应用方案：扫码填写表单，信息收集无纸化
日常生活中的申请表、签到表、报名表等纸质表格，收集到的信息常常不规范，可以搭建用于信息收集的二维码应用，通过扫码填写电子表单的方式，实现核销、业务申请、内部审批等场景的无纸化登记，并能将填写的信息导出为Excel表格存档。
草料二维码
203 0
草料二维码
|
7月前
|
供应链 数据可视化 小程序
搭建二维码系统，轻松实现固定资产的一物一码管理
固定资产管理中普遍存在盘点难、家底不清、账实不一致、权责不清晰等问题，可以在草料上搭建固定资产管理系统，通过组合功能模块实现资产信息展示、领用登记、出入库管理、故障报修等功能，对固定资产进行一物一码规范化管理。
草料二维码
213 0

热门文章

最新文章

  • 1
    使用MaxCompute访问TableStore（OTS） 简明手册
  • 2
    从超模转职成为程序媛是一种怎样的体验
  • 3
    阿里巴巴NACOS（6）- 在k8s上部署Nacos
  • 4
    将任意应用窗口置顶显示，这个工具太强了。
  • 5
    Wi-Fi物联网设备配网的N种方式
  • 6
    WCF分布式安全开发实践(8):消息安全模式之用户名身份验证:Message_UserName_WSHttpBinding
  • 7
    TechED2010与我（二）—— Windows Phone 7 Develop
  • 8
    华尔街认为Twitter出售毫无悬念 只是不会在今年发生
  • 9
    迂者趣事之——下错楼层
  • 10
    Unix Regex
  • 1
    检测指定TCP端口开放状态免费API接口教程
    23
  • 2
    Python 语言：强大、灵活与高效的编程之选
    31
  • 3
    发现一肉鸡接口，快来围攻啦~
    30
  • 4
    深入解析PID控制算法：从理论到实践的完整指南
    32
  • 5
    《C++ 模型训练之早停法：有效预防过拟合的关键策略》
    25
  • 6
    C++构建 GAN 模型：生成器与判别器平衡训练的关键秘籍
    22
  • 7
    通过matlab分别对比PSO,反向学习PSO,多策略改进反向学习PSO三种优化算法
    25
  • 8
    【C语言】宏定义详解
    23
  • 9
    【C语言】进程和线程详解
    18
  • 10
    【C语言】宏定义详解
    23

    • 相关课程

    更多
  • 云上建站快速入门-博客、论坛、CMS、电子商务网站统统搞定

    • 相关电子书

    更多
  • 直达客户 贴身服务——通信在快递场景中的应用
  • 钉钉工作台，从了解价值到学会开发
  • 文娱在线票务

    • 相关实验场景

    更多
  • 收银台的场景化界面实践
  • 网站用户流量分析—适用于电商网站、资讯网站、游戏主站等各类Web站点场景
  • 小试牛刀，一键部署电商商城
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月