如何实现基于OkHttp的网络监控

最新推荐文章于 2023-06-22 18:46:45 发布
最新推荐文章于 2023-06-22 18:46:45 发布
阅读量2k 收藏 5
点赞数 1
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011101777/article/details/121438407
版权

在这里插入图片描述

人一部分的愤怒来自于无法接受想到和做到之间的巨大差距！！！

本篇文章主要是介绍如何基于okhttp来实现网络请求的监控，可能很多同学要问，为啥要监控？监控主要的目标就是真实呈现和还原线上用户的使用状况，为应用整体优化提供指标和方向。平常我们在开发环境中普遍网络状况还是很好的，不能很好的反应出线上用户真实的使用情况。而加入监控后，可以从数据中发现用户的真实使用情况，并拆分请求过程中每个阶段的耗时和失败原因，然后再给予相关指标来进行优化(把锅甩出去)。

了解OkHttp

因为是基于OkHttp来实现监控，所以我们要稍微了解下OkHttp的实现，这里我们了解两个方面就行。

一次网络请求经历了哪些过程

通过域名访问的方式来请求网络时，会经历下列过程：

  1. DNS解析：通过域名服务器或者本地host将域名解析成ip地址
  2. 建立连接：三次握手
  3. 发送数据：通过GET/POST/PUT等方式将数据(header和body)发送给服务器，
  4. 接受数据：接受服务器返回数据：响应头和body
  5. 断开链接：四次挥手断开链接

OkHttp库实现了哪些网络请求过程的状态回调

OkHtt请求过程状态回调
如上图所示，该图来自于OkHttp的Wiki文档,每个过程还是比较清晰的，简单解释下

  1. callStart：一次请求开始了
  2. dns：dns解析过程
  3. connectStart: 开始建立连接了
  4. secureConnect: 开始建立TSL安全链接
  5. connectEnd: 链接建立结束：可能建立失败，失败后可以重试
  6. requestHeaders：发送请求头
  7. requestBody：发送请求body
  8. responseHeaders：客户端接受响应头
  9. responseBody:客户端接受响应body
  10. connectionReleased:链接释放
  11. callEnd:一次请求结束

那么上述流程如何反馈到代码上呢？关键类：EventListener

public abstract class EventListener {
  public static final EventListener NONE = new EventListener() {
  };

  static EventListener.Factory factory(final EventListener listener) {
    return new EventListener.Factory() {
      public EventListener create(Call call) {
        return listener;
      }
    };
  }

 
  public void callStart(Call call) {
  }

  
  public void dnsStart(Call call, String domainName) {
  }

  
  public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
  }

 
  public void connectStart(Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
  }

  public void secureConnectStart(Call call) {
  }

  public void secureConnectEnd(Call call, @Nullable Handshake handshake) {
  }


  public void connectEnd(Call call, InetSocketAddress inetSocketAddress, Proxy proxy,
      @Nullable Protocol protocol) {
  }

  public void connectFailed(Call call, InetSocketAddress inetSocketAddress, Proxy proxy,
      @Nullable Protocol protocol, IOException ioe) {
  }


  public void connectionAcquired(Call call, Connection connection) {
  }

 
  public void connectionReleased(Call call, Connection connection) {
  }

  public void requestHeadersStart(Call call) {
  }

  public void requestHeadersEnd(Call call, Request request) {
  }

  public void requestBodyStart(Call call) {
  }

  
  public void requestBodyEnd(Call call, long byteCount) {
  }

  public void responseHeadersStart(Call call) {
  }

  public void responseHeadersEnd(Call call, Response response) {
  }
  
  public void responseBodyStart(Call call) {
  }

  public void responseBodyEnd(Call call, long byteCount) {
  }
 
  public void callEnd(Call call) {
  }
 
  public void callFailed(Call call, IOException ioe) {
  }

  public interface Factory {
    EventListener create(Call call);
  }
}

上述EventListener对象是如何和请求对象RealCall建立联系的呢？

//RealCall.java
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    // Safely publish the Call instance to the EventListener.
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
  }

OkHttpClient.java
public Builder eventListenerFactory(EventListener.Factory eventListenerFactory) {
      if (eventListenerFactory == null) {
        throw new NullPointerException("eventListenerFactory == null");
      }
      this.eventListenerFactory = eventListenerFactory;
      return this;
    }

从代码可以看出，实际上可以在创建OkHttpClient对象时指定全局的EventListener对应的工厂累Factory。现在知道了回调和接入实际，就可以动手了。

实现监控

话不多说，直接上代码把：

OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
CallbackBuilder callbackBuilder = new CallbackBuilder();
Factory factory =
          new SuHttpEventListener.XYFactory(callbackBuilder.factory, callbackBuilder.stepCallback);
httpClientBuilder.eventListenerFactory(factory);

public class SuHttpEventListener extends EventListener {

  public static final String TAG = "SuHttpEventListener";
  private static final Charset UTF8 = Charset.forName("UTF-8");
  public static final int TIME_OUT_MILLS = 60 * 1000;

  private final long callStartNanos;
  private long dnsStartNano;
  private long connectStartNano;
  private long requestStartNano;
  private EventListener subEventListener;
  private SuKVEventListener stepCallback;

  private HttpData mHttpData = new HttpData();

  /**
   * 套一层的Factory
   */
  static class XYFactory implements Factory {

    private Factory subFactory;
    private SuKVEventListener mStepCallback;

    XYFactory(Factory subFactory, SuKVEventListener stepCallback) {
      this.subFactory = subFactory;
      this.mStepCallback = stepCallback;
    }

    @Override public EventListener create(Call call) {
      EventListener subListener = null;
      if (subFactory != null) {
        subListener = subFactory.create(call);
      }
      if (SuHttpMonitor.checkIsLocalHost(call.request().url().host())) {
        return new SuHttpEventListener(subListener, null);
      }
      return new SuHttpEventListener(subListener, mStepCallback);
    }
  }

  SuHttpEventListener(EventListener subEventListener, SuKVEventListener stepCallback) {
    this.subEventListener = subEventListener;
    this.stepCallback = stepCallback;
    this.callStartNanos = System.nanoTime();
  }

  @Override public void dnsStart(Call call, String domainName) {
    mHttpData.stepCode = HttpEventStep.dnsStart;
    if (subEventListener != null) {
      subEventListener.dnsStart(call, domainName);
    }
    dnsStartNano = System.nanoTime();
  }

  @Override public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
    if (subEventListener != null) {
      subEventListener.dnsEnd(call, domainName, inetAddressList);
    }
    if (dnsStartNano <= 0) {
      return;
    }
    long cost = getCost(dnsStartNano);
    if (cost < 0) {
      return;
    }
    if (stepCallback != null) {
      mHttpData.dnsCost = cost;
    }
    dnsStartNano = 0;
  }

  @Override public void connectStart(Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
    mHttpData.stepCode = HttpEventStep.connectStart;
    if (subEventListener != null) {
      subEventListener.connectStart(call, inetSocketAddress, proxy);
    }
    connectStartNano = System.nanoTime();
  }

  @Override public void secureConnectStart(Call call) {
    mHttpData.stepCode = HttpEventStep.secureConnectStart;
    if (subEventListener != null) {
      subEventListener.secureConnectStart(call);
    }
  }

  @Override public void secureConnectEnd(Call call, Handshake handshake) {
    if (subEventListener != null) {
      subEventListener.secureConnectEnd(call, handshake);
    }
  }

  @Override public void connectEnd(Call call, InetSocketAddress inetSocketAddress, Proxy proxy,
      Protocol protocol) {
    if (subEventListener != null) {
      subEventListener.connectEnd(call, inetSocketAddress, proxy, protocol);
    }
    if (connectStartNano <= 0) {
      return;
    }
    long cost = getCost(connectStartNano);
    if (cost <= 0) {
      return;
    }
    if (stepCallback != null) {
      mHttpData.proxy = proxy == null ? null : proxy.toString();
      mHttpData.inetSocketAddress =
          inetSocketAddress == null ? null : inetSocketAddress.toString();
      mHttpData.protocol = protocol == null ? null : protocol.toString();
      mHttpData.connectCost = cost;
    }
  }

  @Override public void connectionAcquired(Call call, Connection connection) {
    mHttpData.stepCode = HttpEventStep.connectionAcquired;
    if (subEventListener != null) {
      subEventListener.connectionAcquired(call, connection);
    }
    requestStartNano = System.nanoTime();
  }

  @Override public void connectionReleased(Call call, Connection connection) {
    log("connectionReleased");
    if (subEventListener != null) {
      subEventListener.connectionReleased(call, connection);
    }
    if (requestStartNano <= 0) {
      return;
    }
    long cost = getCost(requestStartNano);
    if (cost <= 0) {
      return;
    }
    if (stepCallback != null) {
      mHttpData.responseCost = cost;
    }
    requestStartNano = 0;
  }

  @Override public void connectFailed(Call call, InetSocketAddress inetSocketAddress, Proxy proxy,
      Protocol protocol, IOException ioe) {
    super.connectFailed(call, inetSocketAddress, proxy, protocol, ioe);
    log("connectFailed");
    if (subEventListener != null) {
      subEventListener.connectFailed(call, inetSocketAddress, proxy, protocol, ioe);
    }
  }

  @Override public void requestHeadersStart(Call call) {
    super.requestHeadersStart(call);
    mHttpData.stepCode = HttpEventStep.requestHeadersStart;
    if (subEventListener != null) {
      subEventListener.requestHeadersStart(call);
    }
  }

  @Override public void requestHeadersEnd(Call call, Request request) {
    super.requestHeadersEnd(call, request);
    mHttpData.requestHeaders = request.headers().toString();
    if (subEventListener != null) {
      subEventListener.requestHeadersEnd(call, request);
    }
  }

  @Override public void responseHeadersStart(Call call) {
    super.responseHeadersStart(call);
    mHttpData.stepCode = HttpEventStep.responseHeadersStart;
    if (subEventListener != null) {
      subEventListener.responseHeadersStart(call);
    }
  }

  @Override public void responseHeadersEnd(Call call, Response response) {
    super.responseHeadersEnd(call, response);
    if (subEventListener != null) {
      subEventListener.responseHeadersEnd(call, response);
    }
    mHttpData.responseCode = response.code();
    if (response.headers() != null) {
      mQttpData.responseHeaders = response.headers().toString();
    }
    if (mHttpData.responseCode != 200) {
      try {
        String errorJsonString = getErrorJsonString(response);
        mHttpData.errorMsg = errorJsonString;
        mHttpData.errorCode = getErrorCode(errorJsonString);
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }

  @Override public void requestBodyStart(Call call) {
    super.requestBodyStart(call);
    mHttpData.stepCode = HttpEventStep.requestBodyStart;
    if (subEventListener != null) {
      subEventListener.requestBodyStart(call);
    }
  }

  @Override public void requestBodyEnd(Call call, long byteCount) {
    super.requestBodyEnd(call, byteCount);
    mHttpData.requestByteCount = byteCount;
    if (subEventListener != null) {
      subEventListener.requestBodyEnd(call, byteCount);
    }
  }

  @Override public void responseBodyStart(Call call) {
    super.responseBodyStart(call);
    mHttpData.stepCode = HttpEventStep.responseBodyStart;
    if (subEventListener != null) {
      subEventListener.responseBodyStart(call);
    }
  }

  @Override public void responseBodyEnd(Call call, long byteCount) {
    super.responseBodyEnd(call, byteCount);
    mHttpData.responseByteCount = byteCount;
    if (subEventListener != null) {
      subEventListener.requestBodyEnd(call, byteCount);
    }
  }

  @Override public void callStart(Call call) {
    super.callStart(call);
    mHttpData.stepCode = HttpEventStep.callStart;
    log("callStart");
    if (subEventListener != null) {
      subEventListener.callStart(call);
    }
  }

  @Override public void callFailed(Call call, IOException ioe) {
    super.callFailed(call, ioe);
    log("callFailed");
    if (subEventListener != null) {
      subEventListener.callFailed(call, ioe);
    }
    if (callStartNanos <= 0) {
      return;
    }
    long totalCost = getCost(callStartNanos);
    if (totalCost <= 0) {
      return;
    }
    mHttpData.updateByCall(call);
    if (SuMonitorBlackList.inBlackList(mHttpData.url)) {
      //黑名单不埋点
      return;
    }
    if (!NetworkUtil.isNetworkConnected(SuHttpMonitor.getContext())) {
      return;
    }
    mHttpData.totalCost = totalCost;
    mHttpData.errorMsg = "callFailed";
    if (ioe != null) {
      StringBuilder stringBuilder = new StringBuilder();
      stringBuilder.append(mHttpData.stepCode.name())
          .append(",")
          .append(NetworkUtil.getNetWorkMsg())
          .append(",Ex:")
          .append(ioe.getClass().getSimpleName())
          .append(",Msg:")
          .append(ioe.getMessage())
          .append(",trace:");
      StackTraceElement[] stackTraceElements = ioe.getStackTrace();
      if (stackTraceElements != null && stackTraceElements.length > 0) {
        stringBuilder.append(stackTraceElements[0].toString());
      }
      mHttpData.errorMsg = stringBuilder.toString();
    }
  }

  @Override public void callEnd(Call call) {
    super.callEnd(call);
    log("callEnd");
    if (subEventListener != null) {
      subEventListener.callEnd(call);
    }
    mHttpData.updateByCall(call);
    if (SuMonitorBlackList.inBlackList(mHttpData.url)) {
      return;
    }
    if (callStartNanos <= 0) {
      return;
    }
    long totalCost = getCost(callStartNanos);
    if (totalCost <= 0) {
      return;
    }
    mHttpData.methodName = call.request().url().encodedPath();
    mHttpData.method = call.request().method();
    mHttpData.totalCost = totalCost;
    try {
      mHttpData.requestParams = getRequestParams(call.request());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private long getCost(long startNano) {
    return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNano);
  }

  private int getErrorCode(String errorJsonStr) {
    if (!TextUtils.isEmpty(errorJsonStr)) {
      JSONObject errorJson;
      try {
        errorJson = new JSONObject(errorJsonStr);
        return errorJson.optInt("errorCode");
      } catch (JSONException e) {
        e.printStackTrace();
      }
    }
    return 0;
  }

  private String getErrorJsonString(Response response) throws Exception {
    ResponseBody responseBody = response.body();
    if (responseBody != null && response.code() != 200) {
      BufferedSource source = responseBody.source();
      // Buffer the entire body.
      try {
        source.request(Long.MAX_VALUE);
      } catch (IOException e) {
        e.printStackTrace();
      }
      Buffer buffer = source.buffer();
      Charset charset = UTF8;
      MediaType contentType = responseBody.contentType();
      if (contentType != null) {
        charset = contentType.charset(UTF8);
      }
      if (isPlaintext(buffer) && charset != null) {
        return new String(buffer.clone().readByteArray(), charset);
      }
    }

    return null;
  }

  private static boolean isPlaintext(Buffer buffer) {
    try {
      Buffer prefix = new Buffer();
      long byteCount = buffer.size() < 64 ? buffer.size() : 64;
      buffer.copyTo(prefix, 0, byteCount);
      for (int i = 0; i < 16; i++) {
        if (prefix.exhausted()) {
          break;
        }
        int codePoint = prefix.readUtf8CodePoint();
        if (Character.isISOControl(codePoint) && !Character.isWhitespace(codePoint)) {
          return false;
        }
      }
      return true;
    } catch (EOFException e) {
      // Truncated UTF-8 sequence.
      return false;
    }
  }

  private static String getRequestParams(Request request) throws Exception {
    RequestBody requestBody = request.body();
    boolean hasRequestBody = requestBody != null;
    if (!hasRequestBody) {
      return null;
    }
    Buffer buffer = new Buffer();
    requestBody.writeTo(buffer);
    Charset charset = UTF8;
    MediaType contentType = requestBody.contentType();
    if (contentType != null) {
      charset = contentType.charset(UTF8);
    }
    String param = null;
    if (isPlaintext(buffer) && charset != null) {
      param = URLDecoder.decode(new String(buffer.readByteArray(), charset));
    }
    return param;
  }

  private void log(String message) {
   
  }
}

public final class CallbackBuilder {

    public EventListener.Factory factory;
    public SuKVEventListener stepCallback;
    public boolean isDebug;
  }

public interface SuKVEventListener {
  //通知业务测上报
  void onKVEvent(String eventId, HashMap<String, String> params);

}

class HttpData {

  /**
   * {{@link Proxy}}
   */
  public String proxy;
  /**
   * {{@link InetSocketAddress}}
   */
  public String inetSocketAddress;
  /**
   * {{@link Protocol}}
   */
  public String protocol;
  // http or https
  public String schema;
  // 域名 medi.rthdo.com
  public String domain;
  // GET,POST
  public String method;
  // 服务名 api/rest/xxx/xxx
  public String methodName;
  // url
  public String url;
  //DNS的耗时
  public Long dnsCost;
  //建连耗时
  public Long connectCost;
  //服务器响应耗时
  public long responseCost;
  //网络请求总耗时
  public long totalCost;
  //TraceId,用于全链路监控
  public String traceId;
  //请求参数
  public String requestParams;
  //错误信息
  public String errorMsg;
  //本地错误码-40,-20
  public HttpEventStep stepCode = HttpEventStep.begin;
  //Http状态码 200 ,404
  public Integer responseCode;
  //小影错误码,无用
  public int errorCode;
  //请求包体大小
  public long requestByteCount;
  //响应包体大小
  public long responseByteCount;
  //请求头
  public String requestHeaders;
  //响应头
  public String responseHeaders;

  public void updateByCall(Call call) {
    schema = call.request().url().scheme();
    domain = call.request().url().host();
    method = call.request().method();
    methodName = call.request().url().encodedPath();
    url = call.request().url().toString();
  }

  public String getStatusCode() {
    int statusCode;
    if (responseCode != null && responseCode != 0) {
      statusCode = responseCode;
    } else {
      statusCode = stepCode.getClientStatusCode();
    }
    return String.valueOf(statusCode);
  }

  public boolean isFirst() {
    return dns() && connect();
  }

  public boolean dns() {
    return dnsCost != null && dnsCost >= 0;
  }

  public boolean connect() {
    return connectCost != null
        && connectCost >= 0;
  }
}
三村阿明
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于okhttp的网络框架
12-03
最全的回调教程啊，实现okhttp,如有疑问，可以扣我。
Android网络性能监控方案
Mobile_code的博客
11-10 831
阿里云 云原生应用研发平台EMAS 刘宝文（木睿） 背景 移动互联网时代，移动端极大部分业务都需要通过App和Server之间的数据交互来实现，所以大部分App提供的业务功能都需要使用网络请求。如果因为网络请求慢或者请求失败，导致用户无法顺畅的使用业务功能，会对用户体验造成极大影响。 此外，EMAS对外提供的APM之前并不包括网络监控功能，而网络性能监控作为移动端性能监控的重要组成部分，我们急需补全这部分能力来完善APM的产品功能，进一步满足客户的需求。 “阿里巴巴应用研发平台 EMAS 是国内领
Android之基于OkHttp的websocket框架
03-22
基于okhttp的websocket的封装，实现长连接，数据回调，断开重连。
android替换Glide通讯组件为Okhttp并监控加载进度
11-21
主要实现将Glide通讯组件更换为当下最流行的网络加载框架Okhttp，并且通过拦截器实现图片加载进度，demo中还包括更换缓存路径和更换加载模式为ARGB_8888功能等
Android基于OkHttp实现下载和上传图片
08-26
主要为大家详细介绍了Android基于OkHttp实现下载和上传图片功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于OkHttp的Http监控
jhyshenyu的专栏
09-02 2069
Http请求过程 指标数据 1.入队到请求结束耗时 2.dns查询耗时 3.socket connect耗时 4.tls连接的耗时 5.请求发送耗时 6.响应传输耗时 7.首包耗时 8.响应解析耗时 9.Http错误，区分业务错误和请求错误 采集到以上指标，结合数据可视化的工具，可以对Http个阶段的耗时和错误分布有直观的感受，同时对优化业务Http请求提供数据支持。 如何获取指标 获取指标数据...
基于okhttp的拦截器实现网络监听插件
火虫的博客
10-11 237
原理：基于HttpLoggingInterceptor的Log的接口实现，把log输出悬浮窗上面，方便测试人员观察或者后台开发人员观察我们接口的访问 使用到的技术： okhttp的拦截器 悬浮窗技术 可以根据自身的需求调整我代码 整体代码结果如下所示： https://www.douban.com/note/780409001/ https://www.douban.com/note/780409078/ https://www.douban.com/note/780409181/ https://
广播监听网络状态
ZhangXuxiaoqingnian的博客
07-13 303
在oncreat中进行注册广播IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE"); networkChangeReceiver = new NetWord(); //这个是自己写的广播接收者 registerReceive...
P08 方法入门
李晋江的博客
08-07 353
方法入门
Android 使用okhttp监控网络数据
工宗浩生财指南针
06-22 2170
这里使用Okhttp写了一个demo来监听网络请求过程中的一系列数据，包括当前网络类型、请求体、响应体大小，url，请求方式，当然还有本次核心获取域名解析时长，建立连接时长，保持连接时长，请求总时长这些数据。时间的计算用的是System.nanoTime()，返回正在运行的Java虚拟机的高分辨率时间源的当前值，单位为纳秒。5.connectEnd: 链接建立结束：可能建立失败，失败后可以重试。4.接受数据：接受服务器返回数据：响应头和body。5.断开链接：四次挥手断开链接。2.dns：dns解析过程。
OkOne：基于okhttp库的网络性能优化框架
02-04
好吧 基于okhttp库的网络性能优化框架 简介 在APP项目中可能会包含多个组件模块，或依赖多个三方库，其中可能有使用到okhttp框架进行网络请求。不同的组件模块和三方库间相互创建OkHttpClient实例，或有开发者未通过单例缓存OkHttpClient，或者每次重新请求一次新建，这样将造成浪费和导致无法充分利用okhttp的请求和连接池等控制和优化措施。 借助该OkOne库可以无侵入地将分散在不同组件中的OkHttpClient进行收敛，由OkOne进行统一复用和管理.OkOne会比较OkHttpClient.Builder进行区分复用，即相同配置的OkHttpClient.Buil
Okhttp网络框架封装
12-28
Android 开发 Okhttp网络框架复用机制，基于Okhttp创建
Android 基于协程OkHttp网络请求工具.zip
最新发布
04-24
android
Android-基于RxJava封装的OkHttp网络请求库
08-13
基于RxJava封装的OkHttp网络请求库
BlockCanary介绍
柒月
11-15 3494
BlockCanary是什么 BlockCanary是一个Android平台的一个非侵入式的性能监控组件，应用只需要实现一个抽象类，提供一些该组件需要的上下文环境，就可以在平时使用应用的时候检测主线程上的各种卡慢问题，并通过组件提供的各种信息分析出原因并进行修复。 取名为BlockCanary则是为了向LeakCanary致敬，顺便本库的UI部分是从LeakCanary改来的。 BlockCanary设计原理 上图是BlockCanary的工作流程图，整个流程分为三个部分，分别是监控卡顿、捕获现场、保存.
ARouter实现原理解析
柒月
06-02 2549
相关角色： ARouter:负责提供客户端使用的Api接口，采用了门面模式，实际上内部委托给了_ARouter去处理 _ARouter:路由中心控制器，负责控制整个路由的流程，通过Postcard中的信息导航客户端到目标地址（启动某个Activity或者获取某个服务的实现等） LogisticsCenter:后勤中心，负责注册路由信息到Warehouse和根据path或者Postcard到数据仓库...
Glide系列-Webp如何被解析使用
柒月
12-04 1950
上周接到leader吩咐，说项目中feed流占用的内存有点大，而且在低端手机上页面渲染很慢，需要排查下。所以大致梳理了下Glide中Webp资源的解析过程。如有不正确的地方，烦请斧正，一起进步。 如何通过Glide加载Wepb并展示 目前博主所在的项目使用的第三方开源库来加载webp的，所以第一步????添加依赖 implementation "com.github.bumptech.glide:glide:4.8.0" implementation "com.github.bumptech.glide:o
一次Android权限删除经历
柒月
12-27 1511
** 1.事发经过 ** 近期google play发布了新的政策，其中一部分是限制权限使用，只允许满足条件的使用场景才能申请权限，小编所在的项目被检测出使用了RECEIVE_SMS权限，但是从app下的Androidmanifest文件中并未发现有该权限的注册，所以该权限是哪里来的呢？ 2.初步定位 首先使用android studio查看了打包出来的apk中的Androidmanifest文件...
Java 实现OkHttp3网络请求代码
04-05
OkHttp3是一款基于Java实现的HTTP客户端库，可以用于发送HTTP/HTTPS请求。下面是一个简单的Java代码示例，展示如何使用OkHttp3发送网络请求： ``` import okhttp3.*; import java.io.IOException; public class OkHttp3Example { public static void main(String[] args) { // 创建OkHttpClient对象 OkHttpClient client = new OkHttpClient(); // 创建Request对象，设置请求地址和请求方法 Request request = new Request.Builder() .url("https://www.example.com") .method("GET", null) .build(); // 发送请求并获取响应 try { Response response = client.newCall(request).execute(); if (response.isSuccessful()) { // 响应成功 String responseBody = response.body().string(); System.out.println(responseBody); } else { // 响应失败 System.out.println("Response code: " + response.code()); } } catch (IOException e) { e.printStackTrace(); } } } ``` 上述代码中，创建了一个OkHttpClient对象，用于发送网络请求。然后创建了一个Request对象，设置请求地址和请求方法。最后使用OkHttpClient对象的newCall方法发送请求，并从响应中获取响应体内容。如果响应成功，就输出响应体内容；如果响应失败，就输出响应状态码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值