匿名内部类，异步回调浅析_匿名内部类的回调是异步的吗

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

回调（基础版）：

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("网络异常");
        }
    }



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