先看一下Exchanger的介面定義，就是bind和connect ，bind是服務端呼叫的，繫結一個埠用來接收客戶端的請求。connect是作為一個客戶端去連線服務端，進行和服務端交換。

@SPI(HeaderExchanger.NAME)
public interface Exchanger {

    /**
     * bind.
     *
     * @param url
     * @param handler
     * @return message server
     */
    @Adaptive({Constants.EXCHANGER_KEY})
    ExchangeServer bind(URL url, ExchangeHandler handler) throws
 
 RemotingException;

    /**
     * connect.
     *
     * @param url
     * @param handler
     * @return message channel
     */
    @Adaptive({Constants.EXCHANGER_KEY})
    ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException;

}

那麼Exchanger是被誰呼叫了？

可以看到主要是被Exchangers

建立Exchanger

    public static Exchanger getExchanger(String type) {
        return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
    }

bind

    public static ExchangeServer bind(URL url, ExchangeHandler handler) throws
 
 RemotingException {
        if (url == null) {
            throw new IllegalArgumentException("url == null");
        }
        if (handler == null) {
            throw new IllegalArgumentException("handler == null");
        }
        url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
        return getExchanger(url).bind(url, handler);
    }

connect方法

    public static ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
        if (url == null) {
            throw new IllegalArgumentException("url == null");
        }
        if (handler == null) {
            throw new IllegalArgumentException("handler == null");
        }
        url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
        return getExchanger(url).connect(url, handler);
    }

可以看到 邏輯性不是很強，但是這個分層到底是為了什麼？直接在Protocol釋出/引用服務的時候建立一個Exchanger不就好了嗎？

為什麼要抽象一個工具類呢？

這個後面再思考思考，什麼時候寫公共類，什麼時候寫這種工具類

先聊聊Exchanger的作用是什麼？

exchange 資訊交換層：封裝請求響應模式，同步轉非同步，以 Request, Response 為中心，擴充套件介面為 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer

Request和Response，很熟悉，和Servlet是不是很像，那麼這一層應該是類似於Tomcat接收外界的請求，封裝為Request和Response進行封裝與轉發，作為內部與外部連線的轉接層。確實是哦，Protocol這一層主要是進行服務的釋出與引用，相當於內部的處理都做好了，但是現在與外部個還沒有連線，所以對於injvm這些不需要與外界進行溝通的協議或者如rmi這種有自己格式固定的通訊並有相應的支支撐的協議，就不需要這個交換層了。

Dubbo裡面只有一個HeaderExchanger的預設實現，對心跳的功能的包裝

public class HeaderExchanger implements Exchanger {

    public static final String NAME = "header";

    public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
        // 開啟一個Transporters的客戶端
        // 解碼 -> 心跳handler包裝原始的handler    裝飾者模式 哇哇哇哇
        return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))), true);
    }

    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        // 開啟一個Transporters的服務端
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }

}

建立一個交換層的客戶端，也就是ReferenceBean的訊息傳送者

    public HeaderExchangeClient(Client client, boolean needHeartbeat) {
        if (client == null) {
            throw new IllegalArgumentException("client == null");
        }
        this.client = client;
        this.channel = new HeaderExchangeChannel(client);
        // 獲取dubbo協議版本
        String dubbo = client.getUrl().getParameter(Constants.DUBBO_VERSION_KEY);
        this.heartbeat = client.getUrl().getParameter(Constants.HEARTBEAT_KEY, dubbo != null && dubbo.startsWith("1.0.") ? Constants.DEFAULT_HEARTBEAT : 0);
        // 獲取心跳超時時間
        this.heartbeatTimeout = client.getUrl().getParameter(Constants.HEARTBEAT_TIMEOUT_KEY, heartbeat * 3);
        // 如果心跳超時小於兩個心跳間隔的時間 
        if (heartbeatTimeout < heartbeat * 2) {
            throw new IllegalStateException("heartbeatTimeout < heartbeatInterval * 2");
        }
        // 如果需要傳送心跳
        if (needHeartbeat) {
            startHeartbeatTimer();
        }
    }

如何傳送心跳的

1. 停止之前的心跳傳送器
2. 啟動一個新的心跳
   通過 ScheduledThreadPoolExecutor 定時任務執行緒池

    // 過heartbeat時間後開始沒heartbeat傳送心跳
    private void startHeartbeatTimer() {
        stopHeartbeatTimer();
        if (heartbeat > 0) {
            heartbeatTimer = scheduled.scheduleWithFixedDelay(
            heartBeatTask,
            heartbeat, 
            heartbeat, 
            TimeUnit.MILLISECONDS);
        }
    }

heartBeatTask 心跳任務

    new HeartBeatTask(new HeartBeatTask.ChannelProvider() {
        public Collection<Channel> getChannels() {
            return Collections.<Channel>singletonList(HeaderExchangeClient.this);
        }
    }, heartbeat, heartbeatTimeout);

HeaderExchangeServer 也是類似的功能，不一樣的地方就是裡面的屬性server 和client,這些都是Transport這裡面的，後面還是要梳理梳理整個dubbo的流程
且聽下回分解