小沫沫儿
小沫沫儿

Retrofit源码分析（2.9.0最新版）

转载https://blog.csdn.net/wan_dou_/article/details/116067728 记录

前言

之前讲过了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.png

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

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

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

1、判断是否有baseUrl

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

2、赋值callFactory，这个callFactory其实就是okhttpClient

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

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


public Builder client(OkHttpClient client) {
  return callFactory(Objects.requireNonNull(client, "client == null"));
}


public Builder callFactory(okhttp3.Call.Factory factory) {
  this.callFactory = Objects.requireNonNull(factory, "factory == null");
  return this;
}

3、赋值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方法后会切换到主线程。

4、赋值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，这里不去深挖了，感兴趣的同学可以狗哥一下（狗哥一下，就是强大——暗示点赞）。

5、赋值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;
     }
    ...
}

6、在一切都准备就绪后，一个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()方法

 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)，我们跟进去看看
  
  ```java
  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 {
    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。。。
 
 
现在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()为例的，其实原理都差不多
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Retrofit源码分析（2.9.0最新版）)

        

            

                
    
                    
  • vue 创建项目报错：command failed: npm install --loglevel error
                        那鱼、会飞
vue.jsvue-cli3
                        
    这个问题其实很好解决，只是很多种情况，逐一排除即可。稳下心来~vuecli3创建项目我的node版本是node14.15.0，（永远不要尝试最新版本）node各种版本下载地址：以往的版本|Node.js(nodejs.org)vue/[email protected]@vue/[email protected]（注意vue/cli2和vue/cli3的下载命名有所改变，2是-形式，3是/形式）其实报错
    
                    
    • 
                    
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署）
                        java毕设程序源码王哥
php课程设计vue.js
                        
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    
                    
    • 
                    
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换
                        让开，我要吃人了
OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
                        
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
    
                    
    • 
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • Vue3 vant组件库自动导入
                        不叫虎子
Vuevue.js前端javascript前端框架typescript
                        
    实现：完整使用vant组件库文档安装：#Vue3项目，安装最新版Vantnpmivant#通过yarn安装yarnaddvant#通过pnpm安装pnpmaddvant【一】按需引入：https://vant-contrib.gitee.io/vant/#/zh-CN/quickstart#fang-fa-er.-an-xu-yin-ru-zu-jian-yang-shi【二】批量引入在基于vit
    
                    
    • 
                    
  • Python程序打包指南：手把手教你一步步完成
                        Python_P叔
python数据库开发语言
                        
    最近感兴趣想将开发的项目转成Package，研究了一下相关文章，并且自己跑通了，走了一下弯路，这里记录一下如何打包一个简单的Python项目，展示如何添加必要的文件和结构来创建包，如何构建包，以及如何将其上传到Python包索引（PyPI）。首先要确保安装最新版本：#Unix/macOSpython3-mpipinstall--upgradepip#windowspy-mpipinstall--u
    
                    
    • 
                    
  • 228.第一个错误的版本
                        vbuer

                        
    你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有n个版本[1,2,...,n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用boolisBadVersion(version)接口来判断版本号version是否在单元测试中出错。实现一个函数来查找第一个错
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • 计算机毕设Node.js+Vue校园易购二手交易平台（程序+LW+部署）
                        Node程序源码强子
vue.js课程设计node.js
                        
    项目运行环境配置：Node.js最新版+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    
                    
    • 
                    
  • 拼多多商家电话采集工具 爬虫教程分享
                        小电商达人
爬虫
                        
    以下是使用Python编写的拼多多商家电话采集爬虫教程：一、前期准备安装Python：从Python官方网站下载并安装最新版本的Python，安装过程中注意勾选将Python添加到系统路径选项。安装相关库：在命令提示符中运行以下命令来安装所需的库。pipinstallrequests：用于发送HTTP请求获取网页内容。pipinstallbeautifulsoup4：用于解析HTML页面。二、分析
    
                    
    • 
                    
  • Cisco SD-WAN (Viptela) 20.15.1 发布，新增功能概览
                        sysin.org
CiSCOCiscoSD-WANViptela思科SDN软件定义广域网
                        
    CiscoSD-WAN(Viptela)version20.15.1ED-软件定义广域网CiscoSD-WANpoweredbyViptela请访问原文链接：https://sysin.org/blog/cisco-sd-wan-20/，查看最新版。原创作品，转载请保留出处。作者主页：sysin.org支持SASE的架构，其集成了面向多云、安全、统一通信和应用优化的各种功能，可用于轻松安全地将任何
    
                    
    • 
                    
  • 操作系统简介
                        像风一样自由2020
操作系统linuxubuntuwindowsharmonyos
                        
    操作系统简介操作系统（OperatingSystem，简称OS）是管理计算机硬件和软件资源的系统软件，为用户和应用程序提供接口。现今，操作系统种类繁多，主要分为桌面操作系统、服务器操作系统和移动操作系统等。以下是对目前存在的主要操作系统的详细介绍。1.Windows简介：Windows是由微软公司开发的系列图形界面操作系统，是全球使用最广泛的桌面操作系统之一。最新版本：截至2023年10月，最新版
    
                    
    • 
                    
  • 计算机毕业设计Node.js+Vue基于Java的医院预约挂号系统(程序+源码+LW+部署)
                        Nodejs洋洋 程序
javavue.js课程设计
                        
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：Node.js+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可
    
                    
    • 
                    
  • Java高并发编程详解系列-深入理解Thread构造
                        nihui123
高并发Java高并发Java高并发
                        
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    
                    
    • 
                    
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    
                    
    • 
                    
  • mysql数据库配置环境变量
                        一只会敲代码的小灰灰
数据库mysql数据库
                        
    mysql数据库配置环境变量这是我最初学习时记录下来的笔记，有些简陋！1.下载最新版mysql软件，将mysql安装到系统目录中，记录当前安装目录；如安装mysql到C:/programfiles/mysql目录下2.打开win7系统——计算机——系统属性3.点击环境变量，进入环境变量设置菜单4.选中系统变量中的“path”，在path值开头处输入：C:\programfiles\mysql\bi
    
                    
    • 
                    
  • Jetpack LiveData源码分析
                        xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析
                        
    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（17）——TrackSelector
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（12）——Cache
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
                        2401_83740189
程序员架构
                        
    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    
                    
    • 
                    
  • 【HarmonyOS】- 常见算法简单写法
                        数的羊都睡了
HarmonyOSArkTS鸿蒙
                        
    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    
                    
    • 
                    
  • Navicat 15.x for MySQL最新版注册码破解激活教程
                        张先森丫

                        
    一、准备工作：破解注册步骤并不难，请耐心看完！1.下载Navicat15.xforMySQL官网下载地址：http://www.navicat.com.cn/download/navicat-premium2.下载注册机链接：https://pan.baidu.com/s/1-FHd7b7NveohwSKuxd-jzQ提取码：zxsY二、开始激活操作：1.将下载好的注册机压缩包复制到Navicat
    
                    
    • 
                    
  • MongoDB Atlas与LangChain集成指南
                        afTFODguAKBF
mongodblangchain数据库python
                        
    引言MongoDBAtlas是一款全托管的云数据库解决方案,可在AWS、Azure和GCP上使用。最新版本支持在MongoDB文档数据上进行原生向量搜索。本文将介绍如何使用LangChain将MongoDBAtlas与语言模型集成,以实现高效的向量搜索和语义缓存。安装和设置1.安装langchain-mongodb包pipinstalllangchain-mongodb向量存储LangChain提
    
                    
    • 
                    
  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
                        nangonghen
dockerdocker
                        
    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    
                    
    • 
                    
  • 如何升级用 Helm 安装的极狐GitLab Runner？
                        极小狐
DevOpsDevSecOpsGitLab极狐GitLab安全合规
                        
    本分分享如何对Helm安装的Runner进行升级。整个过程分为三步：1、确定Runner最新版本或者想要升级的版本是否存在；2、用Helmupgrade命令进行升级；3、升级确认。极狐GitLab为GitLab的中国发行版，中文版本对中国用户更友好，可以一键私有化部署，安装升级详情可以查看官网。前提用Helm安装且运行正常的Runner关于使用Helm进行极狐GitLabRunner，可以参考文章
    
                    
    • 
                    
  • dispatch_once源码分析
                        福伟_Y

                        
    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    
                    
    • 
                    
  • PC电脑版《真三国无双8》最新版-单机游戏下载！
                        2401_87320711
电脑游戏
                        
    游戏介绍：以一张幅员广阔的地图表现中国大陆的“开放世界”。除了维持一向轻松的操作感外，“新无双动作”更能以前所未有、万化自如的行动实现本系列以来最高等级的「一骑当千之爽快感」。再加上“众多的魅力武将”所交织成的宏伟「三国志」世界。融合了这些特点，可让玩家身临体验历史洪流的全新「真・三国无双」于此诞生！游戏截图：━好玩的单机游戏：https://pan.xunlei.com/s/VNwX7uYgH-
    
                    
    • 
                    
  • feign和hystrix
                        小林嘞
springcloudhystrixjavaspring
                        
    网上教程说feign中集成了hystrix,但是引入的最新版本的3.1.4版本的feign在运行程序时提示,feign中没有hystrix的实例.于是手动添加:org.springframework.cloudspring-cloud-starter-netflix-hystrix2.2.10.RELEASE同时需要注意,在使用时出现了很多教程说的开启hystrix的方法如下:#开启feign对h
    
                    
    • 
                                
  • web前段跨域nginx代理配置
                                    刘正强
nginxcmsWeb
                                    
    nginx代理配置可参考server部分 
 
server { 
        listen       80; 
        server_name  localhost; 
 

    
                                
    • 
                                
  • spring学习笔记
                                    caoyong
spring
                                    
    一、概述 
    a>、核心技术 : IOC与AOP 
 b>、开发为什么需要面向接口而不是实现 
     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 
 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式) 
    
                                
    • 
                                
  • Eclipse打开workspace提示工作空间不可用
                                    0624chenhong
eclipse
                                    
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 
1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 
解决办法，删掉.fileTableLock文件，重
    
                                
    • 
                                
  • Javascript 面向对面写法的必要性？
                                    一炮送你回车库
JavaScript
                                    
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 
这是javascript层的mvc框架哦,不是j2ee的mvc框架 
  
我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
    
                                
    • 
                                
  • js array对象的迭代方法
                                    换个号韩国红果果
array
                                    
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 
使用该函数  return 语句失效 
 

function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
 
2.every 该方法接受一个返回值为布尔类型
    
                                
    • 
                                
  • 对Hibernate缓存机制的理解
                                    归来朝歌
session一级缓存对象持久化
                                    
    在hibernate中session一级缓存机制中，有这么一种情况： 
问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 
session.save()方法，在提交事务后，会出现这样的情况： 
1：在数据库中有默认属性的字段的值为空 
2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 
通过调试后解决方案如下： 
对于问题一，如你在数据库里设置了
    
                                
    • 
                                
  • WebService调用错误合集
                                    darkranger
webservice
                                    
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton   
调用接口出错， 
一个简单的WebService 
import org.apache.axis.client.Call;import org.apache.axis.client.Service; 
首先必不可
    
                                
    • 
                                
  • JSP和Servlet的中文乱码处理
                                    aijuans
Java Web
                                    
    JSP和Servlet的中文乱码处理 
前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 
一、表单提交时出现乱码： 
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
    
                                
    • 
                                
  • 面试经典六问
                                    atongyeye
工作面试
                                    
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 
 
以下是人事了解应聘者情况的最典型的六个问题： 
 
 
1 简单自我介绍  
 
关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 
 
我的回答：(针对技术面试回答，如果是人事面试，可以就掌
    
                                
    • 
                                
  • contentResolver.query()参数详解
                                    百合不是茶
androidquery()详解
                                    
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 
一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。    
[java]  
view plain 
copy       
 
 public void fetchAllContacts() {   
    
    
                                
    • 
                                
  • ora-00054:resource busy and acquire with nowait specified解决方法
                                    bijian1013
oracle数据库killnowait
                                    
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 
1.下面的语句
    
                                
    • 
                                
  • web 开发乱码
                                    征客丶
springWeb
                                    
    以下前端都是 utf-8 字符集编码 
 
一、后台接收 
1.1、 get 请求乱码 
get 请求中，请求参数在请求头中； 
乱码解决方法： 
a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 
 
1.2、post 请求乱码 
post 请求中，请求参数分两部份， 
1.2.1、url？参数，
    
                                
    • 
                                
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式
                                    bit1129
spark
                                    
    Spark SQL数据源和表的Schema 
 
  case class  
  apply schema  
  parquet  
  json  
 JSON数据源 准备源数据 
{"name":"Jack", "age": 12, "addr":{"city":"beijing&
    
                                
    • 
                                
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss
                                    BlueSkator
-Xss-Xmn-Xms-Xmx
                                    
      
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： 
 
 java -Xmx355
    
                                
    • 
                                
  • jqGrid 各种参数 详解(转帖)
                                    BreakingBad
jqGrid
                                    
      
jqGrid 各种参数 详解   分类： 
源代码分享 
个人随笔请勿参考 
解决开发问题 2012-05-09 20:29   84282人阅读   
评论(22)   
收藏   
举报   
jquery 
服务器 
parameters 
function 
ajax 
string      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 下面
    
                                
    • 
                                
  • 应用升级iOS8中遇到的一些问题
                                    chenhbc
ios8升级iOS8
                                    
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 
-(void)viewWillAppear:(BOOL)animated 
 中写的，最终的解决办法是把判断写在 
-(void
    
                                
    • 
                                
  • 工作流与自组织的关系？
                                    comsci
设计模式工作
                                    
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？ 
 
  这里有篇论文，摘要是：“针对网格中的服务
    
                                
    • 
                                
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX
                                    daizj
oracle
                                    
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 
 
转自：http://space.itpub.net/18922393/viewspace-752123 
 
在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
    
                                
    • 
                                
  • 二叉树:堆
                                    dieslrae
二叉树
                                    
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 
    一个节点的父节点下标为: (当前下标 - 1)/2 
    一个节点的左节点下标为: 当前下标 * 2 + 1 
  &
    
                                
    • 
                                
  • C语言学习八结构体
                                    dcj3sjt126com
c
                                    
    为什么需要结构体，看代码 
# include <stdio.h>

struct Student	//定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量
{
	int age;
	float score;
	char sex;
}

int main(void)
{
	struct Student st = {80, 66.6,
    
                                
    • 
                                
  • centos安装golang
                                    dcj3sjt126com
centos
                                    
    #在国内镜像下载二进制包 
wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz 
tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz 
  
#把golang的bin目录加入全局环境变量 
cat >>/etc/profile<
    
                                
    • 
                                
  • 10.性能优化-监控-MySQL慢查询
                                    frank1234
性能优化MySQL慢查询
                                    
    1.记录慢查询配置 
show variables where variable_name like 'slow%' ; --查看默认日志路径 
查询结果：--不用的机器可能不同 
slow_query_log_file=/var/lib/mysql/centos-slow.log 
 
修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
    
                                
    • 
                                
  • Java父类取得子类类名
                                    happyqing
javathis父类子类类名
                                    
      
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ 
  
package com.urthinker.module.test;

import org.junit.Test;

abstract class BaseDao<T> {
	public void 
    
                                
    • 
                                
  • Spring3.2新注解@ControllerAdvice
                                    jinnianshilongnian
@Controller
                                    
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： 
  
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Co
    
                                
    • 
                                
  • Java spring mvc多数据源配置
                                    liuxihope
spring
                                    
    转自：http://www.itpub.net/thread-1906608-1-1.html 
 
 
1、首先配置两个数据库 
 
<bean id="dataSourceA"         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
    
                                
    • 
                                
  • 第12章 Ajax（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BW / Universe Mappings
                                    blueoxygen
BO
                                    
          
BW Element    
OLAP Universe Element      
Cube  Dimension    
Class      
Charateristic    
A class with dimension and detail objects (Detail objects for key and desription)      
Hi
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
java多线程工作单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 推行国产操作系统的优劣
                                    yananay
windowslinux国产操作系统
                                    
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 
 
先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
    
                                
    •