【笔记记录】使用Okhttp的WebSocket，并分析相关流程

已于 2024-03-03 22:55:54 修改
阅读量1.4k 收藏 19
点赞数 11
文章标签： android okhttp websocket
于 2024-03-03 22:51:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45674709/article/details/136421809
版权

OkHttp之WebSocket相关使用和流程分析

相关使用方法简介
//导入Okhttp包
//okhttp
    implementation 'com.squareup.okhttp3:okhttp:3.10.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'

//创建okHttpClient
private val wsHttpClient :OkHttpClient by lazy {
        OkHttpClient.Builder()
            .readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
            .writeTimeout(10, TimeUnit.SECONDS)//设置写的超时时间
            .connectTimeout(10, TimeUnit.SECONDS)//设置连接超时时间
            .pingInterval(10, TimeUnit.SECONDS)
            .build()
    }
private lateinit var websocket:WebSocket

private lateinit var request:Request
//参数填充
request = Request.Builder()
            .url(webSocketServerurl)
            .build()


        websocket = wsHttpClient.newWebSocket(request,object : WebSocketListener() {
            override fun onOpen(webSocket: WebSocket, response: Response) {
                Log.i(TAG,"webSocket connection successful")
                super.onOpen(webSocket, response)
            }

            override fun onMessage(webSocket: WebSocket, text: String) {
                Log.i(TAG,"webSocket onMessage $text")
                super.onMessage(webSocket, text)
            }

            override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
                Log.i(TAG,"webSocket onMessage ${bytes}")
                super.onMessage(webSocket, bytes)
            }

            override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
                Log.i(TAG,"webSocket onClosing")
                super.onClosing(webSocket, code, reason)
            }

            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
                Log.i(TAG,"webSocket onClosed")
                super.onClosed(webSocket, code, reason)
            }

            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
                Log.i(TAG,"webSocket onFailure")
                super.onFailure(webSocket, t, response)
            }
        })

//发送消息
websocket.send("发送的内容")
主相关流程分析
OkHttpWebsocket
//由RealWebSocket实现接口
public interface WebSocket {

  long queueSize();


  boolean send(String text);

  boolean send(ByteString bytes);

 
  boolean close(int code, @Nullable String reason);

  void cancel();

   //OkHttpClient进行继承
  interface Factory {
    WebSocket newWebSocket(Request request, WebSocketListener listener);
  }
}
OkHttpClient

每个okHttpClient都有自己的线程池和连接池，重用可减少在创建client上面的资源。（因此推荐使用单例，进行重复使用client）

//实现该接口，，Call用来发送http请求和读取响应数据
open class OkHttpClient : Call.Factory, WebSocket.Factory

//具体实现方法
@Override public WebSocket newWebSocket(Request request, WebSocketListener listener) {
    RealWebSocket webSocket = new RealWebSocket(request, listener, new Random(), pingInterval);
    webSocket.connect(this);
    return webSocket;
  }
RealWebSocket
//connent函数
public void connect(OkHttpClient client) {
    client = client.newBuilder()
        .eventListener(EventListener.NONE)
        .protocols(ONLY_HTTP1)
        .build();
    //在原本的请求上面增加配置
    final Request request = originalRequest.newBuilder()
        .header("Upgrade", "websocket")
        .header("Connection", "Upgrade")
        .header("Sec-WebSocket-Key", key)
        .header("Sec-WebSocket-Version", "13")
        .build();
    //Instance在OkHttpClient进行实例化，进行创建请求，RealCall
    call = Internal.instance.newWebSocketCall(client, request);
    call.enqueue(new Callback() {
      @Override public void onResponse(Call call, Response response) {
        try {
          checkResponse(response);
        } catch (ProtocolException e) {
          failWebSocket(e, response);
          closeQuietly(response);
          return;
        }

        // 将http流转化为WebSocket流，实例化StreamAllocation
        StreamAllocation streamAllocation = Internal.instance.streamAllocation(call);
         //设置当前的 connection 不能再创建新的流。
        streamAllocation.noNewStreams(); // Prevent connection pooling!
          //通过RealConnection创建流
        Streams streams = streamAllocation.connection().newWebSocketStreams(streamAllocation);

        // Process all web socket messages.
        try {
            //进行接口回调当前连接情况返回数据
          listener.onOpen(RealWebSocket.this, response);
          String name = "OkHttp WebSocket " + request.url().redact();
            //初始化读写，流的线程，   使用线程池周期性向发送ping帧，，线程池循环读取队列，进行发送该帧
          initReaderAndWriter(name, streams);
           //streamAllocation.connection()返回RealConnection
          streamAllocation.connection().socket().setSoTimeout(0);
           //启动WebSocketReader进行循环读取socket流
          loopReader();
        } catch (Exception e) {
          failWebSocket(e, null);
        }
      }

      @Override public void onFailure(Call call, IOException e) {
        failWebSocket(e, null);
      }
    });
  }
//当前类
//实现了websocket接口，用来提供发送消息，关闭等，取消等函数
//实现了WebSocketReader.FrameCallback接口
final class WebSocketReader {
  public interface FrameCallback {
    void onReadMessage(String text) throws IOException;
    void onReadMessage(ByteString bytes) throws IOException;
    void onReadPing(ByteString buffer);
    void onReadPong(ByteString buffer);
    void onReadClose(int code, String reason);
  }
}


//实现的接口，
@Override public void onReadMessage(String text) throws IOException {
    //回调监听器
    listener.onMessage(this, text);
  }

  @Override public void onReadMessage(ByteString bytes) throws IOException {
    listener.onMessage(this, bytes);
  }

  @Override public synchronized void onReadPing(ByteString payload) {
    pongQueue.add(payload);
    runWriter();
    receivedPingCount++;
  }

  @Override public synchronized void onReadPong(ByteString buffer) {
    // This API doesn't expose pings.
    receivedPongCount++;
    awaitingPong = false;
  }

  @Override public void onReadClose(int code, String reason) {
    if (code == -1) throw new IllegalArgumentException();

    Streams toClose = null;
    synchronized (this) {
      if (receivedCloseCode != -1) throw new IllegalStateException("already closed");
      receivedCloseCode = code;
      receivedCloseReason = reason;
      if (enqueuedClose && messageAndCloseQueue.isEmpty()) {
        toClose = this.streams;
        this.streams = null;
        if (cancelFuture != null) cancelFuture.cancel(false);
        this.executor.shutdown();
      }
    }

    try {
      listener.onClosing(this, code, reason);

      if (toClose != null) {
        listener.onClosed(this, code, reason);
      }
    } finally {
      closeQuietly(toClose);
    }
  }

  @Override public boolean send(String text) {
    if (text == null) throw new NullPointerException("text == null");
    return send(ByteString.encodeUtf8(text), OPCODE_TEXT);
  }

  @Override public boolean send(ByteString bytes) {
    if (bytes == null) throw new NullPointerException("bytes == null");
    return send(bytes, OPCODE_BINARY);
  }

//send具体方法
private synchronized boolean send(ByteString data, int formatOpcode) {
    // If this frame overflows the buffer, reject it and close the web socket.
    if (queueSize + data.size() > MAX_QUEUE_SIZE) {
      close(CLOSE_CLIENT_GOING_AWAY, null);
      return false;
    }

    // Enqueue the message frame.
    queueSize += data.size();
    //向队列添加一个数据帧，然后运行线程进行读写
    messageAndCloseQueue.add(new Message(formatOpcode, data));
    runWriter();
    return true;
  }

//runWriter
private void runWriter() {
    if (executor != null) {
        //线程池执行
      executor.execute(writerRunnable);
    }
  }

//writerRunnable
this.writerRunnable = new Runnable() {
      @Override public void run() {
        try {
          while (writeOneFrame()) {
          }
        } catch (IOException e) {
          failWebSocket(e, null);
        }
      }
    };

//writeOneFrame
主要内容，通过WebSocketWriter来对stream进行写入内容


//initReaderAndWriter
public void initReaderAndWriter(String name, Streams streams) throws IOException {
    synchronized (this) {
      this.streams = streams;
       //初始化 WebSocketWriter
      this.writer = new WebSocketWriter(streams.client, streams.sink, random);
      this.executor = new ScheduledThreadPoolExecutor(1, Util.threadFactory(name, false));
      if (pingIntervalMillis != 0) {
          //周期执行ping帧
        executor.scheduleAtFixedRate(
            new PingRunnable(), pingIntervalMillis, pingIntervalMillis, MILLISECONDS);
      }
      if (!messageAndCloseQueue.isEmpty()) {
          //连接时进行发送消息
        runWriter();
      }
    }
	//初始化WebSocketReader，传入了回调接口，用来时刻监听socket流内容
    reader = new WebSocketReader(streams.client, streams.source, this);
  }



//loopReader
public void loopReader() throws IOException {
    while (receivedCloseCode == -1) {
      //在WebScocketReader进行循环读取接受消息（判断为控住帧或消息帧，不同处理）
      reader.processNextFrame();
    }
  }
Internal

该抽象类，仅仅被OkHttpLcient实现，用来升级内部API

//被实现在OkHttpLcient内部
@Override public Call newWebSocketCall(OkHttpClient client, Request originalRequest) {
        return RealCall.newRealCall(client, originalRequest, true);
      }
RealCall
final class RealCall implements Call {


//第三个参数，当为websocket连接的时候，是true
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    // Safely publish the Call instance to the EventListener.
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    //设置调用连接过程中的监听事件，3.11 or 3.12 之后可能为最终版，目前是3.10.0版本
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
  }
    
 //调用call.enqueue
//最终执行方法
@Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    //监听事件回调
    eventListener.callStart(this);
    //okhttpClient的dispatcher进行分发事件，，，
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }
    
    
    
//AsyncCall，，nameRunnable只是对线程改名
 final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      this.responseCallback = responseCallback;
    }

    String host() {
      return originalRequest.url().host();
    }

    Request request() {
      return originalRequest;
    }

    RealCall get() {
      return RealCall.this;
    }

    //线程池待执行内容
    @Override protected void execute() {
      boolean signalledCallback = false;
      try {
          //进行添加拦截器
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
            //回调失败
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
            //回调成功
          responseCallback.onResponse(RealCall.this, response);
        }
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }
    
    //getResponseWithInterceptorChain，，，添加拦截器
Response getResponseWithInterceptorChain() throws IOException {
    // 构建一个栈顺序的拦截器
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));
//拦截器
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    
    return chain.proceed(originalRequest);
  }

    
    
 //最终，返回的reponse，包含拦截器
  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    if (index >= interceptors.size()) throw new AssertionError();

    calls++;

      //通过索引加一将拦截器串联
    RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
        connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
      //获取当前索引的拦截器
    Interceptor interceptor = interceptors.get(index);
      //再次传入所有拦截器进行继续串联
    Response response = interceptor.intercept(next);


    return response;
  }
Dispatcher
//异步请求执行策略
//ExecutorService在内部运行调用，若自定义线程池，需要满足最大调用数量
synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
       //进入等待队列执行
      readyAsyncCalls.add(call);
    }
  }
其他相关关键词作用和分析
RealConnection

用来实际监控流

在StreamAllocation的findConnection中被实例化并进行connect

//connect
 public void connect(int connectTimeout, int readTimeout, int writeTimeout,
      int pingIntervalMillis, boolean connectionRetryEnabled, Call call,
      EventListener eventListener) {
     ...
     while (true) {
      try {
          //如果是https请求并且使用了http代理服务器
        if (route.requiresTunnel()) {
            //开启隧道连接，隧道技术，进行屏蔽不同网络类型的差异，进行通信
          connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener);
          if (rawSocket == null) {
            // We were unable to connect the tunnel but properly closed down our resources.
            break;
          }
        } else {
            //使用socket连接
          connectSocket(connectTimeout, readTimeout, call, eventListener);
        }
        establishProtocol(connectionSpecSelector, pingIntervalMillis, call, eventListener);
        eventListener.connectEnd(call, route.socketAddress(), route.proxy(), protocol);
        break;
      } catch (IOException e) {
        closeQuietly(socket);
        closeQuietly(rawSocket);
        socket = null;
        rawSocket = null;
        source = null;
        sink = null;
        handshake = null;
        protocol = null;
        http2Connection = null;

        eventListener.connectFailed(call, route.socketAddress(), route.proxy(), null, e);

        if (routeException == null) {
          routeException = new RouteException(e);
        } else {
          routeException.addConnectException(e);
        }

        if (!connectionRetryEnabled || !connectionSpecSelector.connectionFailed(e)) {
          throw routeException;
        }
      }
    }

    if (route.requiresTunnel() && rawSocket == null) {
      ProtocolException exception = new ProtocolException("Too many tunnel connections attempted: "
          + MAX_TUNNEL_ATTEMPTS);
      throw new RouteException(exception);
    }

    if (http2Connection != null) {
      synchronized (connectionPool) {
        allocationLimit = http2Connection.maxConcurrentStreams();
      }
    }
     ...
 }


//connectTunnel
private void connectTunnel(int connectTimeout, int readTimeout, int writeTimeout, Call call,
      EventListener eventListener) throws IOException {
    //创建隧道请求对象,创建request
    Request tunnelRequest = createTunnelRequest();
    HttpUrl url = tunnelRequest.url();
    for (int i = 0; i < MAX_TUNNEL_ATTEMPTS; i++) {
        //创建socket连接
      connectSocket(connectTimeout, readTimeout, call, eventListener);
        //请求开启隧道
      tunnelRequest = createTunnel(readTimeout, writeTimeout, tunnelRequest, url);

      if (tunnelRequest == null) break; // Tunnel successfully created.

      // The proxy decided to close the connection after an auth challenge. We need to create a new
      // connection, but this time with the auth credentials.
      closeQuietly(rawSocket);
      rawSocket = null;
      sink = null;
      source = null;
      eventListener.connectEnd(call, route.socketAddress(), route.proxy(), null);
    }
  }

//createTunnel
private Request createTunnel(int readTimeout, int writeTimeout, Request tunnelRequest,
      HttpUrl url) throws IOException {
    // Make an SSL Tunnel on the first message pair of each SSL + proxy connection.
    String requestLine = "CONNECT " + Util.hostHeader(url, true) + " HTTP/1.1";
    while (true) {
      Http1Codec tunnelConnection = new Http1Codec(null, null, source, sink);
      source.timeout().timeout(readTimeout, MILLISECONDS);
      sink.timeout().timeout(writeTimeout, MILLISECONDS);
      tunnelConnection.writeRequest(tunnelRequest.headers(), requestLine);
      tunnelConnection.finishRequest();
      Response response = tunnelConnection.readResponseHeaders(false)
          .request(tunnelRequest)
          .build();
      // The response body from a CONNECT should be empty, but if it is not then we should consume
      // it before proceeding.
      long contentLength = HttpHeaders.contentLength(response);
      if (contentLength == -1L) {
        contentLength = 0L;
      }
      Source body = tunnelConnection.newFixedLengthSource(contentLength);
      Util.skipAll(body, Integer.MAX_VALUE, TimeUnit.MILLISECONDS);
      body.close();

      switch (response.code()) {
        case HTTP_OK:
          if (!source.buffer().exhausted() || !sink.buffer().exhausted()) {
            throw new IOException("TLS tunnel buffered too many bytes!");
          }
          return null;

        case HTTP_PROXY_AUTH:
          tunnelRequest = route.address().proxyAuthenticator().authenticate(route, response);
          if (tunnelRequest == null) throw new IOException("Failed to authenticate with proxy");

          if ("close".equalsIgnoreCase(response.header("Connection"))) {
            return tunnelRequest;
          }
          break;

        default:
          throw new IOException(
              "Unexpected response code for CONNECT: " + response.code());
      }
    }
  }


//connectSocket
 private void connectSocket(int connectTimeout, int readTimeout, Call call,
      EventListener eventListener) throws IOException {
    Proxy proxy = route.proxy();
    Address address = route.address();

    rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
        ? address.socketFactory().createSocket()
        : new Socket(proxy);

    eventListener.connectStart(call, route.socketAddress(), proxy);
    rawSocket.setSoTimeout(readTimeout);
    try {
      //打开socket链接
      Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
    } catch (ConnectException e) {
      ConnectException ce = new ConnectException("Failed to connect to " + route.socketAddress());
      ce.initCause(e);
      throw ce;
    }
    try {
      //对socket的输入和输出处理
      source = Okio.buffer(Okio.source(rawSocket));
      sink = Okio.buffer(Okio.sink(rawSocket));
    } catch (NullPointerException npe) {
      if (NPE_THROW_WITH_NULL.equals(npe.getMessage())) {
        throw new IOException(npe);
      }
    }
  }
WebsocketReader
//Websocket进行读写流的内容，并通过RealWebSocket传入的FrameCallback接口进行回调信息
//将信息回调到RealWebSocket，然后通过listener将信息回调到用户层面

//RealWebSocket进行调用方法，循环读取
void processNextFrame() throws IOException {
    readHeader();
    if (isControlFrame) {
       //读取控制帧
      readControlFrame();
    } else {
        //读取数据帧
      readMessageFrame();
    }
  }

//readMessageFrame
private void readMessageFrame() throws IOException {
    int opcode = this.opcode;
    if (opcode != OPCODE_TEXT && opcode != OPCODE_BINARY) {
      throw new ProtocolException("Unknown opcode: " + toHexString(opcode));
    }

    //读取内容具体实现
    readMessage();

    if (opcode == OPCODE_TEXT) {
        //进行回调返回信息
      frameCallback.onReadMessage(messageFrameBuffer.readUtf8());
    } else {
      frameCallback.onReadMessage(messageFrameBuffer.readByteString());
    }
  }
RetryAndFollowUpInterceptor

重定向拦截器，位于RealCall中实例化

//重定向最大次数
private static final int MAX_FOLLOW_UPS = 20;

@Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Call call = realChain.call();
    EventListener eventListener = realChain.eventListener();

    //实例化
    StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
        createAddress(request.url()), call, eventListener, callStackTrace);
    this.streamAllocation = streamAllocation;

    int followUpCount = 0;
    Response priorResponse = null;
    while (true) {
      if (canceled) {
        streamAllocation.release();
        throw new IOException("Canceled");
      }

      Response response;
      boolean releaseConnection = true;
      try {
        //处理下层拦截器返回结果
        response = realChain.proceed(request, streamAllocation, null, null);
        releaseConnection = false;
      } catch (RouteException e) {
        // The attempt to connect via a route failed. The request will not have been sent.
          //获取下层拦截器返回的结果，然后判断是否可以重试。
        if (!recover(e.getLastConnectException(), streamAllocation, false, request)) {
          throw e.getLastConnectException();
        }
        releaseConnection = false;
        continue;
      } catch (IOException e) {
        // An attempt to communicate with a server failed. The request may have been sent.
        boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
        //获取下层拦截器返回的结果，然后判断是否可以重试。
        if (!recover(e, streamAllocation, requestSendStarted, request)) throw e;
        releaseConnection = false;
        continue;
      } finally {
        // We're throwing an unchecked exception. Release any resources.
        if (releaseConnection) {
          streamAllocation.streamFailed(null);
          streamAllocation.release();
        }
      }

      // Attach the prior response if it exists. Such responses never have a body.
      if (priorResponse != null) {
        response = response.newBuilder()
            .priorResponse(priorResponse.newBuilder()
                    .body(null)
                    .build())
            .build();
      }

     //判断是否需要重定向,内部解析响应码
      Request followUp = followUpRequest(response, streamAllocation.route());

      if (followUp == null) {
        if (!forWebSocket) {
          streamAllocation.release();
        }
        return response;
      }

      closeQuietly(response.body());

        //超过重定向次数
      if (++followUpCount > MAX_FOLLOW_UPS) {
        streamAllocation.release();
        throw new ProtocolException("Too many follow-up requests: " + followUpCount);
      }
		//不能重用的请求体
      if (followUp.body() instanceof UnrepeatableRequestBody) {
        streamAllocation.release();
        throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
      }

        //后续的请求是否可以重用Connection，则进行创建一个streamAllocation
      if (!sameConnection(response, followUp.url())) {
        streamAllocation.release();
        streamAllocation = new StreamAllocation(client.connectionPool(),
            createAddress(followUp.url()), call, eventListener, callStackTrace);
        this.streamAllocation = streamAllocation;
      } else if (streamAllocation.codec() != null) {
        throw new IllegalStateException("Closing the body of " + response
            + " didn't close its backing stream. Bad interceptor?");
      }

       //重定向的请求结果，赋值
      request = followUp;
      priorResponse = response;
    }
  }
StreamAllocation

使用该类的作用，屏蔽协议细节处理不同Connection的复用功能，，在RetryAndFollowUpInterceptor类中被实例化创建使用

StreamAllocation是用来协调Connections、Streams和Calls这三个实体的

HTTP通信 执行 网络请求（Call） 需要在 连接（Connection） 上建立一个新的 流（Stream）， StreamAllocation 是用来关联call和connection 的桥梁，它负责为一次call 寻找 connection而完成远程通信。

//newStream  ,获取一个 可用的连接(初始化resultConnection) 和 对应连接协议的编解码实例（resultCodec）
public HttpCodec newStream(
      OkHttpClient client, Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
    int connectTimeout = chain.connectTimeoutMillis();
    int readTimeout = chain.readTimeoutMillis();
    int writeTimeout = chain.writeTimeoutMillis();
    int pingIntervalMillis = client.pingIntervalMillis();
    boolean connectionRetryEnabled = client.retryOnConnectionFailure();

    try {
      RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
          writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
      HttpCodec resultCodec = resultConnection.newCodec(client, chain, this);

      synchronized (connectionPool) {
        codec = resultCodec;
        return resultCodec;
      }
    } catch (IOException e) {
      throw new RouteException(e);
    }
  }

首先尝试使用当前的变量connection. 如果当前的connection为 null, 则通过Internal.instance.get(connectionPool, address, this, null); 在 连接池 中获取对应 address 的连接 赋值给 connection，如果当前的 connection不为null，则直接返回.
如果上一步没有找到可用连接，则看是否有其他可用路由。
如果有其他路由则先去连接池查询看是否有对应连接
没有的话则创建一个新的 RealConnection，并赋值给变量 connection.
在连接池中找到的话则直接返回。
然后新创建的连接开始握手连接，然后放入连接池，然后返回。

//findHealthyConnection最终调用findConnection
//返回一个承载新的stream的连接，优先级排序：已存在的连接，连接池，最后是建立一个新连接
 private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,
      int pingIntervalMillis, boolean connectionRetryEnabled) throws IOException {
  ...
  //尝试使用当前的 connection，或者查找 连接池
  synchronized (connectionPool) {
    ...
    releasedConnection = this.connection;
    if (this.connection != null) {
      result = this.connection;
      releasedConnection = null;
    }
    if (!reportedAcquired) {
      releasedConnection = null;
    }
    if (result == null) {
      Internal.instance.get(connectionPool, address, this, null);
      if (connection != null) {
        foundPooledConnection = true;
        result = connection;
      } else {
        selectedRoute = route;
      }
    }
  }
  ...
  if (result != null) {
    return result;
  }

  //是否有其他的路由
  boolean newRouteSelection = false;
  if (selectedRoute == null && (routeSelection == null || !routeSelection.hasNext())) {
    newRouteSelection = true;
    routeSelection = routeSelector.next();
  }
  synchronized (connectionPool) {
    if (newRouteSelection) {
      //有其他路由则先去连接池查询看是否有对应连接
    }
    if (!foundPooledConnection) {
      ...
      //没有的话则创建一个新的RealConnection，并赋值给变量 connection
      result = new RealConnection(connectionPool, selectedRoute);
      acquire(result, false);
    }
  }
  // 在连接池中找到的话则直接返回
  if (foundPooledConnection) {
    eventListener.connectionAcquired(call, result);
    return result;
  }
  //新创建的连接开始握手连接
  result.connect(...);
  synchronized (connectionPool) {
    reportedAcquired = true;
    Internal.instance.put(connectionPool, result);
    ...
  }
  ...
  return result;
}
路漫修远望
关注
  • 11
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OkHttp实现WebSocket
李醉心的博客
07-21 3308
OkHttp实现WebSocket
Okhttp实现websocket链接
05-29
利用okhttp实现的websocket长链接，里面做了断线重连，我设定的是10秒重连，有需要的可以更改
用okhttp实现webSocket长连接
08-24
用okhttp实现webSocket长连接,可以接收服务端消息，向服务端发送消息,心跳包，维护长连接
OkHttp3 关于WebSocket的使用
qq_30894255的博客
03-24 2840
OkHttp3 也是支持WebSocket的，因为 android 网络请求基本都用OkHttp3，所以没必要引入其他的框架了。 import android.app.Service; import android.content.Intent; import android.os.Binder; import android.os.Handler; import android.os.IBinder; import android.util.Log; import androidx.annota.
源码角度，分析OkHttp实现WebSocket---握手-保活-数据处理---
最新发布
2401_84103344的博客
05-04 674
为数据收发做准备的第二步是，初始化用于输入输出的 Source 和 Sink。Source 和 Sink 创建于之前发送 HTTP 请求的时候。这里会阻止在这个连接上再创建新的流。Streams 是一个 BufferedSource 和 BufferedSink 的 holder：第三步是调用回调onOpen()。第四步是初始化 Reader 和 Writer：OkHttp 使用和来处理数据的收发。在发送数据时将数据组织成帧，在接收数据时则进行反向擦除，同时处理 WebSocket 的控制消息。
okhttp中websocket的使用
Welsh_summer的博客
05-15 2046
okhttp中websocket使用及实现websocket是什么websocket能做什么WebSocket之OkHttpWebSocket 保活 参考链接：https://www.cnblogs.com/plokmju/p/okhttp_weisocket.html websocket是什么 一种客户端与服务器进行全双工通讯的网络技术，属于应用层协议。它基于TCP传输协议，并复用HTTP的握手通道。 websocket能做什么 WebSocket 与 HTTP/2 一样，其实都是为了解决 HTTP/1
okhttp3使用websocket
wang_dsheng的博客
01-29 5462
小弟菜鸟一名，因为好奇，所以想研究websocket的连接，因为重来没做过，所以一路坎坷，问了不少大神，结果因为基础太差被屌的体无完肤，不过最终还是完成了！一切都是值得的。 接下来就开始讲讲如何使用okhttp3来连接websocket吧。 首先依赖 compile 'com.squareup.okhttp3:okhttp:3.8.1' okhttp3在3.5以上就开始支持webs
聊聊OkHttp实现WebSocket细节，包括鉴权和长连接保活及其原理！
Android 开发架构
03-19 1344
一、序 OkHttp 应该算是 Android 中使用最广泛的网络库了，我们通常会利用它来实现 HTTP 请求，但是实际上它还可以支持 WebSocket，并且使用起来还非常的便捷。 那本文就来聊聊，利用 OkHttp 实现 WebSocket 的一些细节，包括对 WebSocket 的介绍，以及在传输前如何做到鉴权、长连接保活及其原理。 二、WebSocket 简介 2.1 为什么使用 WebS...
最通俗易懂的使用OkHttp进行WebSocket连接教程：上来直接撸代码
热门推荐
xlh1191860939的博客
07-19 4万+
最近在项目中需要用到WebSocket来处理持续连接（persistent connection）。以前在Android端只使用过Java原生的Socket但没有使用过WebSocket，只知道OkHttp支持WebSocket。上网一搜，有些不是api太旧就是长篇大论不知所云，最终还是从国外两篇博客中得到了启发，：一篇是通过例子直接介绍使用，我决定先把这篇博客分享给大家，直接上手；另一...
Okhttp webSocket详解
qq_38996911的博客
07-05 1143
一、序 OkHttp 应该算是 Android 中使用最广泛的网络库了，我们通常会利用它来实现 HTTP 请求，但是实际上它还可以支持 WebSocket，并且使用起来还非常的便捷。 那本文就来聊聊，利用 OkHttp 实现 WebSocket 的一些细节，包括对 WebSocket 的介绍，以及在传输前如何做到鉴权、长连接保活及其原理。 二、WebSocket 简介 2.1 为什么使用 WebSocket？ 我们做客户端开发时，接触最多的应用层网络协议，就是 HTTP 协议，而今天介绍的 WebSocke
SpringBoot集成websocket（4）|（使用okhttp3实现websocket）
Oaklkm的博客
09-04 1943
HTTP是现代应用常用的一种交换数据和媒体的网络方式，高效地使用HTTP能让资源加载更快，节省带宽。OkHttp是一个高效的HTTP客户端，它有以下默认特性：支持HTTP/2，允许所有同一个主机地址的请求共享同一个socket连接连接池减少请求延时透明的GZIP压缩减少响应数据的大小缓存响应内容，避免一些完全重复的请求请求失败时自动重试主机的其他 IP，自动重定向当握手失败时会回退到TLS 1.0。
okhttp3连接websocket
sapodilla的专栏
12-12 1万+
由于度娘搜索都是一堆废话，所以自己实现了，保存一下，方便以后使用。 1、在工程中引入okhttp3： compile 'com.squareup.okhttp3:okhttp:3.5.0'2、创建WebSocket的连接： /** * 初始化WebSocket服务器 */ private void run() { OkHttpClient c
Android之基于OkHttp的websocket框架
03-22
基于okhttp的websocket的封装，实现长连接，数据回调，断开重连。
Android学习笔记
04-08
18. **网络编程**：包括HTTP/HTTPS请求、WebSocket、Socket编程，以及使用OkHttp、Retrofit等第三方库进行网络访问。 19. **Material Design**：Google推出的统一设计语言，包含了组件、颜色、图标和布局等规范，...
Android 开发实战经典课件笔记与课件Demo代码
02-25
8. **网络编程**：涉及HTTP请求库的使用（如OkHttp、Retrofit），以及WebSocket、FTP等网络协议的应用。 9. **异步处理**：包括线程和Handler机制，以及使用AsyncTask、IntentService进行异步操作。 10. **组件间...
Android开发教程笔记完全版
05-21
使用内存分析工具检测内存泄漏，通过异步编程和多线程提升应用响应速度，使用ProGuard和DexGuard进行代码混淆和优化，以提高应用安全性和运行效率。 十、Android测试 单元测试、UI测试、性能测试是Android应用质量...
Android 系统知识总结+培训课程+笔记
09-20
Android系统是全球最广泛使用的移动操作系统之一，由Google公司开发并维护。这个“Android系统知识总结+培训课程+笔记”包含了一系列深入学习Android开发的重要资料，涵盖了从基础到高级的各种主题，适合Android...
Android开发教程笔记.zip
04-08
7. **网络编程**：包括HTTP请求（如使用OkHttp或Volley库）、WebSocket通信、JSON解析（Gson或Jackson）。 8. **异步处理**：AsyncTask、Handler、Thread、Service以及现代的LiveData和ViewModel用于解决Android...
OkHttp实现分析之Websocket
tq08g2z的专栏
08-17 4979
HTML5 拥有许多引人注目的新特性，WebSocket就是其中之一。WebSocket一向有着 “Web 的 TCP ”之称。通常 WebSocket 都是用于Web的，用于构建实时的 Web 应用。它可以在浏览器和服务器之间提供一个基于 TCP 连接的双向通道。 WebSocket 协议本质上是一个基于 TCP 的协议。为了建立一个 WebSocket 连接，客户端浏览器首先要向服务器发起一个
okhttp使用websocket
11-17
OkHttp是一个支持HTTP和WebSocket的开源框架，可以用于Android和Java应用程序。使用OkHttp实现WebSocket非常简单，只需要遵循以下步骤： 1.创建OkHttpClient对象 ```java OkHttpClient client = new OkHttpClient(); ``` 2.创建WebSocket对象 ```java Request request = new Request.Builder().url("ws://echo.websocket.org").build(); WebSocket ws = client.newWebSocket(request, new WebSocketListener() { @Override public void onOpen(WebSocket webSocket, Response response) { // WebSocket连接成功 } @Override public void onMessage(WebSocket webSocket, String text) { // 接收到消息 } @Override public void onClosed(WebSocket webSocket, int code, String reason) { // WebSocket连接关闭 } @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) { // WebSocket连接失败 } }); ``` 3.发送消息 ```java ws.send("Hello, World!"); ``` 4.关闭WebSocket ```java ws.close(1000, "Goodbye, World!"); ``` 以上就是使用OkHttp实现WebSocket的基本步骤。如果需要实现断线重连，可以在onFailure方法中重新创建WebSocket对象并进行连接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值