【fastweixin框架教程4】AccessToken、QYAPIConfig管理

本文针对《fastweixin框架》 代码不适用于实际情况进行修改。

 

 修改原因：

获得AccessToken接口频率有限制，建议进行缓存，注意有效期，本文写作时候是access_token有效期是7200秒，也就是两小时。

原框架没有固化保存方法，一般可以考虑保存到数据库，但读取时候发现QYAPIConfig没有赋值AccessToken的方法

  修改方法：

  修改QYAPIConfig类，自己继承实现新类。

package com.fastwixinextend;

import com.github.sd4324530.fastweixin.api.config.ChangeType;
import com.github.sd4324530.fastweixin.api.config.ConfigChangeNotice;
import com.github.sd4324530.fastweixin.api.response.GetJsApiTicketResponse;
import com.github.sd4324530.fastweixin.api.response.GetTokenResponse;
import com.github.sd4324530.fastweixin.company.api.config.QYAPIConfig;
import com.github.sd4324530.fastweixin.exception.WeixinException;
import com.github.sd4324530.fastweixin.handle.ApiConfigChangeHandle;
import com.github.sd4324530.fastweixin.util.JSONUtil;
import com.github.sd4324530.fastweixin.util.NetWorkCenter;
import com.github.sd4324530.fastweixin.util.StrUtil;

import java.util.concurrent.atomic.AtomicBoolean;

import org.apache.http.HttpStatus;

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

public class QYAPIConfigExt extends QYAPIConfig {

private static final Logger LOG
= LoggerFactory.getLogger(QYAPIConfig.class);
private static final long serialVersionUID = 1L;

private Integer CACHE_TIME = 7100 * 1000;
private final AtomicBoolean tokenRefreshing = new AtomicBoolean(false);
private final AtomicBoolean jsRefreshing = new AtomicBoolean(false);

private final String corpid;
private final String corpsecret;
protected String accessToken;
private String jsApiTicket;
private boolean enableJsApi;
private long jsTokenStartTime;
protected long weixinTokenStartTime;

/**
* 构造方法二，实现同时获取AccessToken，启用jsApi
*
* @param corpid corpid
* @param corpsecret corpsecret
* @param enableJsApi enableJsApi
*/
public QYAPIConfigExt(String corpid, String corpsecret,
boolean enableJsApi) {
super(corpid, corpsecret, enableJsApi);
this.corpid = corpid;
this.corpsecret = corpsecret;
this.enableJsApi = enableJsApi;
}

/**
* 构造方法一，实现同时获取AccessToken。不启用jsApi
*
* @param corpID corpID
* @param corpSecret corpSecret
*/
public QYAPIConfigExt(String corpID, String corpSecret) {

this(corpID, corpSecret, false);
}

/**
* 构造方法一，实现同时获取AccessToken。不启用jsApi
*
* @param corpID corpID
* @param corpSecret corpSecret
* @param accessToken
* @param weixinTokenStartTime
*/
public QYAPIConfigExt(String corpID, String corpSecret, String accessToken,
long weixinTokenStartTime) {
this(corpID, corpSecret, false);
this.accessToken = accessToken;
this.setWeixinTokenStartTime(weixinTokenStartTime);
}

/**
* 构造方法一，实现同时获取AccessToken。不启用jsApi
*
* @param corpID corpID
* @param corpSecret corpSecret
* @param accessToken
* @param weixinTokenStartTime
*/
public QYAPIConfigExt(String corpID, String corpSecret, String accessToken,
long weixinTokenStartTime, int CACHE_TIME) {
this(corpID, corpSecret, false);
this.accessToken = accessToken;
this.setWeixinTokenStartTime(weixinTokenStartTime);
this.setCACHE_TIME(CACHE_TIME);
}

public String getCorpid() {
return corpid;
}

public String getCorpsecret() {
return corpsecret;
}

public String getAccessToken() {
long now = System.currentTimeMillis();
long time = now - this.weixinTokenStartTime;
try {
if (time > CACHE_TIME
&& tokenRefreshing.compareAndSet(false, true)) {
LOG.debug("准备刷新tokean.........");
initToken(now);
}
} catch (Exception e) {
LOG.error("刷新token异常", e);
tokenRefreshing.set(false);
}
return accessToken;
}

public String getJsApiTicket() {
if (enableJsApi) {
long now = System.currentTimeMillis();
long time = now - this.jsTokenStartTime;
try {
if (now - this.jsTokenStartTime > CACHE_TIME
&& jsRefreshing.compareAndSet(false, true)) {
LOG.debug("准备刷新JSTokean..........");
getAccessToken();
initJSToken(now);
}
} catch (Exception e) {
LOG.error("刷新jsToken异常", e);
jsRefreshing.set(false);
}
} else {
jsApiTicket = null;
}
return jsApiTicket;
}

public boolean isEnableJsApi() {
return enableJsApi;
}

public void setEnableJsApi(boolean enableJsApi) {
this.enableJsApi = enableJsApi;
if (!enableJsApi) {
this.jsApiTicket = null;
}
}

public void addHandle(final ApiConfigChangeHandle handle) {
super.addObserver(handle);
}

public void removeHandle(final ApiConfigChangeHandle handle) {
super.deleteObserver(handle);
}

public void removeAllHandle() {
super.deleteObservers();
}

private void initToken(final long refreshTime) {
LOG.debug("开始初始化access_token..........");
// 记住原本的事件，用于出错回滚
final long oldTime = this.getWeixinTokenStartTime();
this.setWeixinTokenStartTime(refreshTime);
String url
= "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=" + corpid
+ "&corpsecret=" + corpsecret;
NetWorkCenter.get(url, null, new NetWorkCenter.ResponseCallback() {
@Override
public void onResponse(int resultCode, String resultJson) {
if (HttpStatus.SC_OK == resultCode) {
GetTokenResponse response
= JSONUtil.toBean(resultJson, GetTokenResponse.class);
LOG.debug("获取access_token:{}",
response.getAccessToken());
if (null == response.getAccessToken()) {
// 刷新时间回滚
setWeixinTokenStartTime(oldTime);
throw new WeixinException("微信企业号token获取出错，错误信息:"
+ response.getErrcode()
+ ","
+ response.getErrmsg());
}
accessToken = response.getAccessToken();
// 设置通知点
setChanged();
notifyObservers(new ConfigChangeNotice(corpid,
ChangeType.ACCESS_TOKEN,
accessToken));
}
}
});
tokenRefreshing.set(false);
}

private void initJSToken(final long refreshTime) {
LOG.debug("初始化 jsapi_ticket.........");
// 记住原本的事件，用于出错回滚
final long oldTime = this.getJsTokenStartTime();
this.setJsTokenStartTime(refreshTime);
String url
= "https://qyapi.weixin.qq.com/cgi-bin/get_jsapi_ticket?access_token="
+ accessToken;
NetWorkCenter.get(url, null, new NetWorkCenter.ResponseCallback() {

@Override
public void onResponse(int resultCode, String resultJson) {
if (HttpStatus.SC_OK == resultCode) {
GetJsApiTicketResponse response
= JSONUtil.toBean(resultJson,
GetJsApiTicketResponse.class);
LOG.debug("获取jsapi_ticket:{}", response.getTicket());
if (StrUtil.isBlank(response.getTicket())) {
//刷新时间回滚
setJsTokenStartTime(oldTime);
throw new WeixinException("微信企业号jsToken获取出错，错误信息:"
+ response.getErrcode()
+ ","
+ response.getErrmsg());
}
jsApiTicket = response.getTicket();
//设置通知点
setChanged();
notifyObservers(new ConfigChangeNotice(corpid,
ChangeType.JS_TOKEN,
jsApiTicket));
}
}
});
jsRefreshing.set(false);
}

public Integer getCACHE_TIME() {
return CACHE_TIME;
}

private void setCACHE_TIME(Integer CACHE_TIME) {
this.CACHE_TIME = CACHE_TIME;
}

public long getJsTokenStartTime() {
return jsTokenStartTime;
}

private void setJsTokenStartTime(long jsTokenStartTime) {
this.jsTokenStartTime = jsTokenStartTime;
}

public long getWeixinTokenStartTime() {
return weixinTokenStartTime;
}

private void setWeixinTokenStartTime(long weixinTokenStartTime) {
this.weixinTokenStartTime = weixinTokenStartTime;
}
}