就叫汉堡吧
就叫汉堡吧

Retrofit源码分析

  • 本文概述

    Retrofit作为主流的网络框架，采用注解和接口的方式封装请求，使得调用过程变得优雅又简洁，优雅的背后肯定是卓越的设计，所以从源码角度分析一下Retrofit是如何做到的，整理成文。

  • 使用回顾

    public interface GitHubService {

    @GET("group/{id}/users?sort=desc")
    Call> groupList(@Path("id") int groupId);

    /**
     * 和上面的是一样的意义
     *
     * @param groupId
     * @param sort
     * @return
     */
    @GET("group/{id}/users")
    Call> groupList(@Path("id") int groupId, @Query("sort") String sort);

    /**
     * 相当于group/{id}/users？options.key[0]=options.value[0] & options.key[1]=options.value[1] & ...
     *
     * @param groupId
     * @param options
     * @return
     */
    @GET("group/{id}/users")
    Call> groupList(@Path("id") int groupId, @QueryMap Map options);

    @POST("users/new")
    Call createUser(@Body User user);

    @FormUrlEncoded
    @POST("user/edit")
    Call updateUser(@Field("first_name") String first, @Field("last_name") String last);

    @Multipart
    @PUT("user/photo")
    Call updateUser(@Part("photo") RequestBody photo, @Part("description") RequestBody description);

    /**
     * 静态Header
     * @return
     */
    @Headers("Cache-Control: max-age=640000")
    @GET("widget/list")
    Call> widgetList();

    @Headers({
            "Accept: application/vnd.github.v3.full+json",
            "User-Agent: Retrofit-Sample-App"
    })
    @GET("users/{username}")
    Call getUserS(@Path("username") String username);

    /**
     * 动态设置Header
     * @param authorization
     * @return
     */
    @GET("user")
    Call getUser(@Header("Authorization") String authorization);

    @GET("user")
    Call getUser(@HeaderMap Map headers);

}

    public static void retrofitDemo(String url) {
    OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(url)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .build();

    GitHubService service = retrofit.create(GitHubService.class);
    try {
        List users = service.groupList(1001).execute().body();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

    可以看到，Retrofit是一种更上层的封装，你可以设置不同的网络框架client，这里是OkHttpClient，设置baseUrl，之后会和interface类中的请求注解路由参数结合在一起构成整体的url，不用像OkHttpClient每次请求都要传入整个url，ConverterFactory可以根据想要解析的格式自由选择，通常我们使用的都是bean->json、json->bean，现在这部分工作我们可以交给Retrofit去做，其他的Converter还有：

    • Gson: com.squareup.retrofit2:converter-gson
    • Jackson: com.squareup.retrofit2:converter-jackson
    • Moshi: com.squareup.retrofit2:converter-moshi
    • Protobuf: com.squareup.retrofit2:converter-protobuf
    • Wire: com.squareup.retrofit2:converter-wire
    • Simple XML: com.squareup.retrofit2:converter-simplexml
    • JAXB: com.squareup.retrofit2:converter-jaxb
    • Scalars (primitives, boxed, and String): com.squareup.retrofit2:converter-scalars

    通过Retrofit实例构造出调用service的实例，调用其方法获取Response数据，简单的调用背后是复杂又巧妙的抽象设计，下面跟着源码好好的学习一下它的原理。

  • 源码分析

    首先baseUrl就是个验证并将url解析成http或者https格式并保存成HttpUrl对象的方法，client方法将OkHttpClient绑定到Retrofit.Builder，addConverterFactory把第三方的解析库对象添加进一个List类型的集合，build方法就是构建出Retrofit实例：

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

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

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

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

  // Make a defensive copy of the converters.
  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());

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

    可以看到，build里面还加入了容错默认处理。baseUrl不能为空，这是必须参数之一，callFactory默认OkHttpClient，这里还有个Executor需要设置，因为我们外面没有设置过这个，所以它是null，然后通过platform的defaultCallbackExecutor方法创建，platform是通过实例话Builder时通过Platform.get()得到的：

    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，所以这里是Dalvik虚拟机，因此是Android()作为platform，它的defaultCallbackExecutor如下：

    @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);
  }
}

    所以这里使用MainThreadExecutor作为callbackExecutor，可以看到，Android回调操作通常都是和UI的交互，所以回调操作默认是要回到主线程操作的。

    再往下需要注意的是converterFactories除了添加我们外面传入的this.converterFactories之外还添加了一个BuiltInConverters和platform.defaultConverterFactories()，注意添加顺序，platform.defaultConverterFactories()，这个方法实现在Platform中：

    List defaultConverterFactories() {
  return hasJava8Types ? singletonList(OptionalConverterFactory.INSTANCE) : emptyList();
}

    hasJava8Types是在Platfrom构造方法中指定的，这里用的是Android()，所以hasJava8Types默认是false，所以这里defaultConverterFactories返回emptyList()，所以此时converterFactories里面有BuiltInConverters和我们设置的一个Converter（这里是GsonConverterFactory）。

    接下来就是调用create获取接口service对象，那interface是怎样可能创建对象呢？还有interface方法的注解是如何映射成最后发送的request的呢？继续往下看：

    @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
public  T create(final Class service) {
  //检查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);
            }
          });
}

private void validateServiceInterface(Class service) {
  //service必须是interface
  if (!service.isInterface()) {
    throw new IllegalArgumentException("API declarations must be interfaces.");
  }
  
  //使用双向队列保存service及其继承的其他interface，add是添加到队尾，然后从头部依次读取判断每个interface是否符合
  Deque> check = new ArrayDeque<>(1);
  check.add(service);
  while (!check.isEmpty()) {
    Class candidate = check.removeFirst();
    //这里要求接口不能有泛型
    if (candidate.getTypeParameters().length != 0) {
      StringBuilder message =
          new StringBuilder("Type parameters are unsupported on ").append(candidate.getName());
      if (candidate != service) {
        message.append(" which is an interface of ").append(service.getName());
      }
      throw new IllegalArgumentException(message.toString());
    }
    Collections.addAll(check, candidate.getInterfaces());
  }

  //创建retrofit对象时传入的最后一个参数，表示是否提前执行loadServiceMethod方法
  if (validateEagerly) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      //不能是default方法和静态方法。
      //根据isDefaultMethod的javadoc注释，default方法是非静态且有body的，这种方法在interface中存在必须需要default修饰符修饰且需要JDK1.8及以上。
      //interface中static修饰的方法需要有方法体
      if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
        loadServiceMethod(method);
      }
    }
  }
}

ServiceMethod loadServiceMethod(Method method) {
  //之前的validateEagerly如果是true，那在create中调用loadServiceMethod的时候就直接从serviceMethodCache里面取，因为之前已经创建好了
  ServiceMethod result = serviceMethodCache.get(method);
  if (result != null) return result;

  synchronized (serviceMethodCache) {
    result = serviceMethodCache.get(method);
    if (result == null) {
      //创建ServiceMethod的地方
      result = ServiceMethod.parseAnnotations(this, method);
      serviceMethodCache.put(method, result);
    }
  }
  return result;
}

    代码的作用我已经在注释中写明了，现在我们知道了实际上retrofit.create创建的是一个GithubService这个接口的动态代理，所以service.groupList实际上调用的动态代理的方法，至于动态代理的对象是怎么创建的，目前只能追溯到native方法，现在先不考虑JVM是怎么实例化代理对象的，我们只需要知道，当我们调用service.groupList的时候会回调到Proxy.newProxyInstance的最后一个参数new InvocationHandler()的invoke方法里，所以最终还是会调用loadServiceMethod方法，前面看到，loadServiceMethod方法创建的result返回对象在于ServiceMethod.parseAnnotations(this, method)：

    static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
  RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

  //getGenericReturnType()会返回代码中书写的类型，比如说T method(){},则会返回T，而getReturnType会返回Object
  Type returnType = method.getGenericReturnType();
  //验证返回类型是否合法
  if (Utils.hasUnresolvableType(returnType)) {
    throw methodError(
        method,
        "Method return type must not include a type variable or wildcard: %s",
        returnType);
  }
  //返回类型不能是void
  if (returnType == void.class) {
    throw methodError(method, "Service methods cannot return void.");
  }

return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}

  
  这个方法首先通过RequestFactory.parseAnnotations创建了一个RequestFactory：
  
  ```java
  static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
  }

Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;
  this.method = method;
  this.methodAnnotations = method.getAnnotations();
  this.parameterTypes = method.getGenericParameterTypes();
  this.parameterAnnotationsArray = method.getParameterAnnotations();
}

RequestFactory build() {
  //解析作用于方法上的注解（做用于方法上的注解可以有多个，所以是循环解析）
  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }

  if (httpMethod == null) {
    throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
  }

  if (!hasBody) {
    if (isMultipart) {
      throw methodError(
          method,
          "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
    }
    if (isFormEncoded) {
      throw methodError(
          method,
          "FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
    }
  }

  //解析作用于方法参数上的注解(注意parameterAnnotationsArray是一个二维数组，因为有多个参数，每个参数又可能拥有多个注解，但是只允许有一个注解)
  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);
  }

  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.");
  }

  return new RequestFactory(this);
}

首先调用了parseMethodAnnotation解析方法上的注解：

private void parseMethodAnnotation(Annotation annotation) {
  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;
  }
}

阅读代码可知，判断Annotation的类型，调用parseHttpMethodAndPath对应解析，注意只有PATCH、POST、PUT的hasBody参数传入的是true，不同的是Headers注解调用parseHeaders()，Multipart和FormUrlEncoded(表单)是互斥的，它俩分别结合PUT和POST使用，所以没有path。首先看一下parseHttpMethodAndPath方法：

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;
  //如果没有path则返回
  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.
    //queryParams是?后面的内容
    String queryParams = value.substring(question + 1);
    //PARAM_URL_REGEX是\{XXX}\这种样式，不允许出现在?后面，需要使用@Query注解在方法参数里添加
    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);
    }
  }
  //比如/table?id=1，this.relativeUrl就是/table?id=1
  this.relativeUrl = value;
  this.relativeUrlParamNames = parsePathParameters(value);
}

static Set parsePathParameters(String path) {
  Matcher m = PARAM_URL_REGEX.matcher(path);
  Set patterns = new LinkedHashSet<>();
  while (m.find()) {
    patterns.add(m.group(1));
  }
  return patterns;
}

parsePathParameters会把?前面的\{paramName}\形式的参数名存到一个LinkedHashSet中，为什么是链式的，因为如果方法参数中没有指定参数名注解，则会按照顺序对应赋值。

parseHeaders就是根据“key:value”的形式去解析键值对，Content-Type需要通过MediaType解析：

private Headers parseHeaders(String[] headers) {
  Headers.Builder builder = new Headers.Builder();
  for (String header : headers) {
    int colon = header.indexOf(':');
    if (colon == -1 || colon == 0 || colon == header.length() - 1) {
      throw methodError(
          method, "@Headers value must be in the form \"Name: Value\". Found: \"%s\"", header);
    }
    String headerName = header.substring(0, colon);
    String headerValue = header.substring(colon + 1).trim();
    if ("Content-Type".equalsIgnoreCase(headerName)) {
      try {
        contentType = MediaType.get(headerValue);
      } catch (IllegalArgumentException e) {
        throw methodError(method, e, "Malformed content type: %s", headerValue);
      }
    } else {
      builder.add(headerName, headerValue);
    }
  }
  return builder.build();
}

回到RequestFactory的build，parseParameter解析方法参数：

private @Nullable ParameterHandler parseParameter(
    int p, Type parameterType, @Nullable Annotation[] annotations, boolean allowContinuation) {
  ParameterHandler result = null;
  if (annotations != null) {
    for (Annotation annotation : annotations) {
      ParameterHandler annotationAction =
          parseParameterAnnotation(p, parameterType, annotations, annotation);

      if (annotationAction == null) {
        continue;
      }

      if (result != null) {
        throw parameterError(
            method, p, "Multiple Retrofit annotations found, only one allowed.");
      }

      result = annotationAction;
    }
  }

  if (result == null) {
    if (allowContinuation) {
      try {
        if (Utils.getRawType(parameterType) == Continuation.class) {
          isKotlinSuspendFunction = true;
          return null;
        }
      } catch (NoClassDefFoundError ignored) {
      }
    }
    throw parameterError(method, p, "No Retrofit annotation found.");
  }

  return result;
}

parseParameterAnnotation的源码：

@Nullable
private ParameterHandler parseParameterAnnotation(
    int p, Type type, Annotation[] annotations, Annotation annotation) {
  if (annotation instanceof Url) {
    validateResolvableType(p, type);
    if (gotUrl) {
      throw parameterError(method, p, "Multiple @Url method annotations found.");
    }
    if (gotPath) {
      throw parameterError(method, p, "@Path parameters may not be used with @Url.");
    }
    if (gotQuery) {
      throw parameterError(method, p, "A @Url parameter must not come after a @Query.");
    }
    if (gotQueryName) {
      throw parameterError(method, p, "A @Url parameter must not come after a @QueryName.");
    }
    if (gotQueryMap) {
      throw parameterError(method, p, "A @Url parameter must not come after a @QueryMap.");
    }
    if (relativeUrl != null) {
      throw parameterError(method, p, "@Url cannot be used with @%s URL", httpMethod);
    }

    gotUrl = true;

    if (type == HttpUrl.class
        || type == String.class
        || type == URI.class
        || (type instanceof Class && "android.net.Uri".equals(((Class) type).getName()))) {
      return new ParameterHandler.RelativeUrl(method, p);
    } else {
      throw parameterError(
          method,
          p,
          "@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.");
    }

  } else if (annotation instanceof Path) {
    validateResolvableType(p, type);
    if (gotQuery) {
      throw parameterError(method, p, "A @Path parameter must not come after a @Query.");
    }
    if (gotQueryName) {
      throw parameterError(method, p, "A @Path parameter must not come after a @QueryName.");
    }
    if (gotQueryMap) {
      throw parameterError(method, p, "A @Path parameter must not come after a @QueryMap.");
    }
    if (gotUrl) {
      throw parameterError(method, p, "@Path parameters may not be used with @Url.");
    }
    if (relativeUrl == null) {
      throw parameterError(
          method, p, "@Path can only be used with relative url on @%s", httpMethod);
    }
    gotPath = true;

    Path path = (Path) annotation;
    String name = path.value();
    validatePathName(p, name);

    Converter converter = retrofit.stringConverter(type, annotations);
    return new ParameterHandler.Path<>(method, p, name, converter, path.encoded());

  } else if (annotation instanceof Query) {
    validateResolvableType(p, type);
    Query query = (Query) annotation;
    String name = query.value();
    boolean encoded = query.encoded();

    Class rawParameterType = Utils.getRawType(type);
    gotQuery = true;
    if (Iterable.class.isAssignableFrom(rawParameterType)) {
      if (!(type instanceof ParameterizedType)) {
        throw parameterError(
            method,
            p,
            rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
      }
      ParameterizedType parameterizedType = (ParameterizedType) type;
      Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
      Converter converter = retrofit.stringConverter(iterableType, annotations);
      return new ParameterHandler.Query<>(name, converter, encoded).iterable();
    } else if (rawParameterType.isArray()) {
      Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
      Converter converter =
          retrofit.stringConverter(arrayComponentType, annotations);
      return new ParameterHandler.Query<>(name, converter, encoded).array();
    } else {
      Converter converter = retrofit.stringConverter(type, annotations);
      return new ParameterHandler.Query<>(name, converter, encoded);
    }

  } else if (annotation instanceof QueryName) {
    validateResolvableType(p, type);
    QueryName query = (QueryName) annotation;
    boolean encoded = query.encoded();

    Class rawParameterType = Utils.getRawType(type);
    gotQueryName = true;
    if (Iterable.class.isAssignableFrom(rawParameterType)) {
      if (!(type instanceof ParameterizedType)) {
        throw parameterError(
            method,
            p,
            rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
      }
      ParameterizedType parameterizedType = (ParameterizedType) type;
      Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
      Converter converter = retrofit.stringConverter(iterableType, annotations);
      return new ParameterHandler.QueryName<>(converter, encoded).iterable();
    } else if (rawParameterType.isArray()) {
      Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
      Converter converter =
          retrofit.stringConverter(arrayComponentType, annotations);
      return new ParameterHandler.QueryName<>(converter, encoded).array();
    } else {
      Converter converter = retrofit.stringConverter(type, annotations);
      return new ParameterHandler.QueryName<>(converter, encoded);
    }

  } else if (annotation instanceof QueryMap) {
    validateResolvableType(p, type);
    Class rawParameterType = Utils.getRawType(type);
    gotQueryMap = true;
    if (!Map.class.isAssignableFrom(rawParameterType)) {
      throw parameterError(method, p, "@QueryMap parameter type must be Map.");
    }
    Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
    if (!(mapType instanceof ParameterizedType)) {
      throw parameterError(
          method, p, "Map must include generic types (e.g., Map)");
    }
    ParameterizedType parameterizedType = (ParameterizedType) mapType;
    Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
    if (String.class != keyType) {
      throw parameterError(method, p, "@QueryMap keys must be of type String: " + keyType);
    }
    Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
    Converter valueConverter = retrofit.stringConverter(valueType, annotations);

    return new ParameterHandler.QueryMap<>(
        method, p, valueConverter, ((QueryMap) annotation).encoded());

  } else if (annotation instanceof Header) {
    validateResolvableType(p, type);
    Header header = (Header) annotation;
    String name = header.value();

    Class rawParameterType = Utils.getRawType(type);
    if (Iterable.class.isAssignableFrom(rawParameterType)) {
      if (!(type instanceof ParameterizedType)) {
        throw parameterError(
            method,
            p,
            rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
      }
      ParameterizedType parameterizedType = (ParameterizedType) type;
      Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
      Converter converter = retrofit.stringConverter(iterableType, annotations);
      return new ParameterHandler.Header<>(name, converter).iterable();
    } else if (rawParameterType.isArray()) {
      Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
      Converter converter =
          retrofit.stringConverter(arrayComponentType, annotations);
      return new ParameterHandler.Header<>(name, converter).array();
    } else {
      Converter converter = retrofit.stringConverter(type, annotations);
      return new ParameterHandler.Header<>(name, converter);
    }

  } else if (annotation instanceof HeaderMap) {
    if (type == Headers.class) {
      return new ParameterHandler.Headers(method, p);
    }

    validateResolvableType(p, type);
    Class rawParameterType = Utils.getRawType(type);
    if (!Map.class.isAssignableFrom(rawParameterType)) {
      throw parameterError(method, p, "@HeaderMap parameter type must be Map.");
    }
    Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
    if (!(mapType instanceof ParameterizedType)) {
      throw parameterError(
          method, p, "Map must include generic types (e.g., Map)");
    }
    ParameterizedType parameterizedType = (ParameterizedType) mapType;
    Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
    if (String.class != keyType) {
      throw parameterError(method, p, "@HeaderMap keys must be of type String: " + keyType);
    }
    Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
    Converter valueConverter = retrofit.stringConverter(valueType, annotations);

    return new ParameterHandler.HeaderMap<>(method, p, valueConverter);

  } else if (annotation instanceof Field) {
    validateResolvableType(p, type);
    if (!isFormEncoded) {
      throw parameterError(method, p, "@Field parameters can only be used with form encoding.");
    }
    Field field = (Field) annotation;
    String name = field.value();
    boolean encoded = field.encoded();

    gotField = true;

    Class rawParameterType = Utils.getRawType(type);
    if (Iterable.class.isAssignableFrom(rawParameterType)) {
      if (!(type instanceof ParameterizedType)) {
        throw parameterError(
            method,
            p,
            rawParameterType.getSimpleName()
                + " must include generic type (e.g., "
                + rawParameterType.getSimpleName()
                + ")");
      }
      ParameterizedType parameterizedType = (ParameterizedType) type;
      Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
      Converter converter = retrofit.stringConverter(iterableType, annotations);
      return new ParameterHandler.Field<>(name, converter, encoded).iterable();
    } else if (rawParameterType.isArray()) {
      Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
      Converter converter =
          retrofit.stringConverter(arrayComponentType, annotations);
      return new ParameterHandler.Field<>(name, converter, encoded).array();
    } else {
      Converter converter = retrofit.stringConverter(type, annotations);
      return new ParameterHandler.Field<>(name, converter, encoded);
    }

  } else if (annotation instanceof FieldMap) {
    validateResolvableType(p, type);
    if (!isFormEncoded) {
      throw parameterError(
          method, p, "@FieldMap parameters can only be used with form encoding.");
    }
    Class rawParameterType = Utils.getRawType(type);
    if (!Map.class.isAssignableFrom(rawParameterType)) {
      throw parameterError(method, p, "@FieldMap parameter type must be Map.");
    }
    Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
    if (!(mapType instanceof ParameterizedType)) {
      throw parameterError(
          method, p, "Map must include generic types (e.g., Map)");
    }
    ParameterizedType parameterizedType = (ParameterizedType) mapType;
    Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
    if (String.class != keyType) {
      throw parameterError(method, p, "@FieldMap keys must be of type String: " + keyType);
    }
    Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
    Converter valueConverter = retrofit.stringConverter(valueType, annotations);

    gotField = true;
    return new ParameterHandler.FieldMap<>(
        method, p, valueConverter, ((FieldMap) annotation).encoded());

  } else if (annotation instanceof Part) {
    validateResolvableType(p, type);
    if (!isMultipart) {
      throw parameterError(
          method, p, "@Part parameters can only be used with multipart encoding.");
    }
    Part part = (Part) annotation;
    gotPart = true;

    String partName = part.value();
    Class rawParameterType = Utils.getRawType(type);
    if (partName.isEmpty()) {
      if (Iterable.class.isAssignableFrom(rawParameterType)) {
        if (!(type instanceof ParameterizedType)) {
          throw parameterError(
              method,
              p,
              rawParameterType.getSimpleName()
                  + " must include generic type (e.g., "
                  + rawParameterType.getSimpleName()
                  + ")");
        }
        ParameterizedType parameterizedType = (ParameterizedType) type;
        Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
        if (!MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(iterableType))) {
          throw parameterError(
              method,
              p,
              "@Part annotation must supply a name or use MultipartBody.Part parameter type.");
        }
        return ParameterHandler.RawPart.INSTANCE.iterable();
      } else if (rawParameterType.isArray()) {
        Class arrayComponentType = rawParameterType.getComponentType();
        if (!MultipartBody.Part.class.isAssignableFrom(arrayComponentType)) {
          throw parameterError(
              method,
              p,
              "@Part annotation must supply a name or use MultipartBody.Part parameter type.");
        }
        return ParameterHandler.RawPart.INSTANCE.array();
      } else if (MultipartBody.Part.class.isAssignableFrom(rawParameterType)) {
        return ParameterHandler.RawPart.INSTANCE;
      } else {
        throw parameterError(
            method,
            p,
            "@Part annotation must supply a name or use MultipartBody.Part parameter type.");
      }
    } else {
      Headers headers =
          Headers.of(
              "Content-Disposition",
              "form-data; name=\"" + partName + "\"",
              "Content-Transfer-Encoding",
              part.encoding());

      if (Iterable.class.isAssignableFrom(rawParameterType)) {
        if (!(type instanceof ParameterizedType)) {
          throw parameterError(
              method,
              p,
              rawParameterType.getSimpleName()
                  + " must include generic type (e.g., "
                  + rawParameterType.getSimpleName()
                  + ")");
        }
        ParameterizedType parameterizedType = (ParameterizedType) type;
        Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);
        if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(iterableType))) {
          throw parameterError(
              method,
              p,
              "@Part parameters using the MultipartBody.Part must not "
                  + "include a part name in the annotation.");
        }
        Converter converter =
            retrofit.requestBodyConverter(iterableType, annotations, methodAnnotations);
        return new ParameterHandler.Part<>(method, p, headers, converter).iterable();
      } else if (rawParameterType.isArray()) {
        Class arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());
        if (MultipartBody.Part.class.isAssignableFrom(arrayComponentType)) {
          throw parameterError(
              method,
              p,
              "@Part parameters using the MultipartBody.Part must not "
                  + "include a part name in the annotation.");
        }
        Converter converter =
            retrofit.requestBodyConverter(arrayComponentType, annotations, methodAnnotations);
        return new ParameterHandler.Part<>(method, p, headers, converter).array();
      } else if (MultipartBody.Part.class.isAssignableFrom(rawParameterType)) {
        throw parameterError(
            method,
            p,
            "@Part parameters using the MultipartBody.Part must not "
                + "include a part name in the annotation.");
      } else {
        Converter converter =
            retrofit.requestBodyConverter(type, annotations, methodAnnotations);
        return new ParameterHandler.Part<>(method, p, headers, converter);
      }
    }

  } else if (annotation instanceof PartMap) {
    validateResolvableType(p, type);
    if (!isMultipart) {
      throw parameterError(
          method, p, "@PartMap parameters can only be used with multipart encoding.");
    }
    gotPart = true;
    Class rawParameterType = Utils.getRawType(type);
    if (!Map.class.isAssignableFrom(rawParameterType)) {
      throw parameterError(method, p, "@PartMap parameter type must be Map.");
    }
    Type mapType = Utils.getSupertype(type, rawParameterType, Map.class);
    if (!(mapType instanceof ParameterizedType)) {
      throw parameterError(
          method, p, "Map must include generic types (e.g., Map)");
    }
    ParameterizedType parameterizedType = (ParameterizedType) mapType;

    Type keyType = Utils.getParameterUpperBound(0, parameterizedType);
    if (String.class != keyType) {
      throw parameterError(method, p, "@PartMap keys must be of type String: " + keyType);
    }

    Type valueType = Utils.getParameterUpperBound(1, parameterizedType);
    if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(valueType))) {
      throw parameterError(
          method,
          p,
          "@PartMap values cannot be MultipartBody.Part. "
              + "Use @Part List or a different value type instead.");
    }

    Converter valueConverter =
        retrofit.requestBodyConverter(valueType, annotations, methodAnnotations);

    PartMap partMap = (PartMap) annotation;
    return new ParameterHandler.PartMap<>(method, p, valueConverter, partMap.encoding());

  } else if (annotation instanceof Body) {
    validateResolvableType(p, type);
    if (isFormEncoded || isMultipart) {
      throw parameterError(
          method, p, "@Body parameters cannot be used with form or multi-part encoding.");
    }
    if (gotBody) {
      throw parameterError(method, p, "Multiple @Body method annotations found.");
    }

    Converter converter;
    try {
      converter = retrofit.requestBodyConverter(type, annotations, methodAnnotations);
    } catch (RuntimeException e) {
      // Wide exception range because factories are user code.
      throw parameterError(method, e, p, "Unable to create @Body converter for %s", type);
    }
    gotBody = true;
    return new ParameterHandler.Body<>(method, p, converter);

  } else if (annotation instanceof Tag) {
    validateResolvableType(p, type);

    Class tagType = Utils.getRawType(type);
    for (int i = p - 1; i >= 0; i--) {
      ParameterHandler otherHandler = parameterHandlers[i];
      if (otherHandler instanceof ParameterHandler.Tag
          && ((ParameterHandler.Tag) otherHandler).cls.equals(tagType)) {
        throw parameterError(
            method,
            p,
            "@Tag type "
                + tagType.getName()
                + " is duplicate of parameter #"
                + (i + 1)
                + " and would always overwrite its value.");
      }
    }

    return new ParameterHandler.Tag<>(tagType);
  }

  return null; // Not a Retrofit annotation.
}

注意retrofit.requestBodyConverter是这里使用GsonConverter把bean转化成json的地方，怎么转换就交给GsonConverter了。至于Retrofit是在哪里用上的Converter转换请求参数的我们放在最后，现在还没走完请求流程不好理解。

类似于解析方法注解一样，针对Url、Path、Query、QueryName、QueryMap、Header、HeaderMap、Field、FieldMap、Part、PartMap、Body、Tag这些注解进行解析。

回到ServiceMethod的parseAnnotations方法，接下来会验证返回类型并最终会返回一个ServiceMethod，看一下Utils.hasUnresolvableType(returnType)方法：

static boolean hasUnresolvableType(@Nullable Type type) {
  if (type instanceof Class) {
    return false;
  }
  //ParameterizedType，比如ArrayList
  if (type instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) type;
    //getActualTypeArguments()得到一个包含String的Type数组，递归调用会判断为Class类型
    for (Type typeArgument : parameterizedType.getActualTypeArguments()) {
      if (hasUnresolvableType(typeArgument)) {
        return true;
      }
    }
    return false;
  }
  //GenericArrayType,比如T[]或T[][],
  if (type instanceof GenericArrayType) {
    //getGenericComponentType()会得到T和T[](脱一层数组)
    return hasUnresolvableType(((GenericArrayType) type).getGenericComponentType());
  }
  //TypeVariable，比如T、E这种表示某种类型的
  if (type instanceof TypeVariable) {
    return true;
  }
  //WildcardType，? extends String这种通配符表示的，比如ArrayList这种ParameterType类型的调用parameterizedType.getActualTypeArguments()得到? extends String这种WildcardType类型
  if (type instanceof WildcardType) {
    return true;
  }
  String className = type == null ? "null" : type.getClass().getName();
  throw new IllegalArgumentException(
      "Expected a Class, ParameterizedType, or "
          + "GenericArrayType, but <"
          + type
          + "> is of type "
          + className);
}

返回类型验证没问题了就会通过parseAnnotations创建一个ServiceMethod，看看HttpServiceMethod.parseAnnotations做了什么：

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) {
    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
    }

    adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
    annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
  } else {
    adapterType = method.getGenericReturnType();
  }

  CallAdapter callAdapter =
      createCallAdapter(retrofit, method, adapterType, annotations);
  Type responseType = callAdapter.responseType();
  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.");
  }

  Converter responseConverter =
      createResponseConverter(retrofit, method, responseType);

  okhttp3.Call.Factory callFactory = retrofit.callFactory;
  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);
  }
}

通过createCallAdapter得到callAdapter：

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

public CallAdapter callAdapter(Type returnType, Annotation[] annotations) {
  return nextCallAdapter(null, returnType, annotations);
}

public CallAdapter nextCallAdapter(
    @Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
  Objects.requireNonNull(returnType, "returnType == null");
  Objects.requireNonNull(annotations, "annotations == null");

  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);
    if (adapter != null) {
      return adapter;
    }
  }

  StringBuilder builder =
      new StringBuilder("Could not locate call adapter for ").append(returnType).append(".\n");
  if (skipPast != null) {
    builder.append("  Skipped:");
    for (int i = 0; i < start; i++) {
      builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
    }
    builder.append('\n');
  }
  builder.append("  Tried:");
  for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
    builder.append("\n   * ").append(callAdapterFactories.get(i).getClass().getName());
  }
  throw new IllegalArgumentException(builder.toString());
}

可以看到是从callAdapterFactories里面取的，还记得Retrofit.Builder的build的时候吗:

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

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

如果我们通过addCallAdapterFactory设置过CallAdapter则至少会有一个DefaultCallAdapterFactory，按照没设置的情况，callAdapterFactories.get(i).get(returnType, annotations, this)就会是：

@Override
public @Nullable CallAdapter get(
    Type returnType, Annotation[] annotations, Retrofit retrofit) {
  if (getRawType(returnType) != Call.class) {
    return null;
  }
  //必须是ParameterizedType类型
  if (!(returnType instanceof ParameterizedType)) {
    throw new IllegalArgumentException(
        "Call return type must be parameterized as Call or Call");
  }
  //getParameterUpperBound内部会通过getActualTypeArguments获取泛型类的类型，这里即是List
  final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);

  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) {
      return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
    }
  };
}
 
 
同理，converter也一样会走到：
 
 
public  Converter nextResponseBodyConverter(
    @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
  Objects.requireNonNull(type, "type == null");
  Objects.requireNonNull(annotations, "annotations == null");

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

 
 
先看构造Retrofit时第一个被添加的BuiltInConverters的responseBodyConverter：
 
 
@Override
public @Nullable Converter responseBodyConverter(
    Type type, Annotation[] annotations, Retrofit retrofit) {
  if (type == ResponseBody.class) {
    return Utils.isAnnotationPresent(annotations, Streaming.class)
        ? StreamingResponseBodyConverter.INSTANCE
        : BufferingResponseBodyConverter.INSTANCE;
  }
  if (type == Void.class) {
    return VoidResponseBodyConverter.INSTANCE;
  }
  if (checkForKotlinUnit) {
    try {
      if (type == Unit.class) {
        return UnitResponseBodyConverter.INSTANCE;
      }
    } catch (NoClassDefFoundError ignored) {
      checkForKotlinUnit = false;
    }
  }
  return null;
}

 
 
可见这是泛型类没有明确指定时的容错处理。
 
 
我们这里addConverterFactory时传入了GsonConverterFactory.create()，所以去看看GsonConverterFactory的responseBodyConverter：
 
 
@Override
public Converter responseBodyConverter(
    Type type, Annotation[] annotations, Retrofit retrofit) {
  TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
  return new GsonResponseBodyConverter<>(gson, adapter);
}

 
 
回到HttpServiceMethod的parseAnnotations，最终会返回一个CallAdapted（暂时不考虑kotlin协程的情况）。
 
 
然后就是调用动态代理中调用invoke方法，实际上就是HttpServiceMethod中的invoke方法：
 
 
@Override
final @Nullable ReturnT invoke(Object[] args) {
  Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
  return adapt(call, args);
}

 
 
也就是CallAdapted中的adapt方法：
 
 
 @Override
 protected ReturnT adapt(Call call, Object[] args) {
    return callAdapter.adapt(call);
 }

 
 
所以也就是DefaultCallAdapterFactory的get方法返回的CallAdapter的adapt：
 
 
@Override
public Call adapt(Call call) {
  return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}
 
 
到现在相当于service.groupList(1001)已经执行完了，接下来就是execute()，也就是这个ExecutorCallbackCall的execute方法：
 
 
@Override
public Response execute() throws IOException {
  return delegate.execute();
}

 
 
delegate就是上面的OkHttpCall，它的execute是：
 
 
@Override
public Response execute() throws IOException {
  okhttp3.Call call;

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

    call = getRawCall();
  }

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

  return parseResponse(call.execute());
}

 
 
getRawCall方法最终调用方法是：
 
 
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;
}

 
 
这个callFactory经查找就是我们Retrofit.Builder().client()传入的OkHttpClient对象，所以这里的call.execute()就是OkHttpClient的newCall()的execute，再往下就是OkHttpClient的源码了。
 
 
至此，Retrofit的网络请求API调用过程就结束了。
 
 
那么response是怎么通过Converter解析的呢?还有个parseResponse方法：
 
 
Response parseResponse(okhttp3.Response rawResponse) throws IOException {
  ResponseBody rawBody = rawResponse.body();

  // Remove the body's source (the only stateful object) so we can pass the response along.
  rawResponse =
      rawResponse
          .newBuilder()
          .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
          .build();

  int code = rawResponse.code();
  if (code < 200 || code >= 300) {
    try {
      // Buffer the entire body to avoid future I/O.
      ResponseBody bufferedBody = Utils.buffer(rawBody);
      return Response.error(bufferedBody, rawResponse);
    } finally {
      rawBody.close();
    }
  }

  if (code == 204 || code == 205) {
    rawBody.close();
    return Response.success(null, rawResponse);
  }

  ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
  try {
    T body = responseConverter.convert(catchingBody);
    return Response.success(body, rawResponse);
  } catch (RuntimeException e) {
    // If the underlying source threw an exception, propagate that rather than indicating it was
    // a runtime exception.
    catchingBody.throwIfCaught();
    throw e;
  }
}

 
 
responseConverter.convert(catchingBody)就是答案，responseConverter是前面的responseBodyConverter返回的GsonResponseBodyConverter：
 
 
@Override
public T convert(ResponseBody value) throws IOException {
  JsonReader jsonReader = gson.newJsonReader(value.charStream());
  try {
    T result = adapter.read(jsonReader);
    if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
      throw new JsonIOException("JSON document was not fully consumed.");
    }
    return result;
  } finally {
    value.close();
  }
}

 
 
下面就是Gson框架的部分了。
 
 
前面还有一点没讲就是Retrofit怎么引用这个converter解析request参数（即方法参数）的呢？
 
 
返回的ParameterHandler的子类会被保存到RequestFactory的parameterHandlers中，后面OkHttpCall调用createRawCall的时候有一句callFactory.newCall(requestFactory.create(args))，这个requestFactory.create中有一句handlers[p].apply(requestBuilder, args[p])，handlers就是parameterHandlers，所以这个apply就是ParameterHandler的相关子类中的apply方法，拿ParameterHandler.Body来说：
 
 
@Override
void apply(RequestBuilder builder, @Nullable T value) {
  if (value == null) {
    throw Utils.parameterError(method, p, "Body parameter value must not be null.");
  }
  RequestBody body;
  try {
    body = converter.convert(value);
  } catch (IOException e) {
    throw Utils.parameterError(method, e, p, "Unable to convert " + value + " to RequestBody");
  }
  builder.setBody(body);
}

 
 
converter.convert就调用到了前面设置的GsonRequestBodyConverter。
 
 
     
  
  •  
    总结
     
    通过源码深刻理解了从调用到解析，Retrofit是如何优雅的通过注解和动态代理的方式把OkHttpClient的调用封装起来，从而使得彼此之间地耦合度大大地降低地。
     
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 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】本文作者：鸿蒙内核发烧友，用生活场景讲故事的方式去解构内核，一窥究竟，让神秘的内核栩栩如生，浮现眼前。博文全部原创，持续更新，敬请关注。内容仅代表个人观点，错误之处，欢迎大家指正完善。本系列全部文章进入鸿蒙源码分析(总目录)查看目录最难讲的章节坦白讲内存是整个系列里面最
    
                    
    • 
                                
  • 怎么样才能成为专业的程序员？
                                    cocos2d-x小菜
编程PHP
                                    
      
如何要想成为一名专业的程序员？仅仅会写代码是不够的。从团队合作去解决问题到版本控制，你还得具备其他关键技能的工具包。当我们询问相关的专业开发人员，那些必备的关键技能都是什么的时候，下面是我们了解到的情况。 
  
关于如何学习代码，各种声音很多，然后很多人就被误导为成为专业开发人员懂得一门编程语言就够了？！呵呵，就像其他工作一样，光会一个技能那是远远不够的。如果你想要成为
    
                                
    • 
                                
  • java web开发 高并发处理
                                    BreakingBad
javaWeb并发开发处理高
                                    
    java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据） 一：高并发高负载类网站关注点之数据库 没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。 一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（
    
                                
    • 
                                
  • mysql批量更新
                                    ekian
mysql
                                    
    mysql更新优化： 
一版的更新的话都是采用update set的方式，但是如果需要批量更新的话，只能for循环的执行更新。或者采用executeBatch的方式，执行更新。无论哪种方式，性能都不见得多好。 
三千多条的更新，需要3分多钟。 
查询了批量更新的优化，有说replace into的方式，即： 
 
 
replace into tableName(id,status) values
    
                                
    • 
                                
  • 微软BI（3）
                                    18289753290
微软BI SSIS
                                    
    1) 
Q：该列违反了完整性约束错误；已获得 OLE DB 记录。源:“Microsoft SQL Server Native Client 11.0” Hresult: 0x80004005 说明:“不能将值 NULL 插入列 'FZCHID'，表 'JRB_EnterpriseCredit.dbo.QYFZCH'；列不允许有 Null 值。INSERT 失败。”。 
A：一般这类问题的存在是 
    
                                
    • 
                                
  • Java中的List
                                    g21121
java
                                    
            List是一个有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 
        与 set 不同，列表通常允许重复
    
                                
    • 
                                
  • 读书笔记
                                    永夜-极光
读书笔记
                                    
       1.  K是一家加工厂,需要采购原材料,有A,B,C,D 4家供应商,其中A给出的价格最低,性价比最高,那么假如你是这家企业的采购经理,你会如何决策? 
    
     传统决策: A:100%订单  B,C,D:0% 
  
  &nbs
    
                                
    • 
                                
  • centos 安装 Codeblocks
                                    随便小屋
codeblocks
                                    
    1.安装gcc,需要c和c++两部分,默认安装下,CentOS不安装编译器的,在终端输入以下命令即可yum install gccyum install gcc-c++ 
  
2.安装gtk2-devel,因为默认已经安装了正式产品需要的支持库,但是没有安装开发所需要的文档.yum install gtk2* 
3. 安装wxGTK 
   yum search w
    
                                
    • 
                                
  • 23种设计模式的形象比喻
                                    aijuans
设计模式
                                    
    1、ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory  　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：
    
                                
    • 
                                
  • 开发管理 CheckLists
                                    aoyouzi
开发管理 CheckLists
                                    
    开发管理 CheckLists(23) -使项目组度过完整的生命周期 
开发管理 CheckLists(22) -组织项目资源 
开发管理 CheckLists(21) -控制项目的范围开发管理 CheckLists(20) -项目利益相关者责任开发管理 CheckLists(19) -选择合适的团队成员开发管理 CheckLists(18) -敏捷开发 Scrum Master 工作开发管理 C
    
                                
    • 
                                
  • js实现切换
                                    百合不是茶
JavaScript栏目切换
                                    
    js主要功能之一就是实现页面的特效,窗体的切换可以减少页面的大小,被门户网站大量应用思路: 
   1,先将要显示的设置为display:bisible  否则设为none
    2,设置栏目的id  ,js获取栏目的id,如果id为Null就设置为显示
    3,判断js获取的id名字;再设置是否显示
 
  
代码实现: 
  
html代码: 
  <di
    
                                
    • 
                                
  • 周鸿祎在360新员工入职培训上的讲话
                                    bijian1013
感悟项目管理人生职场
                                    
            这篇文章也是最近偶尔看到的，考虑到原博客发布者可能将其删除等原因，也更方便个人查找，特将原文拷贝再发布的。“学东西是为自己的，不要整天以混的姿态来跟公司博弈，就算是混，我觉得你要是能在混的时间里，收获一些别的有利于人生发展的东西，也是不错的，看你怎么把握了”，看了之后，对这句话记忆犹新。  &
    
                                
    • 
                                
  • 前端Web开发的页面效果
                                    Bill_chen
htmlWebMicrosoft
                                    
    1.IE6下png图片的透明显示： 
<img src="图片地址" border="0" style="Filter.Alpha(Opacity)=数值(100),style=数值(3)"/> 
或在<head></head>间加一段JS代码让透明png图片正常显示。 
 
2.<li>标
    
                                
    • 
                                
  • 【JVM五】老年代垃圾回收：并发标记清理GC(CMS GC)
                                    bit1129
垃圾回收
                                    
      CMS概述 
并发标记清理垃圾回收(Concurrent Mark and Sweep GC）算法的主要目标是在GC过程中，减少暂停用户线程的次数以及在不得不暂停用户线程的请夸功能，尽可能短的暂停用户线程的时间。这对于交互式应用，比如web应用来说，是非常重要的。 
  
CMS垃圾回收针对新生代和老年代采用不同的策略。相比同吞吐量垃圾回收，它要复杂的多。吞吐量垃圾回收在执
    
                                
    • 
                                
  • Struts2技术总结
                                    白糖_
struts2
                                    
      
 
 必备jar文件 
   
 早在struts2.0.*的时候，struts2的必备jar包需要如下几个： 
commons-logging-*.jar   Apache旗下commons项目的log日志包 
freemarker-*.jar          
    
                                
    • 
                                
  • Jquery easyui layout应用注意事项
                                    bozch
jquery浏览器easyuilayout
                                    
    在jquery easyui中提供了easyui-layout布局，他的布局比较局限，类似java中GUI的border布局。下面对其使用注意事项作简要介绍： 
     如果在现有的工程中前台界面均应用了jquery easyui，那么在布局的时候最好应用jquery eaysui的layout布局，否则在表单页面（编辑、查看、添加等等）在不同的浏览器会出
    
                                
    • 
                                
  • java-拷贝特殊链表：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？
                                    bylijinnan
java
                                    
    
public class CopySpecialLinkedList {

	/**
	 * 题目：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？
拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。
假设原来链表为A1 -> A2 ->... -> An，新拷贝
    
                                
    • 
                                
  • color
                                    Chen.H
JavaScripthtmlcss
                                    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  "http://www.w3.org/TR/html4/loose.dtd">    <HTML>    <HEAD>&nbs
    
                                
    • 
                                
  • [信息与战争]移动通讯与网络
                                    comsci
网络
                                    
          两个坚持:手机的电池必须可以取下来 
               光纤不能够入户,只能够到楼宇 
 
      建议大家找这本书看看:<&
    
                                
    • 
                                
  • oracle flashback query(闪回查询)
                                    daizj
oracleflashback queryflashback table
                                    
    在Oracle 10g中，Flash back家族分为以下成员： 
Flashback Database 
Flashback Drop 
Flashback Table 
Flashback Query(分Flashback Query,Flashback Version Query，Flashback Transaction Query) 
下面介绍一下Flashback Drop 和Flas
    
                                
    • 
                                
  • zeus持久层DAO单元测试
                                    deng520159
单元测试
                                    
    zeus代码测试正紧张进行中,但由于工作比较忙,但速度比较慢.现在已经完成读写分离单元测试了,现在把几种情况单元测试的例子发出来,希望有人能进出意见,让它走下去. 
本文是zeus的dao单元测试: 
1.单元测试直接上代码 
  
package com.dengliang.zeus.webdemo.test;


import org.junit.Test;
import o
    
                                
    • 
                                
  • C语言学习三printf函数和scanf函数学习
                                    dcj3sjt126com
cprintfscanflanguage
                                    
    printf函数 
/*
	2013年3月10日20:42:32
	地点：北京潘家园
	功能：
	目的：
		测试%x %X %#x %#X的用法
 */

# include <stdio.h>

int main(void)
{

	printf("哈哈！\n");  // \n表示换行

	int i = 10;
	printf
    
                                
    • 
                                
  • 那你为什么小时候不好好读书?
                                    dcj3sjt126com
life
                                    
    dady, 我今天捡到了十块钱, 不过我还给那个人了 
good girl! 那个人有没有和你讲thank you啊 
没有啦....他拉我的耳朵我才把钱还给他的, 他哪里会和我讲thank you 
  
爸爸, 如果地上有一张5块一张10块你拿哪一张呢.... 
当然是拿十块的咯... 
爸爸你很笨的, 你不会两张都拿 
  
爸爸为什么上个月那个人来跟你讨钱, 你告诉他没
    
                                
    • 
                                
  • iptables开放端口
                                    Fanyucai
linuxiptables端口
                                    
    1，找到配置文件 
vi /etc/sysconfig/iptables   
  
2，添加端口开放，增加一行，开放18081端口 
-A INPUT -m state --state NEW -m tcp -p tcp --dport 18081 -j ACCEPT 
  
3，保存 
ESC
:wq! 
  
4，重启服务 
service iptables 
    
                                
    • 
                                
  • Ehcache（05）——缓存的查询
                                    234390216
排序ehcache统计query
                                    
    缓存的查询 
目录 
1.    使Cache可查询 
1.1     基于Xml配置 
1.2     基于代码的配置 
2     指定可搜索的属性 
2.1     可查询属性类型 
2.2 &
    
                                
    • 
                                
  • 通过hashset找到数组中重复的元素
                                    jackyrong
hashset
                                    
      如何在hashset中快速找到重复的元素呢?方法很多，下面是其中一个办法： 
 
 


 int[] array = {1,1,2,3,4,5,6,7,8,8};
         
        Set<Integer> set = new HashSet<Integer>();
         
        for(int i = 0
    
                                
    • 
                                
  • 使用ajax和window.history.pushState无刷新改变页面内容和地址栏URL
                                    lanrikey
history
                                    
    后退时关闭当前页面 
<script type="text/javascript"> 
 jQuery(document).ready(function ($) { 
        if (window.history && window.history.pushState) {
    
                                
    • 
                                
  • 应用程序的通信成本
                                    netkiller.github.com
虚拟机应用服务器陈景峰netkillerneo
                                    
    应用程序的通信成本  
什么是通信 
一个程序中两个以上功能相互传递信号或数据叫做通信。  
什么是成本 
这是是指时间成本与空间成本。 时间就是传递数据所花费的时间。空间是指传递过程耗费容量大小。  
都有哪些通信方式 
 
 全局变量 
 线程间通信 
 共享内存 
 共享文件 
 管道 
 Socket 
 硬件（串口，USB） 等等 
  
全局变量 
全局变量是成本最低通信方法，通过设置
    
                                
    • 
                                
  • 一维数组与二维数组的声明与定义
                                    恋洁e生
二维数组一维数组定义声明初始化
                                    
    /**  *   */ package test20111005; /**  * @author FlyingFire  * @date:2011-11-18 上午04:33:36  * @author ：代码整理  * @introduce :一维数组与二维数组的初始化  *summary：  */ public c
    
                                
    • 
                                
  • Spring Mybatis独立事务配置
                                    toknowme
mybatis
                                    
    在项目中有很多地方会使用到独立事务，下面以获取主键为例      
（1）修改配置文件spring-mybatis.xml    <!-- 开启事务支持 -->    <tx:annotation-driven transaction-manager="transactionManager" />       &n
    
                                
    • 
                                
  • 更新Anadroid SDK Tooks之后，Eclipse提示No update were found
                                    xp9802
eclipse
                                    
    使用Android SDK Manager 更新了Anadroid SDK Tooks 之后， 
打开eclipse提示 This Android SDK requires Android Developer Toolkit version 23.0.0 or above, 点击Check for Updates  
检测一会后提示 No update were found  
    
                                
    •