叮咚Android工程接口请求功能改造

工具 叮咚

先梳理下之前做后台接口API请求的使用方式

第一步

先修改TpClient类，添加一个执行API请求的入口方法，如下

    public final void doApiRequest(RequestCmd requestCmd) {
        CommonRestCallManager.commonRestCall(CommonRestCallType.RequestType, requestCmd);
    }

第二步

修改CommonRestCallType类添加一个请求API的类型整型常量，且注意不能与之前已经有类型的值重复

public static final int RequestType = 3205;

想像下，如果常量类型已经有很多，且值的定义并没有明确的规定和范围限定，那么定义这个类型值冲突的可能性还是有的，而且每次都得过滤下之前定义过的类型，保证唯一才行，费心有费心

第三步

定义并实现RequestCmd类，其实这个类型的定义是请求参数的代表类，但是在这里，每一个API请求都得定义一个这样的类

public class RequestCmd extends DTRestCallBase {
    private String paramKey1 = "key1";
    private String paramKey2 = "key2";
    private String paramValue1 = "value1";
    private String paramValue2 = "value2";
    public String getParamKey1() {
        return paramKey1;
    }
    public void setParamKey1(String paramKey1) {
        this.paramKey1 = paramKey1;
    }
    public String getParamKey2() {
        return paramKey2;
    }
    public void setParamKey2(String paramKey2) {
        this.paramKey2 = paramKey2;
    }
    public String getParamValue1() {
        return paramValue1;
    }
    public void setParamValue1(String paramValue1) {
        this.paramValue1 = paramValue1;
    }
    public String getParamValue2() {
        return paramValue2;
    }
    public void setParamValue2(String paramValue2) {
        this.paramValue2 = paramValue2;
    }
}

第四步

修改RestCallEncoderFactory类，并在如下方法体里进行修改

public static RestCallEncoder createRestCallEncoder(int commonRestCallType, DTRestCallBase restCallBase) {
        switch (commonRestCallType) {
            case CommonRestCallType.CREATE_GIAP_ORDER:
                return new CreateGIAPOrderEncoder(restCallBase);
            case CommonRestCallType.GET_INVITE_LINK:
                return new GetInviteLinkEncoder(restCallBase);
                ...

在switch case条件判断里添加如下代码

    case CommonRestCallType.RequestType:
                return new RequestCmdEncode(restCallBase);

第五步

定义并实现RequestCmdEncode类

class RequestCmdEncode extends RestCallEncoder {
    private RequestCmd requestCmd;
    public RequestCmdEncode(DTRestCallBase restCallCmd) {
        super(restCallCmd);
        requestCmd = (RequestCmd) restCallCmd;
    }
    @Override
    public DTCommonRestCallCmd encode() {
        DTCommonRestCallCmd cmd =  super.encode();
        cmd.setCommandTag(CommonRestCallType.RequestType);
        cmd.setApiName("/router/path");
        StringBuffer sb = new StringBuffer();
        sb.append("&");
        sb.append(requestCmd.getParamKey1());
        sb.append("=");
        sb.append(requestCmd.getParamValue1());
        sb.append("&");
        sb.append(requestCmd.getParamKey2());
        sb.append("=");
        sb.append(requestCmd.getParamValue2());
        cmd.setApiParams(sb.toString());
        return cmd;
    }
}

第六步

修改RestCallDecoderFactory类，并在createRestCallDecoder方法体的switch case条件判断里再增加如下代码：

                ...
case CommonRestCallType.RequestType:
        return new RequestCmdDecoder(commonRestCallBase.responseData, commonRestCallBase.getCommandCookie());
                ...

第七步

定义并实现RequestCmdDecoder类型

class RequestCmdDecoder extends RestCallDecoder {
    public RequestCmdDecoder(String responseData, int commandCookie) {
        super(responseData, commandCookie);
        mRestCallResponse=new RequestResponse();
    }
    @Override
    protected void decodeResponseData(JSONObject jsonObj) {
        try {
            if (mRestCallResponse.getErrCode() == 0) {
                mRestCallResponse.setResult(jsonObj.getInt("Result"));
                ((RequestResponse)mRestCallResponse).data1=jsonObj.optString("data1");
                ((RequestResponse)mRestCallResponse).data2=jsonObj.optInt("data2");
                ((RequestResponse)mRestCallResponse).data3=jsonObj.optString("data3");
            } else {
                mRestCallResponse.setResult(jsonObj.optInt("Result"));
                mRestCallResponse.setErrorCode(jsonObj.optInt("ErrCode"));
                mRestCallResponse.setReason(jsonObj.optString("Reason"));
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void onRestCallResponse() {
        TpClient.getInstance().onRequestDemoResponse((RequestResponse)mRestCallResponse);
    }
}

第八步

定义并实现RequestResponse类型

class RequestResponse extends me.dingtone.app.im.datatype.DTRestCallBase {
    public String data1;
    public int data2;
    public String data3;
}

第九步

再次修改TpClient类，添加onRequestDemoResponse方法

    public void onRequestDemoResponse(RequestResponse mRestCallResponse) {
        mTpEventHandler.onRequestDemoResponse(response);
    }

第十步

修改TpEventHandler类，并添加onRequestDemoResponse方法

public void onRequestDemoResponse(RequestResponse mRestCallResponse) {
        ServiceMgr.getInstance().handleResponse(DTRESTCALL_TYPE.DTRESTCALL_TYPE_DEMO_REQUEST, mRestCallResponse);
    }

第十一步

修改DTRESTCALL_TYPE类并添加DTRESTCALL_TYPE_DEMO_REQUEST常量类，并保证其值为唯一性

    public final static int DTRESTCALL_TYPE_WALLET_POINT_ADD = 0x1520;
    public static final int DTRESTCALL_TYPE_DEMO_REQUEST = 0x1521;

好了，十一步完成，我们现在可以开始正式去使用这个接口请求返回数据的功能了

第十二步

在要使用API请求的在地方，调用之前声明的调用API请求执行的触发方法,一般在Activity里的onCreate()方法里里执行如下代码

        RequestCmd cmd = new RequestCmd();
        cmd.setParamKey1("key1");
        cmd.setParamKey2("key2");
        cmd.setParamValue1("value1");
        cmd.setParamValue2("value2");
        TpClient.getInstance().doApiRequest(cmd);

第十三步

请求了API，总要的回调的地方吧，在要使用API请求的在地方，比如在Activity内去请求一个接口的数据，那需要在Activity内去注册一下当前的请求响应回调的实例。

UIMgr.getInstance().registerActivityEvent(DTRESTCALL_TYPE.DTRESTCALL_TYPE_DEMO_REQUEST, this);

第十四步

让当前的Activity实现me.dingtone.app.im.manager.Event接口,记住，实现的接口只有handleEvent可用,另一个接口方法handleRefreshUI暂时没有用。handleEvent方法就是表示后台API接口请求完成后会回调的方法。

    @Override
    public void handleEvent(int evtType, Object obj) {
        if (evtType == DTRESTCALL_TYPE.DTRESTCALL_TYPE_DEMO_REQUEST) {
            RequestResponse response = (RequestResponse) obj;
            //r接下来就可以使用API返回的数据进行界面的渲染等工作了
            String data1 = response.data1;
        }
        ...

好了，现有的RestCall请求就是这样添加一个新的接口的使用的，我的一句感受，WTF,这能忍受？Oh, I can't!
接下来，看看改造后的样子。

改造后的后台接口API请求的使用方式

改造后的请求方式非常简单，只需要使用一个工具类即可：DtHttpUtil, 新功能在dev_4_6_0分支后可用

    public void testDtHttpUtil() {
        DtRequestParams params = new DtRequestParams();
        params.add("key1", "value1");
        params.add("key2", "value2");
        DtHttpUtil.INSTANCE.edgeRequest("/router/path1", params, new DtRequestCallBack<DtBaseModel<MyData>>() {
            @Override
            public void onRequestSuccessful(DtBaseModel<MyData> response) {
                MyData myData = response.getData();
                //接下来去使用数据进行界面的渲染等工作了
                String data1 = myData.data1;
            }
        });
    }

用到的类都是现有的，除了要返回的MyData这个数据类，需要自己定义实现
定义实现如下：

class MyData {
    public String data1;
    public String data2;
    public String data3;
}

• 提示
  这个DtBaseModel<MyData>类型的数据序列化JSON后是对应的是服务端接口返回的JSON整体数据，大致如下：

{
    "ErrCode":0,
    "Reason":"",
    "Result":1,
    "data":{
        "data1":"111",
        "data2":"111",
        "data3":"111"
    }
}

如有疑问请@seal.wu@dingtone.me