dubbo 服务端异步实现

一：服务端的配置文件

   <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);

}


}