一：服務端的配置文件
<dubbo:service interface="com.tc.tce.var.api.facade.VarQueryFacade"
ref="varQueryFacade" protocol="${var.query.provider.protocol}"
timeout="${var.query.provider.timeout}" version="${var.query.provider.version}" >
<dubbo:method name="varQueryAsync">
<dubbo:argument index="1" callback="true" />
</dubbo:method>
</dubbo:service>
service.threapool.corePoolSize=50
service.threapool.maxPoolSize=50
<bean id="servciceTaskExecutor"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="${service.threapool.corePoolSize}" />
<property name="maxPoolSize" value="${service.threapool.maxPoolSize}" />
<property name="WaitForTasksToCompleteOnShutdown" value="true" />
</bean>
二：服務端代碼
1：接口
public interface VarQueryFacade {
RCEResponse<List<VariableValue>> varQuery(RCERequest<VarQuery> request);
void varQueryAsync(RCERequest<VarQuery> request, LtsAgentCallbackListener listener);
}
2：實現類
public class VarQueryFacadeImpl implements VarQueryFacade {
private static final Logger log = LoggerFactory.getLogger("rce_biz");
@Autowired
private VarQueryService varQueryService;
@Autowired
@Qualifier("servciceTaskExecutor")
private ThreadPoolTaskExecutor serviceTaskExecutor;
/***
* 異步響應
*/
@Override
public void varQueryAsync(RCERequest<VarQuery> request, LtsAgentCallbackListener listener) {
log.info("varQueryAsync accept:"+request.getSession_id());
boolean ret = checkParamsAsync(request, listener);
if (!ret) {
return;
}
serviceTaskExecutor.execute(new VarQueryComputeThread(request,varQueryService,listener));
}
/***
* 異步請求參數的校驗
* @param request
* @param listener
* @return
*/
private boolean checkParamsAsync(RCERequest<VarQuery> request,LtsAgentCallbackListener listener){
if (listener == null) {
log.error("request parameter listener is null.");
return false;
}
RCEResponse<List<VariableValue>> response = new RCEResponse<>();
if (StringUtils.isBlank(request.getSession_id())) {
log.error("request parameter sessionId is null");
response.setCode(RCEResponse.INVALID_PARAM);
response.setCode_desc("params error :sessionId is null");
listener.onComputeResponse(response);
return false;
}
String errorInfo = checkParams(request).toString();
if (StringUtils.isNotBlank(errorInfo)) {
log.error("request parameter error:" + errorInfo);
response.setCode(RCEResponse.INVALID_PARAM);
response.setSession_id(request.getSession_id());
response.setCode_desc("params error :" + errorInfo);
listener.onComputeResponse(response);
return false;
}
return true;
}
}
3：執行線程
public class VarQueryComputeThread implements Runnable {
private static final Logger log = LoggerFactory.getLogger("rce_biz");
private VarQueryService varQueryService;
private RCERequest<VarQuery> request;
private LtsAgentCallbackListener listener;
public VarQueryComputeThread(RCERequest<VarQuery> request,VarQueryService varQueryService,LtsAgentCallbackListener listener) {
this.request = request;
this.varQueryService=varQueryService;
this.listener=listener;
}
@Override
public void run() {
long start = System.currentTimeMillis();
log.info("發起變量查詢請求。sessionId:{},參數：{}",request.getSession_id(), JSON.toJSONString(request));
RCEResponse<List<VariableValue>> response = new RCEResponse<>();
response.setVersion(request.getVersion());
response.setSession_id(request.getSession_id());
try {
List<VariableValue> variableValues = varQueryService.queryVar(request);
response.setBody(variableValues);
response.setCode(RCEResponse.SUCCESS);
response.setCode_desc("成功");
} catch (VarQueryException e) {
response.setCode(RCEResponse.INVALI_DATA);
response.setCode_desc("訪問varQuery業務異常：" + e.getMessage());
log.error("訪問varQuery業務異常", e);
} catch (Exception e) {
response.setCode(RCEResponse.INVALI_DATA);
response.setCode_desc("訪問varQuery系統異常：" + e.getMessage());
log.error("訪問varQuery系統異常", e);
}
long end = System.currentTimeMillis();
log.info("變量查詢結束,sessionId:{},耗時: {} ms", request.getSession_id(),(end-start));
// 應答
listener.onComputeResponse(response);
}
4： 回調listener
public interface LtsAgentCallbackListener {
void onComputeResponse(RCEResponse<List<VariableValue>> rceResponse);
}
5: RCEResponse.java 類
public class RCEResponse<T> implements Serializable {
/**
*
*/
private static final long serialVersionUID = -2366653604420338724L;
public static final Integer SUCCESS = 0; //成功
public static final Integer INVALID_PARAM = 1;//請求參數錯誤
public static final Integer TIMEOUT = 2; //獲取數據超時
public static final Integer INVALI_DATA = 3;//數據異常
public static final Integer BUSY = 4;//服務忙，稍後重試
public static final Integer UNKNOWN_ERROR = 5;//其它錯誤
public static final Integer ALREADY_SENT = 6;//模型計算結果已經推送成功
public static final Integer SENDING = 7;//模型在計算中(推送中)
private String session_id; // 會話ID string 是 和請求中session_id保持一致
private String version; // 接口版本 string 是 目前只支持1.0
private Integer code; // 狀態碼 int 是 0:成功,1:請求參數錯誤,2:獲取數據超時,3:數據異常,4:服務忙，稍後重試,5:其它錯誤
private String code_desc; // 狀態描述 string 是 例如:”success”,”time out”
private T body; // 消息體 struct 否 具體定義依賴於不同的接口。
public String getSession_id() {
return session_id;
}
public void setSession_id(String session_id) {
this.session_id = session_id;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getCode_desc() {
return code_desc;
}
public void setCode_desc(String code_desc) {
this.code_desc = code_desc;
}
public T getBody() {
return body;
}
public void setBody(T body) {
this.body = body;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
}
public class VariableValue {
private Long varId;
private Object varValue;
public VariableValue() {
}
public VariableValue(Long varId, Object varValue) {
this.varId = varId;
this.varValue = varValue;
}
public Long getVarId() {
return varId;
}
public void setVarId(Long varId) {
this.varId = varId;
}
public Object getVarValue() {
return varValue;
}
public void setVarValue(Object varValue) {
this.varValue = varValue;
}
}
三：客戶端配置
1：
<dubbo:reference id="varQueryFacade"
interface="com.tc.tce.var.api.facade.VarQueryFacade" protocol="${lts.service.consumer.protocol}"
timeout="${lts.service.consumer.timeout}" version="${lts.service.consumer.version}"
check="false" async="true">
<!--
<dubbo:method name="varQuery"></dubbo:method>
-->
</dubbo:reference>
四：客戶端代碼
1：
@Override
public boolean getDataAsync(RCERequest request) {
//需要添加異常處理
varQueryFacade.varQueryAsync(request, ltsCallbackListener);
return true;
}
2：RCERequest 需要實現序列化
public class RCERequest<T> implements Serializable {
private static final long serialVersionUID = 1287470477841794151L;
}
3：listener的實現
private LtsAgentCallbackListener ltsCallbackListener = new LtsCallbackListener();
class LtsCallbackListener implements LtsAgentCallbackListener, Serializable {
private static final long serialVersionUID = 1L;
@Override
public void onComputeResponse(RCEResponse<List<VariableValue>> rceResponse) {
logger.info("Get dw result." + rceResponse.getCode() + " " + rceResponse.getCode_desc() + " " + rceResponse.getSession_id());
ltsRespMap.put(rceResponse.getSession_id(), rceResponse);
}
}
private Map<String, RCEResponse<List<VariableValue>>> ltsRespMap = new ConcurrentHashMap<String, RCEResponse<List<VariableValue>>>();
public RCEResponse<List<VariableValue>> getLtsRespMapValue(String sessionId){
return ltsRespMap.get(sessionId);
}
public void removeLtsRespMapValue(String sessionId){
ltsRespMap.remove(sessionId);
}
3：調用的地方：
private class GetDataCallback implements Callable<LTSResult> {
protected LtsServiceContext context = null;
public GetDataCallback(LtsServiceContext context) {
this.context = context;
}
@Override
public LTSResult call() throws Exception {
LTSResult ltsResult = new LTSResult(context);
try {
RCERequest request = new RCERequest();
ltsServiceAccess.getDataAsync(request);
//默認的超時時間 30秒，記得改成配置文件裏面的；
while ((System.currentTimeMillis()-timestamp) < 30000) {
RCEResponse<List<VariableValue>> rceResponse=ltsServiceAccess.getLtsRespMapValue(context.getSmallSessionid());
if (rceResponse != null) {
ltsResult.setValue(rceResponse);
ltsServiceAccess.removeLtsRespMapValue(context.getSmallSessionid());
break;
}
try {
Thread.sleep(20);
} catch (InterruptedException e) {
logger.info("InterruptedException, " + e.getMessage());
}
}
} catch (Exception e) {
logger.error("get lts data callback exception:" + e.getMessage()+context);
}
return ltsResult;
}
}
private static ExecutorService executorService = Executors.newFixedThreadPool(GlobalConfig.getInstance().getInt("LtsComputeModule.threads", 4));
private static ExecutorCompletionService<LTSResult> executorCompletionService = new ExecutorCompletionService<>(executorService);
@Override
public boolean getData(LtsServiceContext context) {
// return ltsPartRequests.add(context);
executorCompletionService.submit(new GetDataCallback(context));
return true;
}
@Override
public boolean start() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Future<LTSResult> future = executorCompletionService.take();
LTSResult ltsResult = future.get();
LtsServiceContext context = ltsResult.getContext();
context.handleAsync(ltsResult);
} catch (InterruptedException e) {
logger.error("InterruptedException, " + e.getMessage());
} catch (ExecutionException e) {
logger.error("ExecutionException, " + e.getMessage());
}
}
}
}, "LtsServicePartCompute");
thread.start();
三：客戶端最簡短的代碼
private LtsAgentCallbackListener ltsCallbackListener = new LtsCallbackListener();
varQueryFacade.varQueryAsync(request, ltsCallbackListener);
class LtsCallbackListener implements LtsAgentCallbackListener, Serializable {
private static final long serialVersionUID = 1L;
@Override
public void onComputeResponse(RCEResponse<List<VariableValue>> rceResponse) {
System.out.println("async response from queryserver:"+rceResponse);
}
}