DthFish
DthFish

Retrofit 2.6.2 源码分析

Retrofit 2.6.2 源码分析

原文链接
Retrofit 是对网络请求接口的封装，它内部最终的网络请求还是通过 OkHttp 实现的，但是它使我们只需要编写 java 接口就能创建 OkHttp 需要的请求。

基本使用

// 定义 get 请求接口
interface BaiDuApi {
    @GET("s")
    fun getBaiDu(): Call
}

        // 自定义 OkHttpClient
        val okHttpClient = OkHttpClient.Builder().eventListener(object : EventListener() {
            override fun callStart(call: Call) {
                super.callStart(call)
                Log.d("OkHttpClient", "callStart:${call.request()}")
            }

        }).build()
                // 初始化 Retrofit
        val retrofit = Retrofit.Builder()
            .baseUrl("https://www.baidu.com/")
            .client(okHttpClient)
            .build()

        val baiDuApi = retrofit.create(BaiDuApi::class.java)
        val retrofitCall = baiDuApi.getBaiDu()
        retrofitCall.enqueue(object : retrofit2.Callback {
            override fun onFailure(call: retrofit2.Call, t: Throwable) {
                Log.d("Retrofit", t.toString())
            }

            override fun onResponse(
                call: retrofit2.Call,
                response: retrofit2.Response
            ) {
                Log.d("Retrofit", response.toString())
            }
        })

因为内部是用 OkHttp 所有可以自己初始化一个 OkHttpClient 对象这样我们可以在拦截器里面实现很多自己需要的功能。

还是和上一篇一样，我们从如何使用入手，这里主要涉及到 Retrofit、Call、Callback 几个对象，因为 BaiDuApi 是我们自己创建的接口，但是实际使用的时候还是通过它的方法获取了一个 Call 对象，所以我们先看一下 Retrofit.create 方法里面到底做了什么。

一、Retrofit.create

    // Retrofit.java
    public  T create(final Class service) {
    // 1、
    Utils.validateServiceInterface(service);
    // 5、
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    // 2、
    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 {
            // 3、
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 4、
            return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }
  1. 接口的合法性验证。
  2. 可以看到 create 方法采用了动态代理的方式代理了我们定义的接口的方法。
  3. Object 的方法就直接正常调用，以及一些默认方法的处理。
  4. 通过 loadServiceMethod 处理再执行（看过低版本的人可能会发现 create 和之前稍微有点不一样，但是事实上只是调用的位置有所调整而已，而且这个版本还对 Kotlin 协程做了支持）。注意这个 invoke 方法。
  5. 再回过头看来 eagerlyValidateMethods，其实这里只是采用饿汉的形式，预先遍历了接口的符合要求的方法做 loadServiceMethod 处理。

二、loadServiceMethod

这个方法是将我们定义的接口方法，通过注解解析为一个 ServiceMethod 对象，是核心部分。

     // Retrofit.java
   ServiceMethod loadServiceMethod(Method method) {
    // 1、
    ServiceMethod result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        // 2、
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }
  1. 可以看到这里用了一个 Map 保存了 ServiceMethod 对象，method 为 key。
  2. 如果前面没有取到则通过 ServiceMethod.parseAnnotations 解析创建一个，然后放到 Map 中。
  // ServiceMethod.java
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    // 3、
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
        // 4、
    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(method,
          "Method return type must not include a type variable or wildcard: %s", returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
        // 5、
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }
  1. 调用 RequestFactory.parseAnnotations 方法解析请求接口，返回 RequestFactory 为之后构造 OkHttp 的 Request 做准备。
  2. 对接口方法的返回值做非法的判断，如果非法直接抛出异常。
  3. 创建 HttpServiceMethod 对象，这个后面会讲到。

三、RequestFactory.parseAnnotations

对应第二节步骤 3 的解析处理。

  // RequestFactory.java
  static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
  }

        // Builder.build()
    RequestFactory build() {
      // 1、
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
            // 2、没有具体的请求类型
      if (httpMethod == null) {
        throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        // isMultipart 但是却没有请求体
        if (isMultipart) {
          throw methodError(method,
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        // isFormEncoded 但是却没有请求体
        if (isFormEncoded) {
          throw methodError(method, "FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }
            // 3、
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
      }
            // 4、
      if (relativeUrl == null && !gotUrl) {
        throw methodError(method, "Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError(method, "Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError(method, "Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError(method, "Multipart method must contain at least one @Part.");
      }
            // 5、
      return new RequestFactory(this);
    }
  1. 遍历方法上的注解，并解析，主要是解析方法对应 Http 请求的方法（GET、POST 之类的）以及首部字段。可以从下边的代码看的，请求的类型都是注解，而与之对应的参数都是通过正则匹配解析。
    private void parseMethodAnnotation(Annotation annotation) {
      // PATCH、POST、PUT 类型的请求有请求体，其余的没有
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
      } else if (annotation instanceof PATCH) {
        parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
      } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
      } else if (annotation instanceof PUT) {
        parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
      } else if (annotation instanceof OPTIONS) {
        parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
      } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
      } 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);
      } else if (annotation instanceof Multipart) {
        if (isFormEncoded) {
          throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isMultipart = true;
      } else if (annotation instanceof FormUrlEncoded) {
        if (isMultipart) {
          throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isFormEncoded = true;
      }
    }
    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;
      }

      // 解析 path 信息，以及参数 
      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);
        if (queryParamMatcher.find()) {
          throw methodError(method, "URL query string \"%s\" must not have replace block. "
              + "For dynamic query parameters use @Query.", queryParams);
        }
      }

      this.relativeUrl = value;
      this.relativeUrlParamNames = parsePathParameters(value);
    }

  1. 不合法情况的检查，基本上就是定义接口不符合规泛造成的前后矛盾的情况。

  2. 遍历请求接口方法的参数上的注解，并解析成为 ParameterHandler 保存在一个数组中。

    解析的方法为 parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter) 它的几个参数分别是参数的索引、参数的类型、参数的注解、是否可能是 Kotlin 的 suspend 方法，因为在 Kotlin 编译的时候针对 suspend 方法会给它添加一个为 Continuation 类型的参数，所以这里在解析最后一个参数的时候可能会对参数类型进行判断，如果为 Continuation 则表明这个接口方法是 suspend 的，然后会用 isKotlinSuspendFunction = true 做标记。

    解析为 ParameterHandler 的代码比较多这里就不粘贴代码了，而且它的具体实现也有很多，但是最终使用的时候都会调用它们的 apply 方法，并且传入 retrofit2.RequestBuilder 对象，以及该 ParameterHandler 对应的参数，然后不同类型的 ParameterHandler 会调用 retrofit2.RequestBuilder 做不同的处理来构建请求。

  3. 又是不合法情况的检查。

  4. 返回 RequestFactory 对象到第二节步骤 3。

四、HttpServiceMethod.parseAnnotations

对应第二节步骤 5 的解析处理。这里包含了 Retrofit 两个很重要的操作：

  • 创建适配器可以把 OkHttpCall 适配为我们最初 api 接口定义的方法的返回值。
  • 创建转换器可以把 ResponseBody 转换为我们最终希望回调里面的参数类型的转换器。
  // HttpServiceMethod.java
  static  HttpServiceMethod parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    // 第三节步骤 3 提到的 suspend 方法的标记
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;

    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    if (isKotlinSuspendFunction) {
      // 1、
      Type[] parameterTypes = method.getGenericParameterTypes();
      Type responseType = Utils.getParameterLowerBound(0,
          (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
      if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
        // Unwrap the actual body type from Response.
        responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
        continuationWantsResponse = true;
      } else {
        // TODO figure out if type is nullable or not
        // Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class)
        // Find the entry for method
        // Determine if return type is nullable or not
      }
            // 2、
      adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
      annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
    } else {
      // 3、
      adapterType = method.getGenericReturnType();
    }
        // 4、
    CallAdapter callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    Type responseType = callAdapter.responseType();
    // 5、
    if (responseType == okhttp3.Response.class) {
      throw methodError(method, "'"
          + getRawType(responseType).getName()
          + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    if (responseType == Response.class) {
      throw methodError(method, "Response must include generic type (e.g., Response)");
    }
    // TODO support Unit for Kotlin?
    if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
      throw methodError(method, "HEAD method must use Void as response type.");
    }
        // 6、
    Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    // 7、
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod) new SuspendForResponse<>(requestFactory,
          callFactory, responseConverter, (CallAdapter>) callAdapter);
    } else {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod) new SuspendForBody<>(requestFactory,
          callFactory, responseConverter, (CallAdapter>) callAdapter,
          continuationBodyNullable);
    }
  }

  1. 如果是 Kotlin 的 suspend 方法，那么就获取最后一个参数的泛型的下界通配类型（Continuation 对象的泛型），即原 suspend 方法的返回值类型。如果这个类型是个 retrofit2.Response 类型或者带泛型的类型的话，进一步获取泛型的类型。举个例子：

    suspend fun getResponse():Response 那么最终 responseType = ResponseBody.class，然后标记 continuationWantsResponse = true。

  2. 用步骤 1 获取的类型创建 retrofit2.Call 赋值给 adapterType。给方法的注解插入一个 SkipCallbackExecutor 注解，用于跳过 callbackExecutor 的调度（目前不清楚，后面继续关注）。

    如果没有了解过 Kotlin 和协程的话，不用在意步骤 1 和 2也没关系，等了解了再回来看。

  3. 如果不是 Kotlin 的 suspend 方法，那么很简单直接获取返回值的类型。

  4. 创建一个 CallAdapter 对象，这个对象是用来把 OkHttpCall 适配为我们定义的方法的返回值类型的，这里我们看下拿到的对象的实现是什么。

  // HttpServiceMethod.java
  private static  CallAdapter createCallAdapter(
      Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
            // 直接调用 Retrofit 的方法，并进一步调用到 nextCallAdapter
      return (CallAdapter) retrofit.callAdapter(returnType, annotations);
    //省略异常处理
  }

  // Retrofit.java
  public CallAdapter nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
        // 省略一些代码
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    // 通过 callAdapterFactories 查找，那么我们看下这个列表是什么时候创建的
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
    // 省略一些代码
  }

    // Retrofit.Builder 对象的 build()
    public Retrofit build() {
      // 省略一些代码
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        // 如果没定义，获取默认的执行器
        callbackExecutor = platform.defaultCallbackExecutor();
      }
      // 找到了，除了我们在初始化自己的 Retrofit 对象的时候自己可以添加进来
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      // 还有就是和平台相关的默认添加的
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

      //省略一些代码
    }

  // Platform.java 
  static class Android extends Platform {
    // 省略一些代码
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override List defaultCallAdapterFactories(
        @Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      // 因为我在 Android 使用所以直接找 Android 平台，
      // 这里根据目标版本的不同，会有点不一样，但是至少会有一个 DefaultCallAdapterFactory
      // Android api 24 对应 Android 7.0 
      // 但是一般我们开发应用会兼容到 4.0 左右，所以就先忽略 CompletableFutureCallAdapterFactory 了
      DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
      return Build.VERSION.SDK_INT >= 24
        ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
        : singletonList(executorFactory);
    }
    // 省略一些代码
        // 留意一下这个 Executor，仅仅是使用 handler post 到主线程，就是我们 build 方法中执行器的实现
    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());
      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

好了，现在我们终于定位到了创建 CallAdapter 对象的工厂类了 DefaultCallAdapterFactory，马上来看一下获取的具体实现。

  // DefaultCallAdapterFactory.java
  @Override public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    // 省略合法性验证代码
    // 获取泛型上的类型
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
    // 还记得我们步骤 2 中对 Kotlin suspend 方法插入的 SkipCallbackExecutor 注解嘛？生效了
    // 协程会自己调度，所以就不需要我们的调度器了
    final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
        ? null
        : callbackExecutor;

    return new CallAdapter>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call adapt(Call call) {
        // 如果不是协程，我们还是需要调度器来为我们切换线程的，毕竟 OkHttp 的回调不在主线程
        return executor == null
            ? call
            : new ExecutorCallbackCall<>(executor, call);
      }
    };
  }
 
 
我们终于找到了 CallAdapter 的实现，但是现在还没有到它发挥作用的时候，真正使用的时候我们会调用它的 adapt 方法，根据实际的情况会直接返回入参 call，或者进一步分装成 ExecutorCallbackCall 这个我们后面会介绍到。
 
 
ps：看过以前版本 Retrofit 的同学可能还会发现这个 DefaultCallAdapterFactory 是以前版本的 DefaultCallAdapterFactory 和 ExecutorCallAdapterFactory 的合体。
 
 
     
  
  1. 对获取的 CallAdapter.responseType() 合法性的验证。
    2.  
  
  2. 创建一个 Converter 对象，用于把 ResponseBody 转换为我们最终希望回调里面的参数类型，根据文章一开始的例子，我们会得到 BufferingResponseBodyConverter 对象（见 BuiltInConverters.java)，下边看实现。
    3.  
 
 
 
// HttpServiceMethod.java
  private static  Converter createResponseConverter(
      Retrofit retrofit, Method method, Type responseType) {
    Annotation[] annotations = method.getAnnotations();
        // 直接调用 Retrofit 的方法，并进一步调用到 nextResponseBodyConverter
        // 过程和 CallAdapter 类似，直接看 Retrofit.Builder 的 build 方法
      return retrofit.responseBodyConverter(responseType, annotations);
    //省略异常处理
  }

 
 
    // Retrofit.Builder 对象的 build()，省略很多不相关的代码
    public Retrofit build() {
      List converterFactories = new ArrayList<>(
          1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());

      // 首先添加内置转换器工厂，里面实现了多个转换器包括把字节流转换成 ResponseBody，
      // ResponseBody 转换为 java 中的 Void 或者 Kotlin 中的 Unit 时关闭流的操作等
      converterFactories.add(new BuiltInConverters());
      // 有自定义的添加自定义，
      // 我们常用的 GsonConverterFactory 就是把 json 字符串转换为具体对象，
      // 或者把对象转换成 json 字符串
      converterFactories.addAll(this.converterFactories);
      // 平台默认的转换器工厂，下边看一下 Android 平台里面的默认实现
      converterFactories.addAll(platform.defaultConverterFactories());

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

 
 
  // Platform.java 省略不相关的代码
  static class Android extends Platform {

    @Override List defaultConverterFactories() {
      // 好吧，低版本的就直接没有，如果感兴趣的可以看下 GsonConverterFactory 
      return Build.VERSION.SDK_INT >= 24
          ? singletonList(OptionalConverterFactory.INSTANCE)
          : Collections.emptyList();
    }
  }

 
 
     
  
  1.  
    把之前获得的几个对象保存在 HttpServiceMethod 的子类中后返回到动态代理调用方法时候调用 loadServiceMethod(Method method)的地方，见第一节步骤 4。
     
    HttpServiceMethod 的子类有三个，其中两个是为 Kotlin suspend 方法准备的，可以看到 Retrofit 为了协程做了很多工作，我会以介绍非协程为主，但是还是会讲到协程请况下的处理。没有接触过协程的也不用纠结直接略过，等啥时候了解了再来回味一下。
     
    2.  
 
 
 
五、HttpServiceMethod.invoke
 
 
回到第一节步骤 4，拿到 HttpServiceMethod 对象之后我们调用了它 invoke 方法，把参数传递进去。
 
 
即我们基本使用例子里调用 baiDuApi.getBaiDu() 就会触发：
 
 
// Retrofit.java create 方法返回的动态代理中
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);


 
 
  // invoke 是 ServiceMethod 的方法，具体实现在 HttpServiceMethod 中
  // HttpServiceMethod.java
  @Override final @Nullable ReturnT invoke(Object[] args) {
    // 创建了第四节开始提到的 OkHttpCall 对象，紧接着调用自己的抽象 adapt 方法
    // 1、
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }
  protected abstract @Nullable ReturnT adapt(Call call, Object[] args);

 
 
     
  
  1.  
    HttpServiceMethod.invoke 方法中创建了 OkHttpCall 对象，这个对象实现了 retrofit2.Call 接口，里面是封装了使用 OkHttp 发请求的逻辑。之后又调用了自己的抽象方法 adapt，具体实现在子类中。
     
    前面提到 HttpServiceMethod 的子类有三个：CallAdapted，SuspendForResponse，SuspendForBody，看类名称也可以猜想到后两个方法是对 Kotlin suspend 方法的支持。
     
    这里主要讲一下 CallAdapted 类。
     
    2.  
 
 
 
  // HttpServiceMethod.java
  static final class CallAdapted extends HttpServiceMethod {
    private final CallAdapter callAdapter;
        // requestFactory 为第二节步骤 3 拿到的 RequestFactory 对象，用于构建 OkHttp 请求
    // callFactory 为 OkHttpClient 对象
    // responseConverter 为第四节步骤 6 拿到的转换器对象，根据本文基础使用的例子为
    // BufferingResponseBodyConverter
    // callAdapter 为第四节步骤 4 中 DefaultCallAdapterFactory.java 创建的对象
    CallAdapted(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
        Converter responseConverter,
        CallAdapter callAdapter) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }
        // 2、
    @Override protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }
  }

 
 
     
  
  1. 步骤 1会调用到 CallAdapted.adapter，这里在注释中解释了一下 CallAdapted 构造方法里面的几个参数便于理解，实际处理还得看 DefaultCallAdapterFactory 创建的 CallAdapter 见下。
    2.  
 
 
 
    // DefaultCallAdapterFactory.java
    new CallAdapter>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call adapt(Call call) {
        // 如果不是协程，我们还是需要调度器来为我们切换线程的，毕竟 OkHttp 的回调不在主线程
        return executor == null
            ? call // 3、
            : new ExecutorCallbackCall<>(executor, call);
      }
    };
 
 
3、 这里我们会获取到 ExecutorCallbackCall 对象，它的参数分别为把方法放到主线程的 MainThreadExecutor（第四节步骤 4 中提到过）、OkHttpCall。
 
 
六、开始调用请求
 
 
                // 开始的例子
                // 1、
        val retrofitCall = baiDuApi.getBaiDu()
        retrofitCall.enqueue(object : retrofit2.Callback {
            override fun onFailure(call: retrofit2.Call, t: Throwable) {
                Log.d("Retrofit", t.toString())
            }

            override fun onResponse(
                call: retrofit2.Call,
                response: retrofit2.Response
            ) {
                Log.d("Retrofit", response.toString())
            }
        })

 
 
     
  
  1. retrofitCall 就是 ExecutorCallbackCall 对象，调用它的 enqueue 方法，传入我们的监听 Callback 。
    2.  
 
 
 
  // DefaultCallAdapterFactory.java
    // 省略了部分代码
  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) {
      checkNotNull(callback, "callback == null");
            // 2、
      delegate.enqueue(new Callback() {
        @Override public void onResponse(Call call, final Response response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

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

 
 
     
  
  1. delegate 是 OkHttpCall 对象，使用过 OkHttp 的应该知道它的 enqueue 是执行在子线程的，所以 ExecutorCallbackCall 为我们做的就是把在子线程的回调中，通过 MainThreadExecutor 在主线程中调用 retrofit2.Callback 的回调。当然这个 enqueue 还不是真正的 OkHttp 的 enqueue，它做了封装。
    2.  
 
 
 
  // OkHttpCall.java     // 太长了，删除部分代码
  @Override public void enqueue(final Callback callback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;
      if (call == null && failure == null) {
          // 3、
          call = rawCall = createRawCall();
      }
    }
    // 4、
    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
        Response response;
            // 5、
          response = parseResponse(rawResponse);
            // 6、
          callback.onResponse(OkHttpCall.this, response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        callFailure(e);
      }
      private void callFailure(Throwable e) {
          callback.onFailure(OkHttpCall.this, e);
      }
    });
  }
  private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

 
 
     
  
  1. 创建 OkHttp 的请求的 okhttp3.Call 对象，调用了 requestFactory.create(args) 构造 Request 对象。
    2.  
 
 
 
  okhttp3.Request create(Object[] args) throws IOException {
    // 这个数组见第三节步骤 3，里面保存了解析出来的参数的 key 等信息
    ParameterHandler[] handlers = (ParameterHandler[]) parameterHandlers;
    int argumentCount = args.length;
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl,
        headers, contentType, hasBody, isFormEncoded, isMultipart);

    if (isKotlinSuspendFunction) {
            // 如果是 suspend 方法，那么就需要少处理一个，因为最后一个是 Continuation
      argumentCount--;
    }

    List argumentList = new ArrayList<>(argumentCount);
    for (int p = 0; p < argumentCount; p++) {
      argumentList.add(args[p]);
      // 调用 ParameterHandler.apply 往 requestBuilder 里面设置参数
      handlers[p].apply(requestBuilder, args[p]);
    }

    return requestBuilder.get()
        .tag(Invocation.class, new Invocation(method, argumentList))
        .build();
  }
 
 
     
  
  1. 发起真正的 OkHttp 异步请求。
    2.  
  
  2. 解析响应。
    3.  
 
 
 
  Response parseResponse(okhttp3.Response rawResponse) throws IOException {
    // 分离响应体和响应头，使得它们可以单独传输处理
    ResponseBody rawBody = rawResponse.body();
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();

    int code = rawResponse.code();
    if (code < 200 || code >= 300) {
        // 请求状态异常的响应
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
    }

    if (code == 204 || code == 205) {
      rawBody.close();
      // 204 和 205 只需要传送响应头
      return Response.success(null, rawResponse);
    }

    ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
        // 调用转换器将 ExceptionCatchingResponseBody 转换成我们需要的数据对象
        // 有兴趣可以看下我们前面提到的 BufferingResponseBodyConverter
      T body = responseConverter.convert(catchingBody);
      return Response.success(body, rawResponse);
  }

 
 
     
  
  1. 回调操作，这里还是在子线程，通过 ExecutorCallbackCall 里面的流程，调用到主线程，到这里我们就真正的走过了一次 Retrofit 从 create 创建 Call 到发送请求，然后到回调主线程的操作了。
    2.  
 
 
 
七、HttpServiceMethod 的子类
 
 
HttpServiceMethod 继承自 ServiceMethod 是 retrofit 中非常重要的对象，由我们定义的 Api 方法解析而来。
 
 
前面提到它有三个子类，第一个 CallAdapted 我们刚才已经讲到过了，那么现在看看另外两个的实现，以及使用场景。
 
 
回顾第四节步骤 1 的解释（代码就不再粘贴了，比较多）:
 
 
 
  
如果是 Kotlin 的 suspend 方法，那么就获取最后一个参数的泛型的下界通配类型（Continuation 对象的泛型），即原 suspend 方法的返回值类型。如果这个类型是个 retrofit2.Response 类型或者带泛型的类型的话，进一步获取泛型的类型。举个例子：
 
  
suspend fun getResponse():Response 那么最终 responseType = ResponseBody.class，然后标记 continuationWantsResponse = true。
 
 
 
 
第四节步骤 2 的解释：
 
 
 
  
用步骤 1 获取的类型创建 retrofit2.Call 赋值给 adapterType。给方法的注解插入一个 SkipCallbackExecutor 注解，用于跳过 callbackExecutor 的调度
 
 
 
 
第四节步骤 4 中获取 CallAdapter 对象时，DefaultCallAdapterFactory 又对插入的 SkipCallbackExecutor 做处理：
 
 
 final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
     ? null
     : callbackExecutor;

 
 
下面为 DefaultCallAdapterFactory 返回的 CallAdapter:
 
 
    new CallAdapter>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call adapt(Call call) {
        // 因为 executor == null，相当于 adapt 方法啥也没做转接了一下
        return executor == null
            ? call
            : new ExecutorCallbackCall<>(executor, call);
      }
    };
 
 
综上如果不是 suspend 方法，OkHttpCall 会被 ExecutorCallbackCall 包一层，然后再保存在 CallAdapted；否则再根据 continuationWantsResponse 判断，如果是 true 相当于直接把 OkHttpCall 保存在 SuspendForResponse，如果 false 相当于直接把 OkHttpCall 保存在 SuspendForBody。
 
 
如果 SuspendForResponse 对应 suspend fun getResponse():Response，
 
 
那么 SuspendForBody 相当于对应 suspend fun getResponse():ResponseBody。
 
 
SuspendForResponse
 
 
  static final class SuspendForResponse extends HttpServiceMethod {
    private final CallAdapter> callAdapter;
        // 省略构造方法
    @Override protected Object adapt(Call call, Object[] args) {
      // 这个 call 就是 OkHttpCall
      call = callAdapter.adapt(call);
            // suspend 方法编译时会给方法添加一个参数 Continuation 它的泛型为原方法的返回值
      // Continuation 相当于一个回调
      Continuation> continuation =
          (Continuation>) args[args.length - 1];

      try {
        // awaitResponse 是一个 suspend 的拓展方法
        return KotlinExtensions.awaitResponse(call, continuation);
      } catch (Exception e) {
        return KotlinExtensions.yieldAndThrow(e, continuation);
      }
    }
  }

 
 
//KotlinExtensions.kt
suspend fun  Call.awaitResponse(): Response {
  // suspendCancellableCoroutine 将异步操作封装为挂起方法
  return suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      cancel()
    }
        // 这个为 OkHttpCall.enqueue
    enqueue(object : Callback {
      override fun onResponse(call: Call, response: Response) {
        // 调用回调
        continuation.resume(response)
      }

      override fun onFailure(call: Call, t: Throwable) {
        continuation.resumeWithException(t)
      }
    })
  }
}

 
 
举个直接用 suspend 请求的例子：
 
 
// @GET("s") suspend fun getResponse():Response
GlobalScope.launch(Dispatchers.Main){
  try{
    val response = baiDuApi.getResponse()
    //成功回调
    Log.d("Retrofit", "launch:$response")
    Log.d("Retrofit", "launch:${Thread.currentThread().name}")
  } catch (t : Throwable){
    //失败回调
    Log.d("Retrofit", "launch:${t.message}")
  }
}

 
 
SuspendForBody
 
 
  static final class SuspendForBody extends HttpServiceMethod {
    private final CallAdapter> callAdapter;
    // 构造方法传入，目前一直是 false，这个判断还是一个 todo，见第四节步骤 1 代码
    private final boolean isNullable;
        // 省略构造方法
    @Override protected Object adapt(Call call, Object[] args) {
      // 这个 call 就是 OkHttpCall
      call = callAdapter.adapt(call);

      Continuation continuation = (Continuation) args[args.length - 1];
      try {
        // awaitNullable,await 实现和上面的 awaitResponse 类似，不再讲
        return isNullable
            ? KotlinExtensions.awaitNullable(call, continuation)
            : KotlinExtensions.await(call, continuation);
      } catch (Exception e) {
        return KotlinExtensions.yieldAndThrow(e, continuation);
      }
    }
  }

 
 
结语
 
 
如果对 OkHttp 的调用流程分析感兴趣，可以看我之前的一篇文章《OkHttp 4.2.2 源码分析》，版本 4.2.2 为是目前最新的，也是用 Kotlin 实现的。
 
 
Retrofit 使我们只需要编写 java 接口就能创建 OkHttp 所需要的请求，以及后续开源的 RxJava2CallAdapterFactory、GsonConverterFactory，让我们也见识到了它设计上的强大。新版本的对 suspend 方法的支持做了很多的工作，但是它的核心原理还是不变的。
 
 
其实阅读源码一个是看其中的原理，另一个是看在代码还能怎么写，顺便思考一下日常开发中是否能运用起来。也希望这篇文章能引起一些没有接触过 Kotlin 协程的同学对协程的兴趣。
 
 
另外，喜欢的同学，觉得对自己有帮助的同学，务必请花一点点时间帮我点个赞！点赞之交淡如水，但这个很重要！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Retrofit 2.6.2 源码分析)

        

            

                
    
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • 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主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • 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硬件
    
                    
    • 
                    
  • 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;
    
                    
    • 
                    
  • [ 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
    
                    
    • 
                    
  • dispatch_once源码分析
                        福伟_Y

                        
    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    
                    
    • 
                    
  • jQuery Easyui 源码分析之combo组件
                        90后北京程序员
前端-easyuieasyui之combobox
                        
    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    
                    
    • 
                    
  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
                        RemusrickCat

                        
    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    
                    
    • 
                    
  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
                        Colourful．
Java集合java集合
                        
    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    
                    
    • 
                    
  • React Native通讯原理
                        zbl_zbl
androidReactNativ
                        
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    
                    
    • 
                    
  • [linux 驱动]增加一个文件节点控制led灯亮灭
                        嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动
                        
    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    
                    
    • 
                    
  • 【QT教程】QT6对话框编程
                        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对话框简介QT6对话框简介
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列十二 事件Event
                        OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发
                        
    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列四 中断Hwi
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核
                        
    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列五 时间管理
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式
                        
    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件
                        
    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件
                        
    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
    
                    
    • 
                    
  • 鸿蒙轻内核A核源码分析系列七 进程管理 (2)
                        OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyosOpenHarmony移动开发驱动开发鸿蒙内核LiteOS-A内核进程通信
                        
    本文先熟悉下进程管理的文件kernel\base\core\los_process.c中的内部接口，读读代码，做些记录。1、LiteOS-A内核进程全局变量⑴是进程池，存放各个进程控制块LosProcessCB的信息。⑵处开始的g_freeProcess是空闲进程链表，挂载各个空闲进程控制块；g_processRecycleList是待回收进程控制块链表，挂载各个等待回收的进程控制块。⑶处开始的g
    
                    
    • 
                    
  • 鸿蒙原生开发——轻内核A核源码分析系列三 物理内存（2）
                        OpenHarmony_小贾
鸿蒙开发HarmonyOSOpenHarmonyharmonyosopenharmony移动开发程序人生鸿蒙开发
                        
    3.1.2.3函数OsVmPhysLargeAlloc当执行到这个函数时，说明空闲链表上的单个内存页节点的大小已经不能满足要求，超过了第9个链表上的内存页节点的大小了。⑴处计算需要申请的内存大小。⑵从最大的链表上进行遍历每一个内存页节点。⑶根据每个内存页的开始内存地址，计算需要的内存的结束地址，如果超过内存段的大小，则继续遍历下一个内存页节点。⑷处此时paStart表示当前内存页的结束地址，接下来
    
                    
    • 
                    
  • Android kotlin开发项目MVP架构搭建
                        哎吆我呸
androidKotlin初入门
                        
    1、引入需要的网络库implementation'com.squareup.retrofit2:retrofit:2.7.1'implementation'com.squareup.retrofit2:converter-gson:2.7.1'implementation'com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.
    
                    
    • 
                    
  • JsonCpp源码分析——Reader
                        哎呦，帅小伙哦
#jsoncppjson
                        
    1、与Writer模块功能相反，可以将Reader理解成一个反序列化的工具，Writer的作用主要是将Value对象转成string或者流式的结构，Reader的作用主要是将流式的结构转成Value类型的对象。Reader类的主要职责有3个，解析JSON字符串：将JSON格式的字符串读取并解析成相应的C++数据结构。处理不同的数据类型，支持解析JSON对象、数组、字符串、数字、布尔值和null。处
    
                    
    • 
                    
  • vue源码分析-挂载流程和模板编译
                        yyzzabc123
vue.js
                        
    前面几节我们从newVue创建实例开始，介绍了创建实例时执行初始化流程中的重要两步，配置选项的资源合并,以及响应式系统的核心思想，数据代理。在合并章节，我们对Vue丰富的选项合并策略有了基本的认知，在数据代理章节我们又对代理拦截的意义和使用场景有了深入的认识。按照Vue源码的设计思路，初始化过程还会进行很多操作，例如组件之间创建关联，初始化事件中心，初始化数据并建立响应式系统等，并最终将模板和数据
    
                    
    • 
                    
  • 鸿蒙内核解析,鸿蒙内核源码分析(内存概念篇)|解读鸿蒙源码
                        刘轩鸿
鸿蒙内核解析
                        
    提示：本文基于开源鸿蒙内核分析，官方源码【kernel_liteos_a】官方文档【docs】参考文档【HuaweiLiteOS】本文作者：鸿蒙内核发烧友，用生活场景讲故事的方式去解构内核，一窥究竟，让神秘的内核栩栩如生，浮现眼前。博文全部原创，持续更新，敬请关注。内容仅代表个人观点，错误之处，欢迎大家指正完善。本系列全部文章进入鸿蒙源码分析(总目录)查看目录最难讲的章节坦白讲内存是整个系列里面最
    
                    
    • 
                                
  • 异常的核心类Throwable
                                    无量
java源码异常处理exception
                                    
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy 
 
 
 
package com.natsu;



    
                                
    • 
                                
  • mongoDB 游标（cursor） 实现分页 迭代
                                    开窍的石头
mongodb
                                    
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询 
 
     如何声明一个游标 
       var mycursor = db.user.find({_id:{$lte:5}}); 
      迭代显示游标数
    
                                
    • 
                                
  • MySQL数据库INNODB 表损坏修复处理过程
                                    0624chenhong
tomcatmysql
                                    
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
    
                                
    • 
                                
  • 剖析如何与设计人员沟通
                                    不懂事的小屁孩
工作
                                    
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 
 
那应该如何与设计人员沟通呢？ 
 
我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
    
                                
    • 
                                
  • qq空间刷评论工具
                                    换个号韩国红果果
JavaScript
                                    
    

var a=document.getElementsByClassName('textinput');
					var b=[];
					for(var m=0;m<a.length;m++){
						if(a[m].getAttribute('placeholder')!=null)
							b.push(a[m])
					}
					var l
    
                                
    • 
                                
  • S2SH整合之session
                                    灵静志远
springAOPstrutssession
                                    
    错误信息： 
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
    
                                
    • 
                                
  • xmp标签
                                    a-john
标签
                                    
    今天在处理数据的显示上遇到一个问题： 
var html = '<li><div class="pl-nr"><span class="user-name">' + user
           + '</span>' + text + '</div></li>';
ulComme
    
                                
    • 
                                
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单
                                    aijuans
Ajax
                                    
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
    
                                
    • 
                                
  • 天-安-门，好高
                                    atongyeye
情感
                                    
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。 
 
    晚上躺在床上一个人想了很久，很久。 
   
    我生在农
    
                                
    • 
                                
  • android 动画
                                    百合不是茶
android透明度平移缩放旋转
                                    
    android的动画有两种  tween动画和Frame动画 
  
tween动画;,透明度,缩放,旋转,平移效果 
  
Animation   动画 
AlphaAnimation 渐变透明度 
RotateAnimation 画面旋转 
ScaleAnimation 渐变尺寸缩放 
TranslateAnimation 位置移动 
Animation
    
                                
    • 
                                
  • 查看本机网络信息的cmd脚本
                                    bijian1013
cmd
                                    
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt"
@echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt"
@echo ___________________>>"%userprofile%\
    
                                
    • 
                                
  • plsql 清除登录过的用户
                                    征客丶
plsql
                                    
    tools---preferences----logon history---history  把你想要删除的删除 
 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一起进步。 
email ： binary_spac
    
                                
    • 
                                
  • 【Pig一】Pig入门
                                    bit1129
pig
                                    
    Pig安装 
1.下载pig 
  
wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz 
  
2. 解压配置环境变量 
  
   如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量 
  
expor
    
                                
    • 
                                
  • Java 线程同步几种方式
                                    BlueSkator
volatilesynchronizedThredLocalReenTranLockConcurrent
                                    
    为何要使用同步？       java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），        将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，        从而保证了该变量的唯一性和准确性。    1.同步方法&
    
                                
    • 
                                
  • StringUtils判断字符串是否为空的方法（转帖）
                                    BreakingBad
nullStringUtils“”
                                    
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html 
  
public static boolean isEmpty(String str)      
　　判断某字符串是否为空，为空的标准是 str== 
null  
或 str.length()== 
0    
    
                                
    • 
                                
  • 编程之美-分层遍历二叉树
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LevelTraverseBinaryTree {

    /**
     * 编程之美 分层遍历二叉树
     * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
    
                                
    • 
                                
  • jquery取值和ajax提交复习记录
                                    chengxuyuancsdn
jquery取值ajax提交
                                    
    
// 取值
	// alert($("input[name='username']").val());
	// alert($("input[name='password']").val());
	// alert($("input[name='sex']:checked").val());
	// alert($("
    
                                
    • 
                                
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression
                                    comsci
java应用服务器工作Excel嵌入式
                                    
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 
----------转帖--------------------------------------------------- 
 IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
    
                                
    • 
                                
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer
                                    daizj
spring
                                    
    1、PropertyPlaceholderConfigurer 
Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 
 
基本的使用方法是：(1) 
 
<bean id="propertyConfigurerForWZ&q
    
                                
    • 
                                
  • 二叉树:二叉搜索树
                                    dieslrae
二叉树
                                    
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. 
 
tree代码: 
 

    
                                
    • 
                                
  • C语言字符串函数大全
                                    dcj3sjt126com
cfunction
                                    
    C语言字符串函数大全 
  
  
函数名: stpcpy 
功 能: 拷贝一个字符串到另一个 
用 法: char *stpcpy(char *destin, char *source); 
程序例: 
  
#include <stdio.h> 
#include <string.h> 
  
int main
    
                                
    • 
                                
  • 友盟统计页面技巧
                                    dcj3sjt126com
技巧
                                    
    在基类调用就可以了, 基类ViewController示例代码 
-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];

    
                                
    • 
                                
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法
                                    flyvszhb
javajdk
                                    
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 
 
本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 
 安装jdk1.6前，执行java -version得到 
C:\Users\liuxiang2>java -version 
java version "1.7.0_21&quo
    
                                
    • 
                                
  • Java在创建子类对象的同时会不会创建父类对象
                                    happyqing
java创建子类对象父类对象
                                    
      
1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象， 
  
2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
    
                                
    • 
                                
  • 跟我学spring3 目录贴及电子书下载
                                    jinnianshilongnian
spring
                                    
      
  一、《跟我学spring3》电子书下载地址： 
《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf   
  
跟我学spring3系列 word原版 下载 
  
  二、
源代码下载  
最新依
    
                                
    • 
                                
  • 第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/
    
                                
    • 
                                
  • BI and EIM 4.0 at a glance
                                    blueoxygen
BO
                                    
    http://www.sap.com/corporate-en/press.epx?PressID=14787 
  
有机会研究下EIM家族的两个新产品~~~~ 
  
New features of the 4.0 releases of BI and EIM solutions include:  
 
  Real-time in-memory computing – 
    
                                
    • 
                                
  • Java线程中yield与join方法的区别
                                    tomcat_oracle
java
                                    
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 
&nb
    
                                
    • 
                                
  • android Manifest.xml选项
                                    阿尔萨斯
Manifest
                                    
    结构 
继承关系 
public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 
内部类 
 
 
 class Manifest.permission权限 
 class Manifest.permission_group权限组 
 构造函数 
 
public Manifest () 详细  androi
    
                                
    • 
                                
  • Oracle实现类split函数的方
                                    zhaoshijie
oracle
                                    
    关键字：Oracle实现类split函数的方 
项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 
 
CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); 
 
cr
    
                                
    •