匿名内部类，异步回调浅析

这个只是自己记录的自己看的，语法上不太严谨，逻辑还是清楚的

回调（基础版）：

A类里的AA函数不会做某事,就利用自己里面的CC函数调用B类里的BB函数做这件事，BB的参数里面有A类参数，BB把自己的步骤执行完毕后，再调用AA执行后面的操作（就是回调，回头再调）。

A(不会做)---调用B的BB方法---传入必要的参数，和自己本身----B.BB()被调用，协助A完成操作----再调用A的方法---表面上看上去是A操作的
A{
AA(x,y){}
CC(){
    A=new A();
    B=new B();
    //在此处对x，y进行操作，因为A不会才委托给B的
    B.BB(x,y,A);
}
}

B{
BB(x,y,A){
    .....
    //此处执行A类不会的东西，比如对x,y的处理
    A(x,y){}//回调
}
}

回调（高级版）：
把对象作为参数传进去，完全暴露，而且不安全

再次升级（匿名内部类）：
B 直接调用 A的匿名内部类，直接把A的存在隐藏掉，因为A就是new出来的匿名类，程序的关键功能都是B来实现的，回调A的方法也是在B内实现的，所以不需要建立一个中间对象，代码更洁净，（逻辑更奇怪）

B不用关心A是什么类？直接按照已经写好的逻辑执行，只要A实现了相关的接口

《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《《
public class RoomMate {
    //   这里可以加线程，如果有其他的动作可以让他先执行，这样就避免了卡死现象，所以在前台调接口里面用的比较多
   public void getAnswer(String homework, DoHomeWork someone)
   {
       if("1+1=?".equals(homework)){
           someone.doHomeWork(homework, "2");
       }else{
           someone.doHomeWork(homework, "(空白)");
       }
   }

   public static void main(String[] args) {
       RoomMate roomMate = new RoomMate();
       roomMate.getAnswer("1+1=?", new DoHomeWork() {

           @Override
           public void doHomeWork(String question, String answer){
               //此处可以加上耗时操作
               System.out.println("问题："+question+" 答案："+answer);
           }
       });
   }



}

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
下面的调用匿名内部类，然后回调其中的方法
onsuccess ， onfailure方法就相当于重写，实际实现了业务逻辑

new EPlusHelper().getDoctorContact(0, new JsonHttpResponseHandler() {
           @Override
           public void onSuccess(int statusCode, Header[] headers,
                   org.json.JSONObject response) {
               Log.e("TAG", response.toString());
               UserListModel model = JSON.parseObject(response.toString(),
                       UserListModel.class);
               if (model.ok()) {
                   int conNum=model.getFeedback().getContacts().size();
                   tvConNum.setText(conNum+"人");
                   Log.e("tag", model.getFeedback().getContacts().toString());
               } else {
                   // JSToastUitl.toast("网络异常");
               }
           };

           @Override
           public void onFailure(int statusCode, Header[] headers,
                   Throwable throwable, org.json.JSONObject errorResponse) {
               // TODO Auto-generated method stub
               super.onFailure(statusCode, headers, throwable, errorResponse);
               JSToastUitl.toast("网络异常");
           }

       });
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

AsyncHttpResponseHandler 接收请求结果，一般重写onSuccess及onFailure接收请求成功或失败的消息，还有onStart，onFinish等消息。

下面的即是helper的实际操作，先操作param，然后asyncHttpClient.post这一句里面实现了onsuccess和onfailure方法的逻辑

此处按理说应该是 responseHandler.onSuccess,onFailure（params）方法,为什么要用 asyncHttpClient.post，这一步之后执行的是

this.threadPool.submit(new AsyncHttpRequest(paramDefaultHttpClient, paramHttpContext, paramHttpUriRequest, paramAsyncHttpResponseHandler));
发送到线程池
AsyncHttpRequest 继承自Runnabler，被submit至线程池执行网络请求并发送start，success等消息，虽然没看到源码，但是这个的success里面肯定写的是responseHandler.onSuccess方法

public void getDoctorContact(int type,JsonHttpResponseHandler responseHandler) {
       JSONObject params = new JSONObject();
       params.put("doctorId", PrefsUtil.getCustomerId());
       params.put("type", type);
       String url = BASE_URL + "doctor/contacts";
       try {
           asyncHttpClient.post(context, url, setEntity(params), null, responseHandler);
       } catch (Exception e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
           JSToastUitl.toast("网络异常");
       }
   }

基本上所有的匿名内部类都是是回调，所有的异步回调都有线程....感觉分析的没什么屌用诶

匿名内部类，异步回调浅析

猜你喜欢