java 通过企业微信推送消息

其他 2018-09-18 14:09:12 阅读次数: 0

首先我们要知道企业微信推送消息的步骤，企业微信官方提供了多个API供我们调用，这里我们只讲我们需要的API；

企业微信的官方开放的API地址：https://work.weixin.qq.com/api/doc

推送企业微信消息分为这么几步：

1、建立一个企业应用，我们只能给应用里面的成员发送消息，企业应用就是类似下面的应用；

2、获取accss_token，这是通过企业微信的获取token的接口获取的

请求方式：GET（HTTPS）
请求URL：https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=ID&corpsecret=SECRECT

参数解释：

corpid：企业id，每个企业微信都有唯一的一个corpid；

corpsecret：应用的凭证密钥，这个是你要发送消息给应用下的成员的corpsecret

返回值：

expires_in是有效时间，单位是秒

{
   "errcode":0，
   "errmsg":""，
   "access_token": "accesstoken000001",
   "expires_in": 7200
}

3、获取到access_token以后，你就可以向应用的成员推送企业微信消息了（这里我们以最简单的发送text为例子，其它的发送图片等消息大同小异，大家可以自己查看官方文档）；

推送消息的接口：

请求方式：POST（HTTPS）
请求地址： https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=ACCESS_TOKEN

请求示例：

{
   "touser" : "UserID1|UserID2|UserID3",//企业微信的唯一userid，非必输
   "toparty" : "PartyID1|PartyID2",//部门id，非必输，如果输入了就只给指定部门发送消息
   "totag" : "TagID1 | TagID2",//标签，非必输，传输了就只给指定的标签发送消息
   "msgtype" : "text",//消息类型，必输，text等
   "agentid" : 1,//应用id，必输，每个应用都有一个唯一的应用id
   "text" : {
       "content" : "你的快递已到，请携带工卡前往邮件中心领取。\n出发前可查看<a href=\"http://work.weixin.qq.com\">邮件中心视频实况</a>，聪明避开排队。"
   },//发送的消息
   "safe":0//是否安全传输
}

参数说明：

参数 是否必须 说明
touser 否 成员ID列表（消息接收者，多个接收者用‘|’分隔，最多支持1000个）。特殊情况：指定为@all，则向该企业应用的全部成员发送
toparty 否 部门ID列表，多个接收者用‘|’分隔，最多支持100个。当touser为@all时忽略本参数
totag 否 标签ID列表，多个接收者用‘|’分隔，最多支持100个。当touser为@all时忽略本参数
msgtype 是 消息类型，此时固定为：text
agentid 是 企业应用的id，整型。可在应用的设置页面查看
content 是 消息内容，最长不超过2048个字节
safe 否 表示是否是保密消息，0表示否，1表示是，默认0

返回示例：

 {
   "errcode" : 0,
   "errmsg" : "ok",
   "invaliduser" : "userid1|userid2", // 不区分大小写，返回的列表都统一转为小写
   "invalidparty" : "partyid1|partyid2",
   "invalidtag":"tagid1|tagid2"
 }

如果部分接收人无权限或不存在，发送仍然执行，但会返回无效的部分（即invaliduser或invalidparty或invalidtag），常见的原因是接收人不在应用的可见范围内。

注：企业微信推送消息的步骤就这么几步，很简单，用户也可以根据自己的实际需求参考企业微信的api实现更多的功能，着咯就不再赘述，接下来我们看看代码的实现：

基础消息类：

package company.sendmessage;


import lombok.Data;

/**
 * 消息基类（企业号 -> 普通用户）
 * @author csh10609
 *
 */

@Data
public class BaseMessage {
    // 否 成员ID列表（消息接收者，多个接收者用‘|’分隔，最多支持1000个）。特殊情况：指定为@all，则向该企业应用的全部成员发送
    private String touser;
    // 否 部门ID列表，多个接收者用‘|’分隔，最多支持100个。当touser为@all时忽略本参数
    private String toparty;
    // 否 标签ID列表，多个接收者用‘|’分隔，最多支持100个。当touser为@all时忽略本参数
    private String totag;
    // 是 消息类型
    private String msgtype;
    // 是 企业应用的id，整型。可在应用的设置页面查看
    private Integer agentid;
}

推送消息类：

/**
 * 文本消息
 * @author csh10609
 *
 */

@Data
public class TextMessage extends BaseMessage {
    //文本
    private Text text;
    //否     表示是否是保密消息，0表示否，1表示是，默认0
    private int safe;


}

具体要发送的消息：

/**
 * 文本
 * @author csh10609
 *
 */

@Data
public class Text {
    //是    消息内容，最长不超过2048个字节
    private String content;

}

接收accesstoken类：

/**
 * @desc  : 微信通用接口凭证 
 * 
 * @author: csh10609
 * @date  : 2018-8-17 下午9:35:11
 */
public class AccessToken {  
    // 获取到的凭证  
    private String token;  
    // 凭证有效时间，单位：秒  
    private int expiresIn;  
  
    public String getToken() {  
        return token;  
    }  
  
    public void setToken(String token) {  
        this.token = token;  
    }  
  
    public int getExpiresIn() {  
        return expiresIn;  
    }  
  
    public void setExpiresIn(int expiresIn) {  
        this.expiresIn = expiresIn;  
    }  
}

异常处理类：

import lombok.Data;

@Data
public class BizException extends RuntimeException {

    private int code;

    private String msg;

    private EnumsUtils enumsUtils;

    public BizException(EnumsUtils enumsUtils) {
        this.enumsUtils = enumsUtils;
    }

    public BizException(int code, String msg){
        this.code = code;
        this.msg = msg;
    }

}

异常枚举类：

import lombok.Getter;

@Getter
public enum EnumsUtils {

    FAIL(000, "操作失败"),
    SUCCESS(100, "操作成功"),
    BASEMESSAGE_ISEMPTY(110, "基础信息不能为null"),
    MSGTYPE_ISEMPTY(120, "发送消息类型不能为空"),
    WEIXINPARAMES_ISEMPTY(130, "微信参数不能为null"),
    AGENTID_ISEMPTY(131, "应用ID不能为空"),
    CORPID_ISEMPTY(132, "企业ID不能为空"),
    AGENTSECRET_ISEMPTY(133, "应用密钥不能为空"),
    WEIXIN_CONNECT_FAILED(134, "请求微信接口失败"),
    WEIXIN_HAPPEN_EXCEPTION(135, "请求微信接口发生未知错误"),
    APPLY_TOKEN_FAILED(136, "请求应用token发生未知错误"),
    SENDMESSAGE_FAILED(137, "发送企业微信消息失败"),
    SENDMAIL_PARAM_ISEMPTY(138, "发送Email基础参数不能为空"),
    SENDMAIL_FROM_ISEMPTY(139, "Email邮件发送人不能为空"),
    SENDMAIL_TO_ISEMPTY(140, "Email邮件收件人不能为空"),
    SENDMAIL_MESSAGING_EXCEPTION(141, "Email邮件发送缺少发送类");

    private int code;

    private String msg;

    EnumsUtils(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }


}

参数检验类：

/**
 * 校验参数的工具类
 *
 * @Author csh10609
 * @date 2018-08-17
 */

public class CheckParamsUtil {

    /**
     * 校验基本参数BaseMessage
     *
     * @param message
     */
    public static void checkBaseMessage(RequestMessage message) {
        //baseMessage不能为空
        if (null == message) {
            throw new BizException(EnumsUtils.BASEMESSAGE_ISEMPTY);
        }
        if (StringUtils.isEmpty(message.getMsgtype())) {
            throw new BizException(EnumsUtils.MSGTYPE_ISEMPTY);
        }
        if (null == message.getAgentid()) {
            throw new BizException(EnumsUtils.AGENTID_ISEMPTY);
        }
    }


    /**
     * 校验基本参数WeiXinParames
     *
     * @param weiXinParames
     */
    public static void checkWeiXinParames(WeiXinParames weiXinParames) {
        if (null == weiXinParames) {
            throw new BizException(EnumsUtils.WEIXINPARAMES_ISEMPTY);
        }
        if (StringUtils.isEmpty(weiXinParames.getCorpId())) {
            throw new BizException(EnumsUtils.CORPID_ISEMPTY);
        }
        if (StringUtils.isEmpty(weiXinParames.getAgentSecret())) {
            throw new BizException(EnumsUtils.AGENTSECRET_ISEMPTY);
        }
    }

    /*
     * 检查参数
     * @param entity
     */
    public static void checkMailParam(SendMailUtils.EmailEntity entity) {
        if (null == entity) {
            throw new BizException(EnumsUtils.SENDMAIL_PARAM_ISEMPTY);
        }
        //发件人不能为空
        if (org.springframework.util.StringUtils.isEmpty(entity.getFrom())) {
            throw new BizException(EnumsUtils.SENDMAIL_FROM_ISEMPTY);
        }
        //收件人不能为空
        if (CollectionUtils.isEmpty(entity.getTo())) {
            throw new BizException(EnumsUtils.SENDMAIL_TO_ISEMPTY);
        }
    }
}

证书信任器：

/** 
 * 证书信任管理器（用于https请求） 
 *  
 * @author csh10609
 * @date 2018-08-17
 */  
public class MyX509TrustManager implements X509TrustManager {  
  
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
    }  
  
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
    }  
  
    public X509Certificate[] getAcceptedIssuers() {  
        return null;  
    }  
}

我们提供别人的发送消息的接口接收参数：

/**
 * 消息基类（企业号 -> 普通用户）
 * @author csh10609
 *
 */

@Data
public class RequestMessage {
    // 否 成员ID列表
    private List<String> touser;
    // 否 部门ID列表
    private List<String> toparty;
    // 否 标签ID列表
    private List<String> totag;
    // 是 消息类型
    private String msgtype;
    // 是 企业应用的id，整型。可在应用的设置页面查看
    private Integer agentid;
    //文本
    private Text text;
    //否     表示是否是保密消息，0表示否，1表示是，默认0
    private int safe;
}

接口返回参数：

package company.sendmessage;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;


@Setter
@Getter
@ToString
@NoArgsConstructor
public class ResultJson<T> implements Serializable {

    /**
     * 返回编码
     */
    private int code;

    /**
     * 返回消息
     */
    private String msg;

    /**
     * 返回数据
     */
    private T data;


    public ResultJson(T date) {
        this.data = date;
    }

    public ResultJson(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public ResultJson(int code, T data) {
        this.code = code;
        this.data = data;
    }

    public ResultJson(String msg, T data) {
        this.msg = msg;
        this.data = data;
    }

    public ResultJson(EnumsUtils enumsUtils, T data) {
        this.code = enumsUtils.getCode();
        this.msg = enumsUtils.getMsg();
        this.data = data;
    }

    public ResultJson(EnumsUtils enumsUtils) {
        this.code = enumsUtils.getCode();
        this.msg = enumsUtils.getMsg();
    }
}

发送消息的service：

package company.sendmessage;


import com.google.gson.Gson;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @desc : 发送消息
 * @author: csh10609
 * @date : 2018-8-17 上午10:06:23
 */
public class SendMessageService {

    private static Logger log = LoggerFactory.getLogger(SendMessageService.class);

    private static String sendMessage_url = "https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=ACCESS_TOKEN";

    /**
     * @param accessToken
     * @param message     void
     * @desc ：0.公共方法：发送消息
     */
    public void sendMessage(String accessToken, BaseMessage message, WeiXinParames weiXinParames, int cycleSize) {
        //重试5次，超过五次直接失败
        cycleSize++;
        if(cycleSize > 5){
            throw new BizException(EnumsUtils.SENDMESSAGE_FAILED);
        }
        //1.获取json字符串：将message对象转换为json字符串
        Gson gson = new Gson();
        String jsonMessage = gson.toJson(message);      //使用gson.toJson(user)即可将user对象顺序转成json
        log.info("请求发送消息的jsonTextMessage:" +  jsonMessage);

        //2.获取请求的url
        sendMessage_url = sendMessage_url.replace("ACCESS_TOKEN", accessToken);

        //3.调用接口，发送消息
        JSONObject jsonObject = WeiXinUtil.httpRequest(sendMessage_url, "POST", jsonMessage);
        //JSONObject jsonObject = JSONObject.fromObject("{\"errcode\":42001,\"errmsg\":\"ok\",\"access_token\":\"\",\"expires_in\":7200}");
        log.info("发送消息的返回jsonObject:" + jsonObject);

        //4.错误消息处理
        if (null != jsonObject) {
            int errcode = jsonObject.getInt("errcode");
            if (0 == errcode) {
                //批量发送推送消息时，可能存在部分用户发送消息成功，部分用户userid不合法的情侣
                if(!"".equals(jsonObject.getString("invaliduser"))){
                    log.warn("发送企业微信成功，部分用户userId不合法，不合法的userId = " + jsonObject.getString("invaliduser"));
                }else {
                    log.info("发送企业微信消息成功" + message);
                }
            }else {
                //如果是由于token失效,则替换老的token，重新调用
                if(40014 == errcode || 41001 == errcode || 42001 == errcode){
                    //重新获取token
                    AccessToken newToken = WeiXinUtil.getAccessToken(weiXinParames.getCorpId(), weiXinParames.getAgentSecret());
                    //重新发送消息
                    sendMessage(newToken.getToken(), message, weiXinParames, cycleSize);
                    //替换过期的token，所以先锁tokenMap不让别人用
                    String key = weiXinParames.getCorpId() + "_" + weiXinParames.getAgentSecret();
                    synchronized (WeiXinUtil.tokenMap){
                        //替换新的token
                        WeiXinUtil.tokenMap.put(key, newToken);
                    }
                }else {
                    log.error("发送企业微信消息失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
                    throw new BizException(jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
                }
            }
        }else {
            log.info("请求发送企业微信消息返回为空，requestUrl =" + sendMessage_url);
            throw new BizException(EnumsUtils.SENDMESSAGE_FAILED);
        }
    }
}

推送企业微信的util工具类，这个是入口方法：

package company.sendmessage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * 微信发送消息工具类
 */
public class SendWeiXinUtils {

    //发送企业微信消息的service
    private final static SendMessageService SMS = new SendMessageService();
    //企业微信发送请求接口的连接符
    private final static String SYMBOL = "|";

    private static Logger log = LoggerFactory.getLogger(SendWeiXinUtils.class);


    /**
     * 发送企业微信消息
     *
     * @param message
     */
    public static ResultJson sendWeiXinMessage(RequestMessage message, WeiXinParames weiXinParames) {
        log.info("发送企业微信消息开始，message={},params ={}", message, weiXinParames);
        ResultJson resultJson = null;
        TextMessage textMessage = null;
        try {
            //1、校验BaseMessage和weiXinParames
            CheckParamsUtil.checkBaseMessage(message);
            CheckParamsUtil.checkWeiXinParames(weiXinParames);
            //RequestMessage转换BaseMessage
            textMessage = convertTextMessage(message);
            //1.获取access_token:根据企业id和通讯录密钥获取access_token,并拼接请求url
            String accessToken = WeiXinUtil.getAccessToken(weiXinParames.getCorpId(), weiXinParames.getAgentSecret()).getToken();
            //发送消息
            SMS.sendMessage(accessToken, textMessage, weiXinParames, 1);
            resultJson = new ResultJson(EnumsUtils.SUCCESS);
            log.info("发送企业微信消息成功，response = " + resultJson);
        } catch (BizException e) {
            log.warn("发送企业微信消息失败，code ={},msg ={}", e.getEnumsUtils().getCode(), e.getEnumsUtils().getMsg());
            resultJson = new ResultJson(e.getEnumsUtils().getCode(), e.getEnumsUtils().getMsg());
        }
        return resultJson;
    }

    /**
     * RequestMessage转换BaseMessage
     *
     * @param message
     * @return
     */
    public static TextMessage convertTextMessage(RequestMessage message) {
        TextMessage textMessage = new TextMessage();
        //转换成员列表
        textMessage.setTouser(StringUtils.connectBySymbol(message.getTouser(), SYMBOL));
        //转换部门列表
        textMessage.setToparty(StringUtils.connectBySymbol(message.getToparty(), SYMBOL));
        //转换标签列表
        textMessage.setTotag(StringUtils.connectBySymbol(message.getTotag(), SYMBOL));
        textMessage.setMsgtype(message.getMsgtype());
        textMessage.setAgentid(message.getAgentid());
        textMessage.setText(message.getText());
        textMessage.setSafe(message.getSafe());
        return textMessage;
    }


    public static void main(String[] args) {
       /* //0.设置消息内容
        String content="unex 定时调度系统后台测试消息，只发给任务创建者！";

        //1.创建文本消息对象
        TextMessage message=new TextMessage();
        //企业微信的userid，唯一且必须
        message.setTouser("csh10609");
        //1.1非必需
        //message.setTouser("@all");  //不区分大小写
        //textMessage.setToparty("1");
        //txtMsg.setTotag(totag);
        //txtMsg.setSafe(0);

        //1.2必需
        message.setMsgtype("text");
        message.setAgentid(1000001);

        Text text=new Text();
        text.setContent(content);
        message.setText(text);*/
        String content = "unex 定时调度系统后台测试消息，只发给任务创建者！";
        RequestMessage requestMessage = new RequestMessage();
        List<String> list = new ArrayList<String>();
        list.add("csh10609");
        list.add("xxx10609");
       /* list.add("tsh10648");
        list.add("lsh9938");*/
        requestMessage.setTouser(list);
        requestMessage.setMsgtype("text");
        requestMessage.setAgentid(1000001);
        Text text = new Text();
        text.setContent(content);
        requestMessage.setText(text);
        WeiXinParames weiXinParames = new WeiXinParames();
        weiXinParames.setCorpId("**********");
        weiXinParames.setAgentSecret("****************");
        for (int i = 0; i < 1; i++) {
            sendWeiXinMessage(requestMessage, weiXinParames);
        }
    }
}

自定义字符串工具类：

/**
 * 字符串工具类
 * @Author csh10609
 */
public class StringUtils {

    /*
     * 遍历数组，以特定的符号连接
     * @param list
     * @param symbol
     * @return
     */
    public static String connectBySymbol(List<String> list, String symbol){
        StringBuffer sb = new StringBuffer();
        String touser = "";
      if(!CollectionUtils.isEmpty(list)){
          for (String s: list) {
             sb.append(s).append(symbol);
          }
          //去除最后面的symbol
          touser =  sb.substring(0,sb.length() - symbol.length());
      }
      return touser;
    }


    public static void main(String[] args) {
        List<String> list =  new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(connectBySymbol(list, "|"));
    }
}

企业微信参数类：

/**
 * 微信参数
 * @author csh10609
 *
 */

@Data
public class WeiXinParames {

	//企业ID
	private String corpId;
     //应用密钥
	private String agentSecret;

	//企业应用的id，整型。可在应用的设置页面查看
	//技术与创新中心id=1000006
	//private  int agentId;


}

微信工具类：就是提供http请求等一些公共方法：

package company.sendmessage;


import io.swagger.models.HttpMethod;
import net.sf.json.JSONException;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import java.io.*;
import java.net.ConnectException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class WeiXinUtil {

    private static Logger log = LoggerFactory.getLogger(WeiXinUtil.class);
    //微信的请求url
    //获取access_token的接口地址（GET） 限200（次/天）
    public final static String access_token_url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={corpId}&corpsecret={corpsecret}";
    //存储accessToken的Map，key=corpId_agentSecret,value=accessToken
    public static volatile Map<String, AccessToken> tokenMap = new ConcurrentHashMap<String, AccessToken>();



    /**
     * 1.发起https请求并获取结果
     *
     * @param requestUrl 请求地址
     * @param requestMethod 请求方式（GET、POST）
     * @param outputStr 提交的数据
     * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值)
     */
    public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {
        JSONObject jsonObject = null;
        StringBuffer buffer = new StringBuffer();
        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        try {
            // 创建SSLContext对象，并使用我们指定的信任管理器初始化
            TrustManager[] tm = { new MyX509TrustManager() };
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, tm, new java.security.SecureRandom());
            // 从上述SSLContext对象中得到SSLSocketFactory对象
            SSLSocketFactory ssf = sslContext.getSocketFactory();

            URL url = new URL(requestUrl);
            HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
            httpUrlConn.setSSLSocketFactory(ssf);

            httpUrlConn.setDoOutput(true);
            httpUrlConn.setDoInput(true);
            httpUrlConn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            httpUrlConn.setRequestMethod(requestMethod);

            if (HttpMethod.GET.toString().equalsIgnoreCase(requestMethod))
                httpUrlConn.connect();

            // 当有数据需要提交时
            if (null != outputStr) {
                OutputStream outputStream = httpUrlConn.getOutputStream();
                // 注意编码格式，防止中文乱码
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }

             // 将返回的输入流转换成字符串
             inputStream = httpUrlConn.getInputStream();
             inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
             bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            httpUrlConn.disconnect();
            jsonObject = JSONObject.fromObject(buffer.toString());
        } catch (ConnectException ce) {
            log.error("Weixin server connection timed out.");
            throw new BizException(EnumsUtils.WEIXIN_CONNECT_FAILED);
        } catch (Exception e) {
            log.error("https request error:{}", e);
            throw new BizException(EnumsUtils.WEIXIN_HAPPEN_EXCEPTION);
        }finally {
            try {
                // 释放资源
                bufferedReader.close();
                inputStreamReader.close();
                inputStream.close();
                inputStream = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return jsonObject;
    }


    /**
     * 2.发起http请求获取返回结果
     *
     * @param requestUrl 请求地址
     * @return
     */
    public static String httpRequest(String requestUrl) {
        StringBuffer buffer = new StringBuffer();
        try {
            URL url = new URL(requestUrl);
            HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();

            httpUrlConn.setDoOutput(false);
            httpUrlConn.setDoInput(true);
            httpUrlConn.setUseCaches(false);

            httpUrlConn.setRequestMethod("GET");
            httpUrlConn.connect();

            // 将返回的输入流转换成字符串
            InputStream inputStream = httpUrlConn.getInputStream();
            //InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

            String str = null;
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);

            }
            bufferedReader.close();
            inputStreamReader.close();
            // 释放资源
            inputStream.close();
            inputStream = null;
            httpUrlConn.disconnect();

        } catch (Exception e) {
        }
        return buffer.toString();
    }


    /**
     * 3.获取access_token
     *
     * @param corpId 凭证
     * @param appsecret 密钥
     * @return
     */
    public static AccessToken getAccessToken(String corpId, String appsecret) {
        AccessToken accessToken = null;
        //如果tokenMap已经有缓存token，直接返回，不用请求微信接口
        //注意因为token都是有失效时间的，所有返回的有可能是失败的token
        String key = corpId + "_" + appsecret;
        if(!StringUtils.isEmpty(tokenMap.get(key))){
            accessToken = tokenMap.get(key);
            return accessToken;
        }
        //如果是第一次请求token，通过corpId、appsecret请求企业微信的获取token的接口
        //拼装请求的url
        String requestUrl = access_token_url.replace("{corpId}", corpId).replace("{corpsecret}", appsecret);
        JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
        // 如果请求成功
        if (null != jsonObject) {
            try {
                accessToken = new AccessToken();
                accessToken.setToken(jsonObject.getString("access_token"));
                accessToken.setExpiresIn(jsonObject.getInt("expires_in"));
                //获取token成功，缓存进tokenMap中
                tokenMap.put(key, accessToken);
            } catch (JSONException e) {
                // 获取token失败
                log.error("获取token失败 errcode:{} errmsg:{}", jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
                //解析失败原因
                throw new BizException(jsonObject.getInt("errcode"), jsonObject.getString("errmsg"));
            }
        }else {
            log.error("获取token返回为空， requestUrl = " + requestUrl);
            //请求token失败
            throw new BizException(EnumsUtils.APPLY_TOKEN_FAILED);
        }
        return accessToken;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            String requestUrl = access_token_url.replace("{corpId}", "**************").replace("{corpsecret}", "**********************");
            JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
            System.out.println(jsonObject);
        }

    }

}

猜你喜欢

转载自blog.csdn.net/chengkui1990/article/details/82011991
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022