Java回調方法詳解

回調在維基百科中定義為：

在計算機程序設計中，回調函數，是指通過函數參數傳遞到其他代碼的，某一塊可執行代碼的引用。

其目的是允許底層代碼調用在高層定義的子程序。
舉個例子可能更明白一些：以Android中用retrofit進行網絡請求為例，這個是異步回調的一個例子。
在發起網絡請求之後，app可以繼續其他事情，網絡請求的結果一般是通過onResponse與onFailure這兩個方法返回得到。看一下相關部分的代碼：

call.enqueue(new Callback<HistoryBean>() {
            @Override
            public void onResponse(Call<HistoryBean> call, Response<HistoryBean> response) {
                HistoryBean hb = response.body();
                if(hb == null) return;
                showText.append(hb.isError() + "");
                for(HistoryBean.ResultsBean rb : hb.getResults()){
                    showText.append(rb.getTitle() + "/n");
                }
            }

            @Override
            public void onFailure(Call<HistoryBean> call, Throwable t) {

            }
        });

忽略上面CallBack中的泛型，按照維基百科中的定義，匿名內部類裡面的全部代碼可以看成函數參數傳遞到其他代碼的，某一塊可執行代碼的引用。 onResponse與onFailure這兩個方法就是回調方法。底層的代碼就是已經寫好不變的網絡請求部分，高層定義的子程序就是回調，因為具體的實現交給了使用者，所以具備了很高的靈活性。上面就是通過enqueue(Callback callback)這個方法來關聯起來的。

回調方法的步驟

上面說的回調是很通用的概念，放到程序書寫上面，就可以說：

A類中調用B類中的某個方法C,然後B類中在反過來調用A類中的方法D,在這裡面D就是回調方法。B類就是底層的代碼，A類是高層的代碼。

所以通過上面的解釋，我們可以推斷出一些東西，為了表示D方法的通用性，我們采用接口的形式讓D方法稱為一個接口方法，那麼如果B類要調用A類中的方法D,那勢必A類要實現這個接口，這樣，根據實現的不同，就會有多態性，使方法具備靈活性。
A類要調用B類中的某個方法C,那勢必A類中必須包含B的引用，要不然是無法調用的，這一步稱之為注冊回調接口。那麼如何實現B類中反過來調用A類中的方法D呢，直接通過上面的方法C,B類中的方法C是接受一個接口類型的參數，那麼只需要在C方法中，用這個接口類型的參數去調用D方法，就實現了在B類中反過來調用A類中的方法D，這一步稱之為調用回調接口。
這也就實現了B類的C方法中，需要反過來再調用A類中的D方法，這就是回調。A調用B是直調，可以看成高層的代碼用底層的API,我們經常這樣寫程序。B調用A就是回調，底層API需要高層的代碼來執行。
最後，總結一下，回調方法的步驟：

• A類實現接口CallBack callback
• A類中包含了一個B的引用
• B中有一個參數為CallBack的方法f(CallBack callback)
• 在A類中調用B的方法f(CallBack callback)——注冊回調接口
• B就可以在f(CallBack callback)方法中調用A的方法——調用回調接口

回調的例子

我們以一個兒子在玩游戲，等媽媽把飯做好在通知兒子來吃為例，按照上面的步驟去寫回調；
上面的例子中，顯然應該兒子來實現回調接口，母親調用回調接口。所以我們先定義一個回調接口,然後讓兒子去實現這個回調接口。
其代碼如下：

public interface CallBack {

    void eat();
}

public class Son implements CallBack{

    private Mom mom;

    //A類持有對B類的引用
    public void setMom(Mom mom){
        this.mom = mom;
    }

    @Override
    public void eat() {
        System.out.println("我來吃飯了");
    }

    public void askMom(){
        //通過B類的引用調用含有接口參數的方法。
         System.out.println("飯做了嗎？");
        System.out.println("沒做好，我玩游戲了");
        new Thread(() -> mom.doCook(Son.this)).start();
        System.out.println("玩游戲了中......");
    }
}

然後我們還需要定義一個母親的類，裡面有一個含有接口參數的方法doCook

public class Mom {


    //在含有接口參數的方法中利用接口參數調用回調方法
    public void doCook(CallBack callBack){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("做飯中......");
                    Thread.sleep(5000);
                    callBack.eat();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

我們通過一個測試類：

public class Test {

    public static void main(String[] args) {
        Mom mom = new Mom();
        Son son = new Son();
        son.setMom(mom);
        son.askMom();
    }

}

這個例子就是典型的回調的例子。Son類實現了接口的回調方法，通過askMom這個方法調用Mom類中的doCook，實現注冊回調接口，相當於A類中調用B類的代碼C。在Mom類中的doCook來回調Son類中的eat，來告訴Son類中的結果。
這樣，我們就實現了一個簡單的，符合定義的回調。

回調例子的進一步探索

我們主要看一下Son類的代碼：

public class Son implements CallBack{

    public Mom mom;
    public Son(Mom mom){
        this.mom = mom;
    }

    public void askMom(){
        System.out.println("飯做了嗎？");
        System.out.println("沒做好，我玩游戲了");
        new Thread(() -> mom.doCook(Son.this)).start();
        System.out.println("玩游戲了中......");
    }
    @Override
    public void eat() {
        System.out.println("好了，我來吃飯了");
    }
}

這個類裡面，除了輸出一些語句之外，真正有用的部分是mom.doCook(Son.this)以及重寫eat方法。所以，我們可以通過匿名內部類的形式，簡寫這個回調。其代碼如下：

public class CallBackTest {
    public static void main(String[] args) {
        Mom mom = new Mom();
        new Thread(()-> mom.doCook(() -> System.out.println("吃飯了......"))).start();
    }
}

取消Son類，直接在主方法中通過匿名內部類去實現eat方法。其實匿名內部類就是回調的體現。

異步回調與同步回調

回調上面我們講了 就是A調用B類中的方法C,然後在方法C裡面通過A類的對象去調用A類中的方法D。
我們在說一下異步與同步，先說同步的概念

同步
同步指的是在調用方法的時候，如果上一個方法調用沒有執行完，是無法進行新的方法調用。也就是說事情必須一件事情一件事情的做，做完上一件，才能做下一件。
異步
異步相對於同步，可以不需要等上個方法調用結束，才調用新的方法。所以，在異步的方法調用中，是需要一個方法來通知使用者方法調用結果的。

實現異步的方式

在Java中最常實現的異步方式就是讓你想異步的方法在一個新線程中執行。

我們會發現一點，異步方法調用中需要一個方法來通知使用者調用結果，結合上面所講，我們會發現回調方法就適合做這個事情，通過回調方法來通知使用者調用的結果。
那異步回調就是A調用B的方法C時是在一個新線程當中去做的。
上面的母親通知兒子吃飯的例子，就是一個異步回調的例子。在一個新線程中，調用doCook方法，最後通過eat來接受返回值，當然使用lamdba優化之後的，本質是一樣的。
同步回調就是A調用B的方法C沒有在一個新線程，在執行這個方法C的時候，我們什麼都不能做，只能等待他執行完成。

同步回調與異步回調的例子

我們看一個Android中的一個同步回調的例子：

button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
             Log.i("button","被點擊");
        }
});

button通過setOnClickListener注冊回調函數，和上面寫的一樣，通過匿名內部類的形式將接口的引用傳進去。由於button調用setOnClickListener沒有新建一個線程，所以這個是同步的回調。
而異步回調，就是我們開篇講的那個例子：

call.enqueue(new Callback<HistoryBean>() {
            @Override
            public void onResponse(Call<HistoryBean> call, Response<HistoryBean> response) {
                HistoryBean hb = response.body();
                if(hb == null) return;
                showText.append(hb.isError() + "");
                for(HistoryBean.ResultsBean rb : hb.getResults()){
                    showText.append(rb.getTitle() + "/n");
                }
            }

            @Override
            public void onFailure(Call<HistoryBean> call, Throwable t) {

            }
        });

這個enqueue方法是一個異步方法去請求遠程的網絡數據。其內部實現的時候是通過一個新線程去執行的。
通過這兩個例子，我們可以看出同步回調與異步回調的使用其實是根據不同的需求而設計。不能說一種取代另一種，像上面的按鈕點擊事件中，如果是異步回調，用戶點擊按鈕之後其點擊效果不是馬上出現，而用戶又不會執行其他操作，那麼會感覺很奇怪。而像網絡請求的異步回調，因為受限於請求資源可能不存在，網絡連接不穩定等等原因導致用戶不清楚方法執行的時候，所以會用異步回調，發起方法調用之後去做其他事情，然後等回調的通知。

回調方法在通信中的應用

上面提到的回調方法，除了網絡請求框架的回調除外，其回調方法都是沒有參數，下面，我們看一下在回調方法中加入參數來實現一些通信問題。
如果我們想要A類得到B類經過一系列計算，處理後數據，而且兩個類是不能通過簡單的將B的引用給A類就可以得到數據的。我們可以考慮回調。
步驟如下：

1. 在擁有數據的那個類裡面寫一個回調的接口。-->這裡就是B類中寫一個回調接口
2. 回調方法接收一個參數，這個參數就是要得到的數據
3. 同樣是在這個類裡寫一個注冊回調的方法。
4. 在注冊回調方法，用接口的引用去調用回調接口，把B類的數據當做參數傳入回調的方法中。
5. 在A類中，用B類的引用去注冊回調接口，把B類中的數據通過回調傳到A類中。

上面說的步驟，有點抽象。下面我們看一個例子，一個是Client,一個是Server。Client去請求Server經過耗時處理後的數據。

public class Client{

    public Server server;
    public String request;
    //鏈接Server，得到Server引用。
    public Client connect(Server server){
        this.server = server;
        return this;
    }

    //Client，設置request
    public Client setRequest(String request){
        this.request = request;
        return this;
    }
    
    //異步發送請求的方法，lamdba表達式。
    public void enqueue(Server.CallBack callBack){
        new Thread(()->server.setCallBack(request,callBack)).start();
    }
}

public class Server {
    public String response = "這是一個html";
    //注冊回調接口的方法，把數據通過參數傳給回調接口
    public void setCallBack(String request,CallBack callBack){
        System.out.println("已經收到request，正在計算當中......");
        new Thread(() -> {
            try {
                Thread.sleep(5000);
                callBack.onResponse(request + response);
            } catch (InterruptedException e) {
                e.printStackTrace();
                callBack.onFail(e);
            }
        }).start();
    }

    //在擁有數據的那個類裡面寫一個接口
    public interface CallBack{
        void onResponse(String response);
        void onFail(Throwable throwable);
    }
}

接下來，我們看一下測試的例子：

public class CallBackTest {

    public static void main(String[] args) {

        Client client = new Client();
        client.connect(new Server()).setRequest("這個文件是什麼？").enqueue(new Server.CallBack() {
            @Override
            public void onResponse(String response) {
                System.out.println(response);
            }

            @Override
            public void onFail(Throwable throwable) {
                System.out.println(throwable.getMessage());
            }
        });
    }
}

結果如下：

已經收到request，正在計算當中......
這個文件是什麼？這是一個html

以上就是通過回調的方式進行通信