Dex_
Dex_

Retrofit2.9.0源码解析

前言

之前讲过了okhttp的超级概括的原理解析，okhttp以它优秀的线程池设计，任务队列的分配和转化以及基于责任链模式设计的5大拦截器的使用被广大开发者间接引入。等等，为啥是间接？你点进来的时候相信已经有了答案，当然是因为Retrofit的横空出世。当我们使用okhttp的时候肯定得去封装一层，封装的时候得考虑到主、子线程的切换，api返回值的转化处理等等。当你哼哧哼哧或者嘻嘻哈哈封装完毕后，某个小伙伴说他用不习惯，他更愿意去做成XXXX+YYYY+okhttp的模式。这个时候你是选择把他k.o.还是自己默默按照他的方式再来一套呢？当然是选择retrofit啦，所以retrofit还是一个增进队友之间友谊的软工具。接下来让我们一步一步的深挖这个优秀的开源框架是怎么让友谊的小船越走越远的。

使用

public class MainActivity extends AppCompatActivity {
    public static final String API_URL = "https://api.github.com";

    public void request(View view) {
        Retrofit retrofit =
                new Retrofit.Builder()
                        .client(new OkHttpClient())
                        .callFactory(new OkHttpClient())
                        .baseUrl(API_URL)
                        //.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                        //.addConverterFactory(GsonConverterFactory.create())
                        .build();

        // Create an instance of our GitHub API interface.
        GitHub github = retrofit.create(GitHub.class);

        // Create a call instance for looking up Retrofit contributors.
        Call> call = github.contributors("square", "retrofit");

        // Fetch and print a list of the contributors to the library.
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    List contributors = call.execute().body();
                    Log.e("ss", contributors.toString());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        request(null);
    }

    public interface GitHub {
        @GET("/repos/{owner}/{repo}/contributors")
        Call> contributors(@Path("owner") String owner, @Path("repo") String repo);
    }

    public static class Contributor {
        public final String login;
        public final int contributions;

        public Contributor(String login, int contributions) {
            this.login = login;
            this.contributions = contributions;
        }

        @Override
        public String toString() {
            return "Contributor{" +
                    "login='" + login + '\'' +
                    ", contributions=" + contributions +
                    '}';
        }
    }

}

以上代码是从官网的sample中拷贝的一段，除了线程那边，其他差不多都一样，把代码原样拷贝到as项目中是可以直接运行的。使用上就说到这里（然而并没有说啥）。相信大家对Retrofit的使用早就烂熟于心，甚至看完我写的样例代码后，起身怒拍桌子。所以这里就不多赘述，我们开始撕源码。

retrofit的封装模式其实就是将okhttp覆盖了一层更加友好的调用方式，它本质还是得靠okhttp来执行网络请求，就像一把剑，如果单有锋利的剑身，没有剑柄和剑鞘，虽然也能杀敌，但是首先得自损八百。当照顾到使用者习惯后加上了剑柄和剑鞘，甚至再付个魔，使用起来肯定事半功倍，但是真正起作用的只有剑身。retrofit和okhttp的爱恨纠葛大概说起来就是下面这张图:

image-20210423091905259

读源码最简单的方式就是从使用上入手，所以，我们就从上面的样例代码中开始，看看Retrofit的工作流程。

Retrofit.build()方法究竟做了什么

retrofit使用的是构建模式创建实例，我们重点看下它最终build的时候做了哪些事情

  1. 判断是否有baseUrl

    if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

  1. 赋值callFactory，这个callFactory其实就是okhttpClient

    okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

    如果没有值就默认给OkHttpClient，使用Retrofit.client(okhttpClient)也是给callFactory赋值

    /**
 * The HTTP client used for requests.
 *
 * 
    This is a convenience method for calling {@link #callFactory}.
 */
public Builder client(OkHttpClient client) {
  return callFactory(Objects.requireNonNull(client, "client == null"));
}

/**
 * Specify a custom call factory for creating {@link Call} instances.
 *
 * 
    Note: Calling {@link #client} automatically sets this value.
 */
public Builder callFactory(okhttp3.Call.Factory factory) {
  this.callFactory = Objects.requireNonNull(factory, "factory == null");
  return this;
}

  2. 赋值callbackExecutor

    Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
  callbackExecutor = platform.defaultCallbackExecutor();
}

    通过上面的代码可以看到，如果没有设置，就默认给出platform.defaultCallbackExecutor()，那这个默认又个是啥？callbackExecutor究竟是干嘛用的？我们点进去康康

    class Platform {
    ...
  @Nullable
  Executor defaultCallbackExecutor() {
    return null;
  }
    ...
}

    Platform，顾名思义，就是平台，我们初步判断这个类其实就是选择平台用的，但是return null???，直觉告诉我事出反常必有妖，肯定是哪里把这个方法给重写了。

    static final class Android extends Platform {
    ...
    @Override
    public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }
    ...
}

    果然是这样，是一个叫Android的类复写了这个方法，那是在哪里对这个Platform进行赋值了呢？

    public static final class Retrofit.Builder {
    ...
    public Builder() {
          this(Platform.get());
        }
    ...
}

    其实就是在创建Retrofit的Builder的时候就已经对所选平台进行了赋值，具体的赋值方法如下

    class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }
  private static Platform findPlatform() {
    return "Dalvik".equals(System.getProperty("java.vm.name"))//就是这一行代码确定了平台
        ? new Android() //
        : new Platform(true);
  }
    ...
}

    确定了平台后，再看看Android平台下是怎么赋值defaultCallbackExecutor的

      static final class Android extends Platform {
      ...
    @Override
    public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }
      ...

    static final class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override
      public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

    defaultCallbackExecutor方法就是构造了一个MainThreadExecutor的实例，这个实例里面有个new Handler(Looper.getMainLooper());很熟悉有木有，看到这里我们大概能猜出来了，Retrofit.callbackExecutor这个成员变量其实就是一个用来切换线程的东东，在执行了execute方法后会切换到主线程。

  3. 赋值callAdapterFactories

    // Make a defensive copy of the adapters and add the default Call adapter.
List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

    上述代码中callAdapterFactories，就是一个工厂模式，这里是做成了列表，表示能创建不同的callAdapter，这个callAdapter其实就是类比到okhttp中的Call，网络请求的关键一步（call.equeue(),call.execute()）就是由这个来做的（先这么认为，建立一个概念）。这里要看看最后那行platform.defaultCallAdapterFactories(callbackExecutor)，是不是感觉很熟悉，这里其实就是做了两件事情，第一步：把你之前在Retrofit.addCallAdapterFactory(RxJava2CallAdapterFactory.create()).build()中添加的RxJava2CallAdapterFactory这个实体给放到callAdapterFactories列表中。第二步：将平台中默认的callAdapterFactory也放在这个列表中。那么平台默认的AdapterFactory长啥样？

    List defaultCallAdapterFactories(
 @Nullable Executor callbackExecutor) {
        DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
        return hasJava8Types
            ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
            : singletonList(executorFactory);
  }

    这个方法中也做了两件事，首先创建一个平台默认的callAdapterFactory（DefaultCallAdapterFactory），然后判断hasJava8Types，如果为false，就将这个DefaultCallAdapterFactory放入到列表中并返回。使用singletonList方法是使用定长列表，为了减少内存分配（要不人怎么能去写开源框架呢，什么事情都做到极致——暗示点赞）。如果为true那就除了DefaultCallAdapterFactory外还要额外加一个CompletableFutureCallAdapterFactory，那hasJava8Types是何时被确定下来的呢？

    class Platform {
    ...
    Platform(boolean hasJava8Types) {
    this.hasJava8Types = hasJava8Types;
        ...
    }
}

    上述代码得知，是通过构造方法确认的，所以要去Android类下看看Android是怎么确定这个值的

      static final class Android extends Platform {
    Android() {
      super(Build.VERSION.SDK_INT >= 24);
    }
      ...
  }

    很简单，只有当sdk>=24时才为true，为什么要做这样的一个判断？因为java1.8有一个新特性叫CompletableFuture，这里不去深挖了，感兴趣的同学可以狗哥一下（狗哥一下，就是强大——暗示点赞）。

  4. 赋值converterFactories

    List converterFactories =
 new ArrayList<>(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());

// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
converterFactories.addAll(platform.defaultConverterFactories());

    converterFactories就是给服务端的返回值进行一个转化用的，这里面的代码做了几件事情。

    • 创建一个List converterFactories列表，这个列表的长度设置成在build中配置的converterFactories的长度加平台中的默认ConverterFactories的长度+1
    • 添加BuiltInConverters转换工厂，这里给出了注释，狗哥翻译：首先添加内置转换器工厂。 这可以防止覆盖其行为，但也可以确保使用使用所有类型的转换器时的正确行为。大概意思就是个内置转换器，用来处理一些奇葩的返回，比如Stream，Buffer,Void,甚至kotlin中的Unit
    • 添加用户自定义的转换工厂
    • 添加平台中的转化工厂，这个和第一步中的platform.defaultConverterFactoriesSize()平台工厂列表长度相呼应，如果平台中有转换工厂列表就有size，如果没有size 就等于0。

    平台默认工厂列表有哪些？看代码

    class Platform {
    ...
    List defaultConverterFactories() {
        return hasJava8Types ? singletonList(OptionalConverterFactory.INSTANCE) : emptyList();
    }
    int defaultConverterFactoriesSize() {
        return hasJava8Types ? 1 : 0;
     }
    ...
}

    我们看到了熟悉的hasJava8Types，这个就不多说了，如果为true的时候会添加一个这个工厂，同时返回的defaultConverterFactoriesSize会等于1，和上一段代码相呼应。

  5. 在一切都准备就绪后，一个Retrofit实例就成功创建出来了

    return new Retrofit(
          callFactory,
          baseUrl,
          unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories),
          callbackExecutor,
          validateEagerly);
    }

    上面代码中的unmodifiableList，其实是Collections.unmodifiableList()这个方法的大概意思就是，你不能这样去添加一个factory工厂：Retrofit.getConverterFactories().add(......)，如果这么做就会报错。这样写的意图是为了代码的健壮性。

前菜结束，下面来几个正餐

Retrofit.create()方法究竟做了什么

直接上代码

public  T create(final Class service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                  throws Throwable {
                // If the method is a method from Object then defer to normal invocation.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }

唉咦！！Proxy.newProxyInstance，乍一看仿佛又看到了熟悉的东西，仔细一看，还确实是动态代理，代理就是将某个对象的一些方法交给第二个对象（代理对象）去完成。举一个很形象的例子。

特能诌公司产了型号为never-stop-740的电瓶车（以下简写740电瓶车），这款740电瓶车根本刹不住车，N女士当时不知道有问题，买回来后出了事情，去特能诌公司讨要说法，但是无果，这时候N女士需要一个更加强大的人来代替她去要说法。
于是她就委托X律师全权处理刹车失灵的事情。X律师一开始也和N女士一样去特能诌先去讨要说法，但是无果，这个时候X律师就想办法要到了740电瓶车的出厂清单，然后找专业人士去分析这个清单，最后实锤740电瓶车确实是因为技术问题导致刹车失灵，然后X律师拿着740电瓶车刹车失灵的清单报告将特能诌公司告上了法庭，在充足的证据面前特能诌不得不对N女士进行了道歉，X律师完成了N女士的讨回公道的请求。

我们看看N女士的整个过程，首先N女士有一个“讨回公道”的要求，但是因为特能诌比较能诌，显然N女士自己不能完成，于是她就找了代理X律师，X律师代理后首先也是去特能诌讨说法（和N女士一样），但是X律师的手段比N女士多得多，又是联系厂商出报告，又是找专业人士分析报告，又是将特能诌告上法庭，最终完成了N女士“讨回公道”的需要。

从上面的例子中可以看出代理的作用就是将原来实体可以实现的给实现掉，甚至还能把原来实体的功能进行增强，从代码中看

public interface GitHub {
        @GET("/repos/{owner}/{repo}/contributors")
        Call> contributors(@Path("owner") String owner, @Path("repo") String repo);
    }

这里的GitHub类可以看成是N女士，她有一个诉求就是执行contributors方法，获取到git的仓库列表。显而易见，你GitHub只不过是一个小小接口，啥都干不了，你还想去通过网络请求去获取git仓库列表？真是小小接口，可笑可笑。就像是N女士面对特能诌讨说法束手无策一样。但是这时候GitHub接口去找到了动态代理Proxy.newProxyInstance(...)，这个动态代理可以看成是X律师，这个动态代理可以把GitHub接口中配置的东西（@Get()中的api，contributors方法中的各种请求需要的参数）全部转化为okhttp需要的参数，然后顺便再将请求通过okhttp发送出去，甚至当数据返回时还能帮忙把数据解析成想要的格式。这真是“山重水复疑无路，柳暗花明又一村”啊。

那为什么要选择动态代理呢，如果是选择静态代理，那GitHub有多少种方法，在静态代理中就要增加多少个对应的方法。动态代理采用了反射机制，将所有的请求全部都流经这个动态代理的invoke()方法中，对于使用者来说如果你将来想要往里面添加请求，比如获取某个列表的详情，那只要像contributors方法一样添加一个声明类的方法即可，动态代理会帮你处理剩下的事情。对，没错，是耗性能，但是retrofit用了这么久，它不香吗？

接下来我们看看这个动态代理究竟帮助我们做了哪些重要的事情

首先要明确一个重要的概念

GitHub github = retrofit.create(GitHub.class);

上述代码执行完后其实只是创建了一个代理，下述代码中的InvocationHandler.invoke方法并不会马上被执行

public  T create(final Class service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                  throws Throwable {
                // If the method is a method from Object then defer to normal invocation.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);//代码30
              }
            });
  }

那什么时候被执行？就是执行下述代码的时候

Call> call = github.contributors("square", "retrofit");

为什么呢？当GitHub github = retrofit.create(GitHub.class);这个代码执行后，实际上github 这个类已经不是它自己了，而是一个代理（X律师）。那代理总归是能代替原来的实体做事情的，它做的事情都会流经invoke。那原来的实体要做什么呢，就是执行contributors()方法。动态代理中的原理也需要深入源码去分析，现在只要知道只有在代理执行方法的时候才会执行invoke方法就行，以后会出一个动态代理源码分析的记录。而invoke()方法中的method，就相当于contributors()这个方法

明确了这一点后我们看看github(代理).contributors方法会执行哪些东西：

  • private final Platform platform = Platform.get(); 获取当前平台

  • return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);

    执行方法

    其中这里首先会判断下当前需要执行的方法是不是默认方法，我们跟进去看一眼

    boolean isDefaultMethod(Method method) {
    return hasJava8Types && method.isDefault();
}

    hasJava8Types我们先不管，因为它true和false都有可能。跟进method.isDefault()方法

    /**
 * Returns {@code true} if this method is a default
 * method; returns {@code false} otherwise.
 *
 * A default method is a public non-abstract instance method, that
 * is, a non-static method with a body, declared in an interface
 * type.
 *
 * @return true if and only if this method is a default
 * method as defined by the Java Language Specification.
 * @since 1.8
 */
 public boolean isDefault() {
     // Android-changed: isDefault() implemented using Executable.
     return super.isDefaultMethodInternal();
 }

    看注释，这又是一个java8的新特性，意思是如果被default修饰符修饰那就返回true，否则返回false。这里再多一嘴这个新特性

    通常我们写接口类的方法时一般只能写它的类似声明的一个方法，而不能写具体的实现，但是java8中你一旦加入了这个default修饰符后，你就可以去写具体的实现。就像这样

    interface MyInterface {
    default void eat() {
        System.out.println("I eat beef");
    }
}

    意思是如果有个类你implement这个接口类，那你不去实现这个eat()方法，那我就调用默认的 System.out.println("I eat beef");

    显然一般来说我们不可能多去写这么个东西，所以method.isDefault()肯定返回false，从而platform.isDefaultMethod(method) 这个肯定返回false，从而肯定会执行loadServiceMethod(method).invoke(args)这个方法，这个方法分两步走

    第一步：loadServiceMethod(method)，我们跟进去看看

    public final class Retrofit {
    private final Map> serviceMethodCache = new ConcurrentHashMap<>();  
        ...
    ServiceMethod loadServiceMethod(Method method) {
        ServiceMethod result = serviceMethodCache.get(method);//代码1
        if (result != null) return result;

        synchronized (serviceMethodCache) {
          result = serviceMethodCache.get(method);
          if (result == null) {
            result = ServiceMethod.parseAnnotations(this, method);//代码2
            serviceMethodCache.put(method, result);
          }
        }
        return result;
      }
        ...
}

    这个方法中代码1首先从serviceMethodCache这个map中找method对应的ServiceMethod，如果没有就走代码2新建一个，然后通过key = method,value = ServiceMethod的方式将ServiceMethod存入map中。为啥要这样干，很显然，这是为了性能，ServiceMethod.parseAnnotations方法中存在了大量的反射，反射本身是很耗性能的，我们的ServiceMethod可谓得之不易，非常珍贵，这么珍贵的资源当然得存起来，万一下次再用，我就不用重新再次拼命反射获得了。再深入一下，看看ServiceMethod.parseAnnotations究竟是干嘛的

    abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
      ...
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  ...
}

    从上述代码看出这里会做两件事情RequestFactory.parseAnnotations(retrofit, method);和return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);，接下来我们展开讲讲这两个方法

RequestFactory.parseAnnotations(retrofit, method)方法究竟做了什么

看下面的代码

final class RequestFactory {
  static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
  }
    ...
  RequestFactory build() {
      for (Annotation annotation : methodAnnotations) {//代码1
        parseMethodAnnotation(annotation);//代码3
      }
        ...

      int parameterCount = parameterAnnotationsArray.length;//代码4
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
      }
        ...

      return new RequestFactory(this);//代码6
    }
    ...
}
...
  static final class Builder {
      ...
      final Annotation[] methodAnnotations;
      final Annotation[][] parameterAnnotationsArray;
      ...
      Builder(Retrofit retrofit, Method method) {
            ...
          this.methodAnnotations = method.getAnnotations();//代码2:获取方法上的注解
          this.parameterAnnotationsArray = method.getParameterAnnotations();//代码5：获取方法中参数的注解
            ...
    }
  }

调用了parseAnnotations方法后，会直接调用build()方法，这个build方法首先会执行代码1这个循环的作用就是取出方法上的所有注解以及内容（代码2中展示了怎么获取方法上的注解），然后进行一个url的字符拼接和确定是post/get/put/...的请求。具体的方法就在代码3中，我们跟进去看看

private void parseMethodAnnotation(Annotation annotation) {
    //设置是什么类型的请求
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);//代码4
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      }
        ...
     //设置头部
        else if (annotation instanceof retrofit2.http.Headers) {
        String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
        if (headersToParse.length == 0) {
          throw methodError(method, "@Headers annotation is empty.");
        }
        headers = parseHeaders(headersToParse);
      } 
        ...
    }

其中代码4中的第二个参数取的就是url后面的东西，比如我的样例中请求方法的头部是这样的@GET("/repos/{owner}/{repo}/contributors") 那取的就是括号中的字符，具体怎么解析的，我们看代码

    private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      if (this.httpMethod != null) {
        throw methodError(
            method,
            "Only one HTTP method is allowed. Found: %s and %s.",
            this.httpMethod,
            httpMethod);
      }
      this.httpMethod = httpMethod;
      this.hasBody = hasBody;

      if (value.isEmpty()) {
        return;
      }

      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');
      if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
          //这里是大括号的正则
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);

      this.relativeUrl = value;
          //这里是将所有的大括号中的内容根据正则取出赋值给relativeUrlParamNames
      this.relativeUrlParamNames = parsePathParameters(value);
    }

简单来说，就是保存当前是什么类型的请求，然后请求中的？后面的内容取出来，还有就是替换掉{XXX}中包含的东西并保存好。

代码4开始，就是获取方法中参数的注解并保存到ParameterHandler[] parameterHandlers中，我们可以看到，在代码5中实际上是用了二维数组来保存方法中参数的注解的，这是因为，方法中的参数注解可以有多个比如这个样子

Call> contributors(@Field ("ss")@Path("owner") String owner)

所以parameterAnnotationsArray的含义是parameterAnnotationsArray[参数][注解]，参数可以有很多个，每个参数中对应的注解也可以有很多个

最后执行代码6返回，接下来分析HttpServiceMethod.parseAnnotations

HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory)方法究竟做了什么

总体来说这个方法就是做了两件事

  • 选择合适此次请求的CallAdapter
  • 选择合适此次请求的Converter

为什么是“合适此次请求”？很简单，我们构建Retrofit的时候肯定可以这样干

new Retrofit.Builder()
                        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                        .addCallAdapterFactory(RxJava2CallAdapterFactoryB.create())
                        .addCallAdapterFactory(RxJava2CallAdapterFactoryC.create())
                        .addConverterFactory(GsonConverterFactory.create())
                        .addConverterFactory(GsonConverterFactoryB.create())
                        .addConverterFactory(GsonConverterFactoryC.create())

那你搞出这么多的CallAdapter和Converter的工厂，真正在请求的时候，Retrofit肯定只会用到一个啊，那不得通过返回值来筛选一下子啊，听懂掌声——暗示点赞

具体我们跟进代码中看看

  static  HttpServiceMethod parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;

    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    if (isKotlinSuspendFunction) {//代码7
        ...
    } else {
      adapterType = method.getGenericReturnType();//代码8
    }

    CallAdapter callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);//代码10
    Type responseType = callAdapter.responseType();
      ...
    Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);//代码11

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);//代码9
    } else if (continuationWantsResponse) {
      ...
    } else {
       ...
    }
  }

首先要明确一点，HttpServiceMethod是继承ServiceMethod的，然后我们往里面看看。

首先看到代码7这是一个判断是否为kotlin的Suspend关键字的挂起方法，显然不是，所以执行到了代码8这个代码的意思是获取请求网络方法的返回值，想想也对，我们要确认是哪个CallAdapter或者Convert那不得从返回值的类型入手嘛。

接下来执行到了代码10，这段代码就是帮我们选择合适的CallAdapter的，究竟是怎么筛选的呢，来来来我们深入了解下

abstract class HttpServiceMethod extends ServiceMethod {
    ...
    private static  CallAdapter createCallAdapter(
      Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
    try {
      //noinspection unchecked
      return (CallAdapter) retrofit.callAdapter(returnType, annotations);//代码12
    } catch (RuntimeException e) { // Wide exception range because factories are user code.
      throw methodError(method, e, "Unable to create call adapter for %s", returnType);
    }
  }
    ...
}

public final class Retrofit {
    ...
    public CallAdapter callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);//代码13
  }
  public CallAdapter nextCallAdapter(
      @Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {//代码15
    ...
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter adapter = callAdapterFactories.get(i).get(returnType, annotations, this);//代码14
      if (adapter != null) {
        return adapter;
      }
    }
    ...
}

如上述代码，首先我们的代码10执行后会有一系列的跳转：代码10->代码12->代码13->代码15，直接看代码15，代码15中有一个skipPast的参数是告诉程序，你不用给我找从第一个CallAdapter.Factory到skipPast之间的所有CallAdapter.Factory了，你给我直接从skipPast后面开始for循环。显然代码13传的是null，所以暂时不用管，想要继续扩展的可以看下SkipCallbackExecutor这个注解。

代码15以后是一个for循环，这个循环的作用是找出符合条件的CallAdapter，其中最主要的代码是代码14，如果循环过程中代码14返回的不为null，就说明已经找到合适的了，并直接返回结果，我们进去代码14的get(returnType, annotations, this)方法中一探究竟

abstract class Factory {
    /**
     * Returns a call adapter for interface methods that return {@code returnType}, or null if it
     * cannot be handled by this factory.
     */
    public abstract @Nullable CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit);//代码16
    ...
}

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
    ...
  @Override
  public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);

    final Executor executor =//代码17
        Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
            ? null
            : callbackExecutor;

    return new CallAdapter>() {//代码18
      @Override
      public Type responseType() {
        return responseType;
      }

      @Override
      public Call adapt(Call call) {
        return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
      }
    };
  }
    ...
}


执行到代码16的时候就会代码14中对应取到的CallAdapter.Factory来执行get()方法，就拿DefaultCallAdapterFactory来举个例子，代码17中其实就是判断当前是否需要跳过，如果是跳过就给Executor = null如果不要跳过那就给他原来赋值的callbackExecutor，这个callbackExecutor之前讲过，安卓平台默认就是切换线程用的，代码18中就返回了一个CallAdapter，到此代码10就这样分析完毕


接下来我们看看代码11，这段代码其实就是帮我们筛选出符合条件的Converter的，老规矩，进去继续深入聊聊


abstract class HttpServiceMethod extends ServiceMethod {
    ...
    private static  Converter createResponseConverter(
      Retrofit retrofit, Method method, Type responseType) {
        Annotation[] annotations = method.getAnnotations();
        try {
          return retrofit.responseBodyConverter(responseType, annotations);//代码19
        } catch (RuntimeException e) { // Wide exception range because factories are user code.
          throw methodError(method, e, "Unable to create converter for %s", responseType);
        }
  }
   ...
    
}



public final class Retrofit {
    ...
    public  Converter responseBodyConverter(Type type, Annotation[] annotations) {
        return nextResponseBodyConverter(null, type, annotations);//代码20
    }
    
    
    public  Converter nextResponseBodyConverter(//代码23
      @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
        Objects.requireNonNull(type, "type == null");
        Objects.requireNonNull(annotations, "annotations == null");

        int start = converterFactories.indexOf(skipPast) + 1;//代码21
        for (int i = start, count = converterFactories.size(); i < count; i++) {
          Converter converter =
              converterFactories.get(i).responseBodyConverter(type, annotations, this);//代码22
          if (converter != null) {
            //noinspection unchecked
            return (Converter) converter;
          }
        }
        ...
  }
}



上述代码可以看到，过滤Converter和过滤CallAdapter的套路大同小异，我们看看代码流向：代码19->代码20->代码23


前面几个代码流向就不多说了，直接看代码21，这里也是过滤掉了带有SkipCallbackExecutor的Converter，然后不断循环之前配的converterFactories，看代码22循环体中会调用responseBodyConverter()方法，如果返回不为null就表示找到了合适的Converter，进入responseBodyConverter方法康康


  abstract class Factory {
    public @Nullable Converter responseBodyConverter(
        Type type, Annotation[] annotations, Retrofit retrofit) {
      return null;
    }
  }



返回null，很明显是通过子类来实现的，以GsonConverterFactory为例


public final class GsonConverterFactory extends Converter.Factory {
      @Override
      public Converter responseBodyConverter(Type type, Annotation[] annotations,
          Retrofit retrofit) {
        TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonResponseBodyConverter<>(gson, adapter);
      }
    ...
}



final class GsonResponseBodyConverter implements Converter {
  private final Gson gson;
  private final TypeAdapter adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      return adapter.read(jsonReader);
    } finally {
      value.close();
    }
  }
}



看上述代码其实就是把返回的值转化为json格式，这边就贴两段代码，具体也没啥好讲的，实在有不明白的可以在评论区留个言。


最后我们再看一眼代码9，这段代码把刚才筛选出的CallAdater和Converter作为参数给了CallAdapted的构造函数生成了一个新的CallAdapted实体，注意：是CallAdapted 不是CallAdater，CallAdated是最终形态，他是继承HttpServiceMethod的。


static final class CallAdapted extends HttpServiceMethod



到这里为止所有的东西已经就绪，现在就差调用okhttp，接下来会详细讲解Retrofit是如何调用okhttp的


生成Call




我们的样例代码中有这么一行


Call> call = github.contributors("square", "retrofit");



那这个call是怎么来的？嘿嘿，不要忘了，我们分析到现在还只是分析了动态代理中invoke方法中的loadServiceMethod(method)返回值是怎么来的，那返回值后面还低调地写了一个方法：.invoke(args)，低调但是也不平凡，这个方法直接返回了Call，且听我娓娓道来。


老规矩，跟代码


abstract class ServiceMethod {
    ...
    abstract @Nullable T invoke(Object[] args);//代码24
}



abstract class HttpServiceMethod extends ServiceMethod {
    ...
    @Override
    final @Nullable ReturnT invoke(Object[] args) {
        Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
        return adapt(call, args);//代码25
    }
    protected abstract @Nullable ReturnT adapt(Call call, Object[] args);//代码26
    ...
}



static final class CallAdapted extends HttpServiceMethod {
    private final CallAdapter callAdapter;
    ...
    @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);//代码27
    }
  }



public interface CallAdapter {
    ...
      T adapt(Call call);//代码28
    ...
}



代码流向是这样：代码24->代码25->代码26->代码27->代码28，到代码28是不是发现走不下去了？那就对了，你看看28是在哪个类下？CallAdapter，是不是很熟悉？没错这个就是之前被我们循环筛选，选出来的工厂造出来地CallAdapter，你回去看一眼代码18，代码27执行后必然会执行下面的代码(代码18匿名类中的方法)


 @Override
public Call adapt(Call call) {
    return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}


那么这个executor是什么？当然是Android（extends Platform）平台的类中的MainThreadExecutor啦，当然不可能为null啦，所以肯定会是新建一个ExecutorCallbackCall实例，下面是这个类的代码


static final class ExecutorCallbackCall implements Call {
    final Executor callbackExecutor;
    final Call delegate;

    ExecutorCallbackCall(Executor callbackExecutor, Call delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

    @Override
    public void enqueue(final Callback callback) {
      Objects.requireNonNull(callback, "callback == null");

      delegate.enqueue(
          new Callback() {
            @Override
            public void onResponse(Call call, final Response response) {
              callbackExecutor.execute(
                  () -> {
                    if (delegate.isCanceled()) {
                      // Emulate OkHttp's behavior of throwing/delivering an IOException on
                      // cancellation.
                      callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
                    } else {
                      callback.onResponse(ExecutorCallbackCall.this, response);
                    }
                  });
            }

            @Override
            public void onFailure(Call call, final Throwable t) {
              callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
            }
          });
    }

    @Override
    public boolean isExecuted() {
      return delegate.isExecuted();
    }

    @Override
    public Response execute() throws IOException {//代码29
      return delegate.execute();
    }

    @Override
    public void cancel() {
      delegate.cancel();
    }

    @Override
    public boolean isCanceled() {
      return delegate.isCanceled();
    }

    @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
    @Override
    public Call clone() {
      return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
    }

    @Override
    public Request request() {
      return delegate.request();
    }

    @Override
    public Timeout timeout() {
      return delegate.timeout();
    }
  }



如果你曾经使用过okhttp，可以在这里看到，几个熟悉的方法enqueue，execute，timeout...我的天，retrofit居然把okhttp中的Call又自己做了一层封装：retrofit2.Call ！！！




Retrofit：okhttp老兄，有人说你不好用，连个线程切换都没有，还要人去哼哧哼哧地封装，你早晚让人给毙了


okhttp（惊恐脸）：那怎么办，老弟你可得给我支支招啊


Retrofit：也不是不行，你跟我合作，我可是出了名地好用，到时候把你封装进来，用的人就多了啊


okhttp（长叹一口气）：多谢老弟，老弟费心，来根烟


okhttp弯下腰递了一根烟给Retrofit


Retrofit（阴险内心独白）：我调你用我自己封装的Call，让程序员用我的时候完全感知不到你的存在，我看几年后谁还记得你，咩，哈哈哈哈~




这究竟是道德的沦陷还是。。。


其实是因为Retrofit设计初衷就是想灵活适配网络请求框架的，这样做的话可以体现出我是独立的，你们任何人都可以和我合作，只要做很少的适配。


只不过目前为止还是只适配了okhttp。。。


现在Call已经生成了，我们接着样例代码往下走


List contributors = call.execute().body();



执行网络请求


当执行了call.execute()后就直接执行到了代码29，在这个方法中发现它执行的是delegate.execute();我们猜测，这个delegate其实就是okhttp的call，证据如下


首先我们再回到梦开始的地方——代理执行invoke方法的地方见代码30


进入invoke方法，我们再看这里面有个啥


 @Override
  final @Nullable ReturnT invoke(Object[] args) {
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);//代码31
    return adapt(call, args);
  }



所有的请求都会走这个invoke。我们看看代码31，这段代码返回的东西，就是我们之前分析的retrofit2.Call，如果能证明OkHttpCall里面的execute方法确实调用了Okhttp3.Call.execute()方法，那整个流程就通了。看代码


final class OkHttpCall implements Call {
    @Override
    public Response execute() throws IOException {
        okhttp3.Call call;//代码32

        synchronized (this) {
          if (executed) throw new IllegalStateException("Already executed.");
          executed = true;

          call = getRawCall();//代码33
        }

        if (canceled) {
          call.cancel();
        }

        return parseResponse(call.execute());
  }
    ...
    @GuardedBy("this")
    private okhttp3.Call getRawCall() throws IOException {//代码34
        okhttp3.Call call = rawCall;//代码35
        if (call != null) return call;
        ...
              // Create and remember either the success or the failure.
        try {
          return rawCall = createRawCall();//代码36
        } catch (RuntimeException | Error | IOException e) {
          throwIfFatal(e); // Do not assign a fatal error to creationFailure.
          creationFailure = e;
          throw e;
        }
        }
    
    ...
    private okhttp3.Call createRawCall() throws IOException {
        okhttp3.Call call = callFactory.newCall(requestFactory.create(args));//代码37
        if (call == null) {
          throw new NullPointerException("Call.Factory returned null.");
        }
        return call;
    }

}



代码流向：代码33->代码34->代码35 ->代码36->代码37，还记得callFactory的赋值吗？对的，就是如果在build构建Retrofit时没有赋值，那就默认OkhttpClient，下面的代码帮助回忆一下：


 public Retrofit build() {
     ...
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
     ...
 }



证毕，结果：实锤retrofit2.Call == okhttp3.Call


接下来执行execute方法其实就是okhttp3.Call.execute()，我之前写了一篇文章是以okhttp3.Call.equeue()为例的，其实原理都差不多，有兴趣的可以看一下我的文章：okhttp3原理解析——概览（非常概括）


结语




头一回写这么长篇的源码解析，写到这里其实也涨了不少的知识，阅读源码确实是一个很好的习惯，都说阅读书本是在和圣贤交流，交流多了就能成为圣贤。那阅读优秀源码其实也是在和大神交流，交流多了不说能成为大神，至少对以后的学习和能力的提升都是一笔不小的财富。Retrofit确实是一个很优秀的开源框架，我也是看了3天才大致了解里面的工作流程，好的东西真的是每次看都能发现新的知识，每次都能将自己的认知升那么一小段。
























你可能感兴趣的:(Retrofit2.9.0源码解析)






    

  • Elasticsearch——配置详解
smart哥
elasticsearch专题elasticsearch搜索引擎

    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
    

    • 

  • Eventbus3.0源码解析
超威蓝猫l

    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    

    • 

  • 前端宝典之三：React源码解析之Fiber架构
桃子叔叔
大厂进阶前端深度解析系列react.js架构javascript

    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
    

    • 

  • Java集合之HashSet源码解析
气宇轩昂固执狂
JAVA面试笔试通关指南java开发语言HashSetHashSet源码

    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
    

    • 

  • Spring之AOP底层源码解析（上）
阿立聊代码
spring代理模式

    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
    

    • 

  • Spring Boot自动配置源码解析
一休哥助手
springbootjava数据库

    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
    

    • 

  • Spring扩展点系列-InstantiationAwareBeanPostProcessor
码至终章
Spring生命周期扩展接口springsqljava扩展接口mavenspringboot

    文章目录简介测试一1、配置文件Bean注册2、单元测试方法3、测试类4、输出结果结论测试二1、测试类2、输出结果结论源码解析postProcessPropertiesCommonAnnotationBeanPostProcessorAnnotationInjectedBeanPostProcessor总结简介spring容器中Bean的生命周期内所有可扩展的点的调用顺序扩展接口实现接口Applic
    

    • 

  • MyBatis 源码解析：DefaultSqlSessionFactory 的创建与管理
捕风捉你
MyBatis源码解读mybatis

    摘要在MyBatis中，SqlSessionFactory是执行数据库操作的核心对象，它负责创建和管理SqlSession的生命周期。你是否想了解SqlSessionFactory的创建和管理过程？本文将通过自定义实现一个简化版的DefaultSqlSessionFactory，带你深入探讨MyBatis中DefaultSqlSessionFactory的创建与管理机制，并帮助你更好地掌握SqlS
    

    • 

  • FFmpeg源码解析系列（一）目录和编译
头快撑不住了
FFmpeg源码解析ffmpeg音视频视频编解码实时音视频图像处理

    引言当我们欣赏一部电影、观看一段视频或者享受一首音乐时，很少有人会停下来思考这一切是如何呈现在我们眼前的。然而，在每一帧的画面、每一秒的声音背后，有着一个不可思议的技术世界这个充满音视频的世界的核心之一，就是FFmpeg。FFmpeg是一个强大而复杂的多媒体处理工具，它为视频和音频编解码、流媒体传输、格式转换等提供了优秀的解决方案。在这个系列博客中，我们将深入探讨FFmpeg源码，解析它的工作原理
    

    • 

  • Spark MLlib LinearRegression线性回归算法源码解析
SmileySure
Spark人工智能算法SparkMLlib

    线性回归一元线性回归hθ(x)=θ0+θ1xhθ(x)=θ0+θ1x——————–1多元线性回归hθ(x)=∑mi=1θixi=θTXhθ(x)=∑i=1mθixi=θTX—————–2损失函数J(θ)=1/2∑mi=1(hθ(xi)−yi)2J(θ)=1/2∑i=1m(hθ(xi)−yi)2—————31/2是为了求导时系数为1，平方里是真实值减去估计值我们的目的就是求其最小值最小二乘法要求较为
    

    • 

  • HashMap源码解析
dlwlrma ⥳
兴趣类哈希算法散列表算法

    目录一:put方法流程二：get方法三：扩容机制一：put方法流程publicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node[]tab;Nodep;intn,i;//判断数组是
    

    • 

  • Spring之启动过程源码解析
阿立聊代码
springspring数据库oracle

    前言分析通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。首先，Spring启动过程主要做了这么几件事情：构造一个BeanFactory对象解析配置类，得到BeanDefinition，并注册到BeanFactory中解析@ComponentScan，此时就会完成扫描解析@Import解析@Bean...因为Application
    

    • 

  • 【HuggingFace Transformers】BertIntermediate 和 BertPooler源码解析
CS_木成河
HuggingFace深度学习人工智能bertpython大模型Transformer

    BertIntermediate和BertPooler源码解析1.介绍1.1位置与功能1.2相似点与不同点2.源码解析2.1BertIntermediate源码解析2.2BertPooler源码解析1.介绍1.1位置与功能(1)BertIntermediate位置：位于BertLayer的注意力层（BertSelfAttention）和输出层（BertOutput）之间。功能：它执行一个线性变换（
    

    • 

  • vue.js项目实战案例详细源码讲解
程序员小羊！
Javavue.js前端javascript

    大家好，我是程序员小羊！前言：为帮助大家更好地掌握Vue.js项目的开发流程，我将为你讲解一个完整的Vue.js实战案例，并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程，适合用于构建一个具有基本CRUD功能的简单任务管理应用。案例介绍我们将开发一个任务管理应用（TaskManager），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
    

    • 

  • Go Context使用及源码解析
zhangj1125
Gogolang后端

    概述context包提供了一种在Go程序中不同组件之间传递请求范围的值、取消信号和截止时间的方式。context包的设计目的是为了解决在Go的并发模型中，尤其是在goroutines之间，如何安全、高效地传递控制信息的问题。当Context被取消时，从其派生的所有Context也将被取消。Context接口Context接口定义了4个方法typeContextinterface{//返回Conte
    

    • 

  • c#视觉应用开发中如何使用OpenCV库进行计算机视觉处理？
openwin_top
C#视觉应用开发问题系列计算机视觉c#opencv

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位在C#中使用OpenCV库进行计算机视觉处理，通常会借助一个叫做EmguCV的封装库。EmguCV是OpenCV的一个跨平台的.NET封装，使得在C#中调用OpenCV变得更加方便。安装EmguCV
    

    • 

  • Android 12.0 App全屏时通过系统属性控制上划下拉是否显示虚拟导航栏和状态栏
VaporRuby
android

    遇到问题厂测App触摸屏测试，需要全屏显示，禁止出现状态栏和导航栏，以免影响测试。参考资料https://zhuanlan.zhihu.com/p/440810585Android12系统源码_SystemUI（九）WindowInsetsController源码解析-CSDN博客解决方案1、framework修改点+++b/frameworks/base/services/core/java/c
    

    • 

  • Spring之Bean生命周期源码解析上
阿立聊代码
springspringjava后端

    Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的Bean的生成过程1.生成BeanDefinitionSpring启动的时候会进行扫描，会先调用org.springfr
    

    • 

  • MyBatis 源码解析：XMLConfigBuilder 解析过程
捕风捉你
MyBatis源码解读mybatisjava

    前言在MyBatis框架中，XMLConfigBuilder是一个关键类，负责解析mybatis-config.xml配置文件。理解这个类的工作原理有助于掌握MyBatis的配置管理和框架初始化过程。本篇文章将通过自定义实现一个简化版的XML配置解析器，并深入解析MyBatis中XMLConfigBuilder的实现细节。自定义实现：简化版XML配置解析器目标与功能我们将实现一个简化版的XML配置
    

    • 

  • 【Android】APK应用安装过程源码解析
Tech Ranger
笔记

    Android系统在启动的过程中，会启动一个应用程序管理服务PackageManagerService，这个服务负责扫描系统中特定的目录，找到里面的应用程序文件，即以Apk为后缀的文件，然后对这些文件进解析，得到应用程序的相关信息，完成应用程序的安装过程，本文将详细分析这个过程。一、启动安装1、InstallStart在开发过程中有时候需要进行APP更新，或者下载其他APP到本地让后使用以下代码进
    

    • 

  • frameworks 之getEvent指令
哥咫匙传说
linux车载系统android

    frameworks之getEvent指令指令解析源码追溯源码解析1.解析参数2.初始化ufds数组3.添加到poll并做对应处理通过getEvent可以识别按键基本命令和里面的关键信息涉及到的类如下system/core/toolbox/toolbox.csystem/core/toolbox/tools.hsystem/core/toolbox/getevent.c指令解析通过getEvent
    

    • 

  • Spring Cloud LoadBalancer 源码解析
码农爱java
【SpringCloudGateway】springcloud微服务负载均衡LoadBalancer源码

    前言LoadBalancer（负载均衡器）：一种网络设备或软件机制，用于分发传入的网络流量负载到多个后端目标服务器上，依次来提高系统的可用性和性能，SpringCloud2020版本以后，移除了对Netflix的依赖，也就移除了负载均衡器Ribbon，SpringCloud官方推荐使用Loadbalancer替换Ribbon，并成为了SpringCloud负载均衡器的唯一实现。LoadBalanc
    

    • 

  • java源码浅析之dubbo
DaHuangXiao
随笔java

    前言最近在看RPC框架，选择先看dubbo，再看netty，最后手写一个RPC的学习路线，结合雷神关于dubbo的讲解，对源码流程进行一个简单的记录原理所谓RPC就是远程服务调用的意思，那么dubbo怎么完成远程调用的呢？原理图如下[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9fEwo2Az-1623312993257)(java源码解析之dubbo.assets
    

    • 

  • ThreadLocal源码解析
七月拾光

    使用示例publicclassThreadLocalDemo{privatestaticThreadLocalthreadLocal=newThreadLocal{threadLocal.set(1);System.out.println(Thread.currentThread().getName()+","+threadLocal.get());},"thread1").start();new
    

    • 

  • Java集合框架：了解TreeMap
索茄啦你
java

    TreeMap基于红黑树实现的有序映射目录TreeMap继承关系TreeMap源码解析TreeMap总结TreeMap继承关系TreeMap继承了AbstractMap抽象类，拥有map的相关操作方法TreeMap实现了Serializable接口，支持序列化，可通过序列化传输TreeMap实现了Cloneable接口，覆盖了clone()方法，能被克隆TreeMap实现了NavigableMap
    

    • 

  • Java 集合框架：TreeMap 的介绍、使用、原理与源码解析
栗筝i
栗筝i的Java技术栈#Java基础栗筝i的Java技术栈Java基础Java集合TreeMapr-tree

    大家好，我是栗筝i，这篇文章是我的“栗筝i的Java技术栈”专栏的第021篇文章，在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验，并希望进一步完善自己对整个Java技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同
    

    • 

  • YOLOv5 | 源码解析 | 计算损失loss原理——独家原创注释
kay_545
YOLOv8改进有效涨点Yolov5改进YOLOpython开发语言

    ⭐欢迎大家订阅我的专栏一起学习⭐订阅专栏，更新及时查看不迷路YOLOv5涨点专栏：http://t.csdnimg.cn/D9kR0YOLOv8涨点专栏：http://t.csdnimg.cn/5hNr8YOLOv7专栏：http://t.csdnimg.cn/hJsf1魔改网络、复现论文、优化创新各位订阅YOLOv8专栏读者，非常抱歉，这篇文章加错专栏了，但是因为是订阅的，所以不能删除或者移动这
    

    • 

  • SeaweedFS部署
仙女陈
linux

    SeaweedFS介绍SeaweedFS是一个分布式文件系统应用场景：主要用于存储处理小文件、大文件分块成小文件上传Githup地址：https://github.com/chrislusf/seaweedfs官方文档：https://github.com/chrislusf/seaweedfs/wikiseaweedfs源码解析：https://www.bbsmax.com/A/6pdDYXQK
    

    • 

  • 【axios】从源码解析axios拦截器是如何工作的
web安全学习资源库
前端javascriptvue.js

    本文所用axios版本号为：1.3.2。axios拦截器的配置方式axios中有两种拦截器：axios.interceptors.request.use(onFulfilled,onRejected,options)：配置请求拦截器。*onFulfilled方法在发送请求前执行，接收config对象，返回一个新的config对象，可在此方法内修改config对象。*onRejected方法在onF
    

    • 

  • 快速排序详解！c语言
自律的阿龙
数据结构c语言数据结构算法c语言排序算法

    目录快速排序是什么？快速排序的三种方法！快速排序的优化1.hore法（初代目）hore法的源码源码解析2.挖坑法（常用）！！！！挖坑法源码3.前后指针法（常用）前后指针代码4.非递归法快速排序全过程图快速排序是什么？快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法快速排序顾名思义，快速的排序，事实也如此，他的应用面广泛同时确实很快，因为他的时间复杂度是o（nlogn），相比前面的
    

    • 

  • 用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类）
AdyZhang
POJOeclipseHibernateMiddleGenIDE

    推荐:MiddlegenIDE插件,   是一个Eclipse   插件.     用它可以直接连接到数据库,   根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件!     今天开始试着使用
    

    • 

  • .9.png
Cb123456
android

      “点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png
　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。
　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
    

    • 

  • 算法的效率
天子之骄
算法效率复杂度最坏情况运行时间大O阶平均情况运行时间

    算法的效率
效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。
 
以下是我的学习笔记：
 
1.求值与霍纳法则，即为秦九韶公式。
 
2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。 
    

    • 

  • java数据结构
何必如此
java数据结构

    Java 数据结构
Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：
枚举（Enumeration）
位集合（BitSet）
向量（Vector）
栈（Stack）
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）
以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
    

    • 

  • MybatisHelloWorld
3213213333332132

    
//测试入口TestMyBatis
package com.base.helloworld.test;
import java.io.IOException;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibat
    

    • 

  • Java|urlrewrite|URL重写|多个参数
7454103
javaxmlWeb工作

     个人工作经验！ 如有不当之处，敬请指点
1.0  web -info 目录下建立     urlrewrite.xml  文件 类似如下：
<?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE u
    

    • 

  • 达梦数据库+ibatis
darkranger
sqlmysqlibatisSQL Server

    --插入数据方面
如果您需要数据库自增...
那么在插入的时候不需要指定自增列.
如果想自己指定ID列的值, 那么要设置
set identity_insert  数据库名.模式名.表名;
----然后插入数据;
example:
create table zhabei.test(
id bigint identity(1,1) primary key,
nam
    

    • 

  • XML 解析 四种方式
aijuans
android

    XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。
XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object 
    

    • 

  • spring中配置文件占位符的使用
avords

    1.类
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
    

    • 

  • 前端工程化-公共模块的依赖和常用的工作流
bee1314
webpack

    题记： 一个人的项目，还有工程化的问题嘛？   我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？ 你真的想这样嘛？   var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。   
    

    • 

  • 上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？
bijian1013
项目管理沟通IT职业规划

    问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应
        正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。
 
Eno-Bea回答，注重感受，不一定是别人的
        虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
    

    • 

  • TortoiseSVN，过滤文件
征客丶
SVN

    环境：
TortoiseSVN 1.8
配置：
在文件夹空白处右键
选择  TortoiseSVN -> Settings
在 Global ignote pattern 中添加要过滤的文件：
多类型用英文空格分开
*name ： 过滤所有名称为 name 的文件或文件夹
*.name ： 过滤所有后缀为 name 的文件或文件夹
--------
    

    • 

  • 【Flume二】HDFS sink细说
bit1129
Flume

    1. Flume配置
 
a1.sources=r1
a1.channels=c1
a1.sinks=k1
###Flume负责启动44444端口
a1.sources.r1.type=avro
a1.sources.r1.bind=0.0.0.0
a1.sources.r1.port=44444
a1.sources.r1.chan
    

    • 

  • The Eight Myths of Erlang Performance
bookjovi
erlang

    erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide
里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html
 
Myth: Funs are sl
    

    • 

  • java多线程网络传输文件(非同步)-2008-08-17
ljy325
java多线程socket

    利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。
使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer.
客户端:
修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
    

    • 

  • 读《研磨设计模式》-代码笔记-模板方法模式
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
    

    • 

  • 配置心得
chenyu19891124
配置

    时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。
作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。
做了一年的配置管理给自总结下：
1.改变
从一个以前对配置毫无
    

    • 

  • 对“带条件选择的并行汇聚路由问题”的再思考
comsci
算法工作软件测试嵌入式领域模型

    2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
    

    • 

  • Oracle 10g 的clusterware 32位 下载地址
daizj
oracle

    Oracle 10g 的clusterware 32位 下载地址
http://pan.baidu.com/share/link?shareid=531580&uk=421021908
http://pan.baidu.com/share/link?shareid=137223&uk=321552738
http://pan.baidu.com/share/l
    

    • 

  • 非常好的介绍：Linux定时执行工具cron
dongwei_6688
linux

    Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。
新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
    

    • 

  • Yii assets目录生成及修改
dcj3sjt126com
yii

    assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。
assets设置对应的方法位置 \framework\web\CAssetManager.php
 
assets配置方法 在m
    

    • 

  • mac工作软件推荐
dcj3sjt126com
mac

    mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。
我为什么要要iterm2
切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点：
* 兼容性好，远程服务器 vi 什么的低版本能很好兼
    

    • 

  • Memcached(三)、封装Memcached和Ehcache
frank1234
memcachedehcachespring ioc

    本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。
cache.xml
<?xml version="1.0" encoding="UTF-8"?>

    

    • 

  • Remove Duplicates from Sorted List II
hcx2013
remove

    Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.
For example,Given 1->2->3->3->4->4->5,
    

    • 

  • Spring4新特性——注解、脚本、任务、MVC等其他特性改进
jinnianshilongnian
spring4

    Spring4新特性——泛型限定式依赖注入
Spring4新特性——核心容器的其他改进
Spring4新特性——Web开发的增强
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
Spring4新特性——Groovy Bean定义DSL
Spring4新特性——更好的Java泛型操作API 
Spring4新
    

    • 

  • MySQL安装文档
liyong0802
mysql

      工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。
  安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。
  Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
    

    • 

  • 使用VS2010构建HotSpot工程
p2p2500
HotSpotOpenJDKVS2010

    1. 下载OpenJDK7的源码：
    
http://download.java.net/openjdk/jdk7
    
http://download.java.net/openjdk/
    
2. 环境配置
    ▶
    

    • 

  • Oracle实用功能之分组后列合并
seandeng888
oracle分组实用功能合并

    1       实例解析
由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下：
表test 数据如下：
ID,SUBJECTCODE,DIMCODE,VALUE
1&nbs
    

    • 

  • Java定时任务注解方式实现
tuoni
javaspringjvmxmljni

    Spring 注解的定时任务，有如下两种方式：
第一种：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http
    

    • 

  • 11大Java开源中文分词器的使用方法和分词效果对比
yangshangchuan
word分词器ansj分词器Stanford分词器FudanNLP分词器HanLP分词器

    本文的目标有两个：
1、学会使用11大Java开源中文分词器
2、对比分析11大Java开源中文分词器的分词效果
本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。
11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口：
/**
* 获取文本的所有分词结果, 对比
    

    •