On丶
On丶

Retrofit源码解析

  • Retrofit在代码中的构建方式
Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http:/xx/xx/xx/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
service = retrofit.create(APIService.class);
service.getCall();
  • 根据构建方式，我们先来看一下Retrofit类源码

（1）Retrofit中的七个重要的成员变量

//Method是Http的请求方法，ServiceMethod是网络请求接口解析注解后的请求方法的对象
  private final Map> serviceMethodCache = new ConcurrentHashMap<>();
//网络请求的工厂
  final okhttp3.Call.Factory callFactory;
//网路请求的基地址，与接口中配置的地址拼接起来就是完整的请求地址
  final HttpUrl baseUrl;
//数据转换器工厂的集合，工厂的作用用于生产数据转换器，比如converter-gson
  final List converterFactories;
//网络请求适配器的工厂集合，比如Call转换成RxJava平台的Call
  final List adapterFactories;
//用于执行回调，处理异步请求。在Android平台默认使用的是MainThreadExcecutor主线程执行器
  final @Nullable Executor callbackExecutor;
//布尔类型，是否需要立即解析接口中的方法，解析java接口中注解的请求方法和参数用到的
  final boolean validateEagerly;
//构造方法
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List converterFactories, List adapterFactories,
      @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
    this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
  }

（2）Retrofit中静态内部类Builder

public static final class Builder {
    //基本上和Retrofit中成员变量一致
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List converterFactories = new ArrayList<>();
    private final List adapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
      // 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());
    }

    public Builder() {
      this(Platform.get());
    }

    Builder(Retrofit retrofit) {
      platform = Platform.get();
      callFactory = retrofit.callFactory;
      baseUrl = retrofit.baseUrl;
      converterFactories.addAll(retrofit.converterFactories);
      adapterFactories.addAll(retrofit.adapterFactories);
      // Remove the default, platform-aware call adapter added by build().
      adapterFactories.remove(adapterFactories.size() - 1);
      callbackExecutor = retrofit.callbackExecutor;
      validateEagerly = retrofit.validateEagerly;
    }

  （省略部分代码）
    ........
    ........

    /**
     * Create the {@link Retrofit} instance using the configured values.
     * 

     * Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link
     * OkHttpClient} will be created and used.
     */
    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 adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List converterFactories = new ArrayList<>(this.converterFactories);

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

成功建立一个Retrofit对象的标准：配置好Retrofit类里的成员变量，即配置好：
serviceMethod：包含所有网络请求信息的对象
baseUrl：网络请求的url地址
callFactory：网络请求工厂
adapterFactories：网络请求适配器工厂的集合
converterFactories：数据转换器工厂的集合
callbackExecutor：回调方法执行器

在Retrofit内部类Builder默认的构造方法中，我们可以看到调用了带参数的构造方法this(Platform.get())，那么Platform是做什么的呢

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

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

  @Nullable Executor defaultCallbackExecutor() {
    return null;
  }

  CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    if (callbackExecutor != null) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    return DefaultCallAdapterFactory.INSTANCE;
  }

  boolean isDefaultMethod(Method method) {
    return false;
  }

  @Nullable Object invokeDefaultMethod(Method method, Class declaringClass, Object object,
      @Nullable Object... args) throws Throwable {
    throw new UnsupportedOperationException();
  }

  @IgnoreJRERequirement // Only classloaded and used on Java 8.
  static class Java8 extends Platform {
    @Override boolean isDefaultMethod(Method method) {
      return method.isDefault();
    }

    @Override Object invokeDefaultMethod(Method method, Class declaringClass, Object object,
        @Nullable Object... args) throws Throwable {
      // Because the service interface might not be public, we need to use a MethodHandle lookup
      // that ignores the visibility of the declaringClass.
      Constructor constructor = Lookup.class.getDeclaredConstructor(Class.class, int.class);
      constructor.setAccessible(true);
      return constructor.newInstance(declaringClass, -1 /* trusted */)
          .unreflectSpecial(method, declaringClass)
          .bindTo(object)
          .invokeWithArguments(args);
    }
  }

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

    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

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

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }
}
  • 其中findPlatform()方法中Class.forName("android.os.Build")

Class.forName(xxx.xx.xx)返回的是一个类。
Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段。
关于生成对象两种方式的区别可以看这里初始化一个类，生成一个实例的时候，newInstance()方法和new关键字

  • Android回调中的线程切换

我们主要是看android，所以重点看其中静态内部类Android，该类中有一个defaultCallbackExecutor()的方法，返回的是Android中一个静态内部类MainThreadExecutor 的实例，我们可以看到在这里做了线程切换，采用Looper.getMainLooper()（主线程的looper）构造了handler，post了Runnable。

（3）baseUrl说明

public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      if (httpUrl == null) {
        throw new IllegalArgumentException("Illegal URL: " + baseUrl);
      }
      return baseUrl(httpUrl);
    }

 public Builder baseUrl(HttpUrl baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      List pathSegments = baseUrl.pathSegments();
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
    }

关于Retrofit中的baseUrl并没有强制怎么写，我可以写成https://api.github.com也可以写成 https://api.github.com/repos/,区别在哪呢?

https://api.github.com的格式可以看成scheme://host[:port]（此种类型是不是以 /（斜线） 结尾都可以，均不会抛出IllegalArgumentException异常）;
https://api.github.com/repos/的格式可以看成scheme://host[:port]/path（此种类型必须以/（斜线） 结尾，否则会抛出IllegalArgumentException异常）.

还是建议baseUrl统一以“/”结尾

（4）GsonConverter/GsonConverterFactory

addConverterFactory(Converter.Factory factory)就是将数据转换器工厂添加到Retrofit的数据转换器的集合中
GsonConverterFactory.create(Gson gson)/GsonConverterFactory.create()，创建了一个持有gson实例的Gson数据转换器工厂，前者可以自己定义gson实例的一些特性，后者是采用了默认的gson实例。

（5）CallAdapter/CallAdapterFactory

addCallAdapterFactory(CallAdapter.Factory factory)同样就是将网络请求适配器工厂添加到Retrofit的网络请求适配器的集合中

RxJava2CallAdapterFactory代码很短，以下是部分代码，其中Scheduler 是RxJava中的调度器，后面会介绍，通过create我们创建了一个RxJava2CallAdapterFactory，然后将其加到Retrofit的网络请求适配器的集合中

/**
   * Returns an instance which creates synchronous observables that do not operate on any scheduler
   * by default.
   */
  public static RxJava2CallAdapterFactory create() {
    return new RxJava2CallAdapterFactory(null, false);
  }

  private final @Nullable Scheduler scheduler;
  private final boolean isAsync;

  private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
    this.scheduler = scheduler;
    this.isAsync = isAsync;
  }
  • 下面我们具体看一下RxJava2CallAdapterFactory
    RxJava2CallAdapterFactory继承自CallAdapter.Factory，Factory是接口CallAdapter的一个内部类，CallAdapter负责将Retroift中的Call转换成java对象，
@POST("heart.do")
Call  addFriendShip(@Body HashMap addInfo);
@POST("heart.do")
Observable addFriendShip(@Body HashMap addInfo);

public interface CallAdapter {
  
  Type responseType();

  T adapt(Call call);

  abstract class Factory {
   
    public abstract @Nullable CallAdapter get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);

    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }

    protected static Class getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

（1） Type responseType()，此处的Type就是Http请求返回的Response解析后的类型，并不是接口的返回类型，而是接口返回类型中泛型参数的实参，比如上述代码中ABaseBean。
（2）T adapt(Call call)，T对应相应平台的对象，比如RxJava2CallAdapter中T对应Observable。
（3）get方法根据接口类型、注解类型获取需要的CallAdapter
（4）getRawType获取原始类型，在RxJava2CallAdapter中根据这个类型来选择生成不同的CallAdapter

RxJava2CallAdapter中的adapt方法中，会将Retrofit.create()方法过程中生成的携带了ServiceMethod对象的OkHttpCall进行适配，后面会讲到：

public Object adapt(Call call) {
    Observable> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }

上述判断条件分别是根据getRawType中获取到的类型生成的布尔值

（6）retrofit.create(xxx.class)，创建网络请求接口实例，create使用了外观模式和动态代理模式

Retrofit中的create方法：

public  T create(final Class service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },
        new InvocationHandler() {
          private final Platform platform = Platform.get();

          @Override public 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);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }




validateEagerly，这是上面提到过的Retrofit的七个重要的成员变量之一，是否提前验证解析接口，如果为true，调用eagerlyValidateMethods方法，这部分调用的说明写在下方代码注释中




private void eagerlyValidateMethods(Class service) {
    Platform platform = Platform.get();//获取平台，之前提到过Android、Java等
    for (Method method : service.getDeclaredMethods()) {//利用反射获取到网络请求接口中定义的method集合，遍历各个method
      if (!platform.isDefaultMethod(method)) {//此方法点进去可以看到默认返回false，则这里条件默认为true
        loadServiceMethod(method);
      }
    }
  }

/**
*该方法采用了常规的保存到缓存以及从缓存中获取目标对象的方式
*获取的ServiceMethod是对应接口中网络请求的一个方法的封装，其中包含了url以及配置参数等等
*/
  ServiceMethod loadServiceMethod(Method method) {
  //serviceMethodCache，这是上面提到过的Retrofit的七个重要的成员变量之一，缓存生成的http请求接口方法的
    ServiceMethod result = serviceMethodCache.get(method);
    if (result != null) return result;//如果从缓存中获取到，则直接返回

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {//如果没有获取到，则创建并缓存到serviceMethodCache
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;//返回目标对象ServiceMethod
  }



接下来，我们回到Retrofit的create方法中，非常重要的来了，动态代理动态创建网路请求，我们选其中重要的代码来看：


ServiceMethod serviceMethod = (ServiceMethod) loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);


loadServiceMethod上面已经说过了，我们先来看看ServiceMethod这个类


ServiceMethod的成员变量：


  //生产网络请求call的工厂
  final okhttp3.Call.Factory callFactory;
  //网络请求适配器，使网络请求适配不同平台,比如RxJava平台
  final CallAdapter callAdapter;
   //网络请求基地址
  private final HttpUrl baseUrl;
  //数据转换器
  private final Converter responseConverter;
  //网络请求的方法，比如GET、POST等等
  private final String httpMethod;
  //网络请求的相对地址，与上面baseUrl拼接成完整的请求地址
  private final String relativeUrl;
  //网络请求的头部信息
  private final Headers headers;
 //网络请求的http报文的body类型
  private final MediaType contentType;
  private final boolean hasBody;
  private final boolean isFormEncoded;
  private final boolean isMultipart;
//非常重要的：网络请求接口中参数、方法的处理器，包括注解啊、参数啊等等
  private final ParameterHandler[] parameterHandlers;



从loadServiceMethod方法中我们看到生成ServiceMethod时使用的也是构建者模式，看一下ServiceMethod的内部类Builder


Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();//网络请求接口中的请求方法以及header等注解，比如POST/GET/Multipart/FormUrlEncoded/Headers
      this.parameterTypes = method.getGenericParameterTypes();//网路请求接口方法中参数的类型
      this.parameterAnnotationsArray = method.getParameterAnnotations();//网路请求接口方法中注解的内容
    }

public ServiceMethod build() {
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();//获取该网络请求适配器的数据返回类型

      ...省略部分代码

      responseConverter = createResponseConverter();
      //遍历网络请求接口中方法的网络请求方式（就是接口名称上边那些）的注解
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);//其中通过if判断是否是哪种网络请求方式做相应解析
      }

     ...省略部分代码

      /**
      * 解析网络请求接口方法中的参数（注解和参数）
      */
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];

        ...省略部分代码

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

       ...省略部分代码

        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

     ...省略部分代码

      return new ServiceMethod<>(this);
    }






生成ServiceMethod，主要是解析了网络请求接口中的注解和参数等，生成了相应的网络请求适配器和数据转换器。




build中生成了ServiceMethod实例，我们分别来看看build方法中的关键步骤


    

  • 

      

    1. 生成网络请求的适配器 callAdapter = createCallAdapter();
      2. 

    • 



private CallAdapter createCallAdapter() {
      Type returnType = method.getGenericReturnType();
      ...省略部分代码
      Annotation[] annotations = method.getAnnotations();
      try {
        return (CallAdapter) retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }





最终调用了ServiceMethod创建时传进来的Retrofit对象的callAdapter(Type returnType, Annotation[] annotations)方法




在retrofit中方法如下：


  public CallAdapter callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }
  public CallAdapter nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    ...省略部分代码
    int start = adapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      CallAdapter adapter = adapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
    ...省略部分代码
  }





这里根据获取到的type和annotations从工厂类中生成相应的网络请求适配器，没有得到会抛出异常




    

  • 

      

    1. 生成数据转换器 responseConverter = createResponseConverter();
      2. 

    • 



private Converter createResponseConverter() {
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }





同样，生成数据转换器也调用了ServiceMethod创建时传进来的Retrofit对象的方法，responseBodyConverter(Type type, Annotation[] annotations)




Retrofit中方法如下（和生成网络请求适配器非常类似）：


  public  Converter responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
  }

  public  Converter nextResponseBodyConverter(
      @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
    ...省略部分代码
    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;
      }
    }
    ...省略部分代码
  }





converterFactories.get(i)获取到相应的数据转换器工厂，调用数据转换器工厂中相应的responseBodyConverter方法，比如常用的GsonConverterFactory




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



    

  • 3 之后build中还对网络请求接口中方法的注解和参数进行了解析，这部分都是在ServiceMethod类中的方法完成的，不再单独介绍，上述build方法代码中有简单的注释。
    • 



到这部分，Retrofit.create()方法中的三行核心代码中的第一行，ServiceMethod serviceMethod = (ServiceMethod) loadServiceMethod(method)，生成ServiceMethod的实现基本分析完毕。
 那么接下来继续看第二行OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args)


final class OkHttpCall implements Call {
  private final ServiceMethod serviceMethod;//上面讲过的非常重要的一个对象
  private final @Nullable Object[] args;//参数
  private volatile boolean canceled;
  private @Nullable okhttp3.Call rawCall;//原生call，所有的操作最后实际上还是通过它来完成
  private @Nullable Throwable creationFailure; // Either a RuntimeException or IOException.
  private boolean executed;

   OkHttpCall(ServiceMethod serviceMethod, @Nullable Object[] args) {
    this.serviceMethod = serviceMethod;
    this.args = args;
  }
  ...省略了部分代码
}





OkHttpCall就是对OkHttp原生Call的封装，包含了各种Call的方法，比如enqueue、execute、cancel、isCanceled，总之需要用到OkHttp的Call中方法的来这里就对了。




第二行代码简单分析之后，然后就是第三行代码了：return serviceMethod.callAdapter.adapt(okHttpCall)
 这里就是调用了adapt方法，比如加入使用了RxJava2CallAdapter，那callAdapter就对应RxJava2CallAdapter，如下：


public Object adapt(Call call) {
    Observable> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }



（7）retrofit.create完成之后，具体去请求接口时：service.getCall()，因为service是一个接口，那接口去调用方法肯定是不行的，这里实际上是通过Retrofit中的create方法中动态代理进行了拦截，用InvocationHandler中的invoke方法进行实际操作，最后会返回一个OkHttpCall的适配器对象。


（8）Retrofit的同步和异步请求：


    

  • Retrofit同步请求流程：
    • 





ParameterHandler——>ServiceMethod——>Okhttp发送网络请求——>数据转换器converter




同步请求依然得依靠OkHttpCall中封装的请求方法来执行：


public Response execute() throws IOException {
    okhttp3.Call call;
    ...省略部分代码
      call = rawCall;
      if (call == null) {
        try {
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException e) {
          creationFailure = e;
          throw e;
        }
      }
    }
    if (canceled) {//如果返回true，需要取消请求
      call.cancel();
    }
    return parseResponse(call.execute());
  }

  private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }





上述代码我们发现会有一个生成原生call的过程，可以看到先调用了ServiceMethod的toRequest生成一个request对象，然后去执行request返回得到call，得到call的过程实际上是用OkHttp库生成的。




ServiceMethod中的相关方法，根据传入的各个请求参数对应ParameterHandler进行解析：


Request toRequest(@Nullable Object... args) throws IOException {
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
        contentType, hasBody, isFormEncoded, isMultipart);

    ParameterHandler[] handlers = (ParameterHandler[]) parameterHandlers;

    int argumentCount = args != null ? args.length : 0;
    ...省略部分代码
    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

    return requestBuilder.build();
  }


在execute方法中，最终用了原生的call去执行，执行的结果又调用了parseResponse(okhttp3.Response rawResponse)方法来解析


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

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      T body = serviceMethod.toResponse(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;
    }
  }





可以看到获取网络请求的状态码等等，我们关注解析的核心过程serviceMethod.toResponse(catchingBody)，又是调用了ServiceMethod中的方法




R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }





这里使用了数据转换器的convert方法，会使用我们的数据转换器，比如GsonRequestBodyConverter




final class GsonRequestBodyConverter implements Converter {
  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
  private static final Charset UTF_8 = Charset.forName("UTF-8");

  private final Gson gson;
  private final TypeAdapter adapter;

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

  @Override public RequestBody convert(T value) throws IOException {
    Buffer buffer = new Buffer();
    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
    JsonWriter jsonWriter = gson.newJsonWriter(writer);
    adapter.write(jsonWriter, value);
    jsonWriter.close();
    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
  }
}



    

  • Retrofit异步请求：
    • 



public void enqueue(final Callback callback) {
    checkNotNull(callback, "callback == null");

    okhttp3.Call call;
    Throwable failure;

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

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          failure = creationFailure = t;
        }
      }
    }

    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

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

    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callSuccess(Response response) {
        try {
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }



异步请求会将执行结果交给一个回调执行器去处理请求结果。其中一些关键性的代码同步时已经说过，不再说了。




【END】到这里，整个的网络请求就完成了，相应的源码也就分析完成了，Retrofit使用了的设计模式有构建者模式（Retrofit、ServiceMethod）、动态代理模式（实际调用请求方法时）、工厂模式（CallAdapter）、静态工厂模式（Platform）、外观模式/门面模式（Retrofit内部封装了很多子系统ServiceMethod、Factory等）、策略模式（CallAdapter是抽象层、具体的CallAdapter比如RxJava2CallAdapter）、适配器模式（CallAdapter）、观察者模式（OkHttpCall和Callback）
 外观模式/门面模式说明：比如android studio点击执行按钮去执行程序，内部实际上是执行了很多复杂的子系统之间的操作，开发者只需要通过android studio提供的按钮来操作就可以了，屏蔽了子系统之间的变化，高内聚低耦合。
 策略模式：比如要完成一项任务，有很多方法，可以根据不同的情况使用不同的方法来完成。
 工厂模式（强调生成不同的对象）和策略模式（adapt产生具体的实现，强调的是不同对象的方法不同的实现）
 观察者模式：一个被观察者可以对应多个观察者，多个观察者之间没有相互联系
























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






    

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • Istio pilot-discovery服务发现源码解析（1.13版本）
xidianjiapei001
#Istioistio云原生服务发现

    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • VITS 源码解析2-模型概述
迪三
#NN_Audio音频人工智能

    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    

    • 

  • RBtree
努力的小带土
侯捷老师STLc++蓝桥杯

    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    

    • 

  • 深入理解Kubernetes：kube-scheduler源码解析
mujingluo
kubernetes容器云原生

    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    

    • 

  • 【Vesta发号器源码】PropertyMachineIdsProvider
DeanChangDM

    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    

    • 

  • StarRocks分布式元数据源码解析
不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据

    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    

    • 

  • 【Starrocks】建表篇Fe源码解析
数算七弦
Starrocks大数据

    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    

    • 

  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    

    • 

  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    

    • 

  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    

    • 

  • android10 按键音量调节源码解析
@OuYang
android

    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    

    • 

  • android10 Settings源码解析
@OuYang
android

    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    

    • 

  • MyBatis 源码解析：XMLScriptBuilder 工作机制
捕风捉你
MyBatis源码解读mybatisjava

    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    

    • 

  • 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.
    

    • 

  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？
openwin_top
C#视觉应用开发问题系列c#图像处理开发语言

    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
    

    • 

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

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

    • 

  • Android从零开始搭建MVVM架构（6）
m0_66070459
程序员面试移动开发android

    //加载项目build.gradle的anroid标签下dataBinding{enabled=true}添加相关依赖//okhttp、retrofit、rxjavaimplementation‘com.squareup.okhttp3:okhttp:3.8.0’implementation‘com.squareup.retrofit2:retrofit:2.3.0’implementation‘
    

    • 

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

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

    • 

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

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

    • 

  • okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
okhttpretrofitrxjava

    目录OkHttp作用基本使用Retrofit作用基本使用RxJava作用优势基本使用三者的配合工作OkHttp、Retrofit和RxJava是Android开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。OkHttp作用OkHttp是一个高效的HTTP客户端，用于发起网络请求和处理响应。它支持同步和异步请求、连接池、缓存、重定向、超时设置等功能。基本使
    

    • 

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

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

    • 

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

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

    • 

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

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

    • 

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

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

    • 

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

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

    • 

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

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

    • 

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

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

    • 

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

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

    • 

  • 二分查找排序算法
周凡杨
java二分查找排序算法折半

     一：概念 二分查找又称
折半查找（
折半搜索/
二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
    

    • 

  • java中的BigDecimal
bijian1013
javaBigDecimal

            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。
        原文地址：http://blog.csdn.net/ugg/article/de
    

    • 

  • Shell echo命令详解
daizj
echoshell

    Shell echo命令
Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式：
echo string
您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串:
echo "It is a test"
这里的双引号完全可以省略，以下命令与上面实例效果一致：
echo Itis a test 2.显示转义
    

    • 

  • Oracle DBA 简单操作
周凡杨
oracle dba sql

     --执行次数多的SQL
select sql_text,executions from (
     select sql_text,executions from v$sqlarea order by executions desc
     ) where rownum<81;
 &nb
    

    • 

  • 画图重绘
朱辉辉33
游戏

      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。
  在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
    

    • 

  • 线程之初体验
西蜀石兰
线程

    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。
之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。
线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。
你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
    

    • 

  • linux集群互相免登陆配置
林鹤霄
linux

    配置ssh免登陆
1、生成秘钥和公钥    ssh-keygen -t rsa
2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub
   其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
    

    • 

  • mysql : Lock wait timeout exceeded; try restarting transaction
aigo
mysql

    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html
 
原因是你使用的InnoDB   表类型的时候,
默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s,
因为有的锁等待超过了这个时间,所以抱错.
 
你可以把这个时间加长,或者优化存储
    

    • 

  • Socket编程 基本的聊天实现。
alleni123
socket

    public class Server
{
//用来存储所有连接上来的客户
private List<ServerThread> clients;
public static void main(String[] args)
{
Server s = new Server();
s.startServer(9988);
}
publi
    

    • 

  • 多线程监听器事件模式(一个简单的例子)
百合不是茶
线程监听模式

       
多线程的事件监听器模式
  监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到
 
     创建多线程的事件监听器模式 思路:
   1, 创建线程并启动,在创建线程的位置设置一个标记
    2,创建队
    

    • 

  • spring InitializingBean接口
bijian1013
javaspring

    spring的事务的TransactionTemplate，其源码如下：
public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{
...
}
TransactionTemplate继承了DefaultT
    

    • 

  • Oracle中询表的权限被授予给了哪些用户
bijian1013
oracle数据库权限

            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。
select t.table_name as "表名",
t.grantee as "被授权的属组",
t.owner as "对象所在的属组"
    

    • 

  • 【Struts2五】Struts2 参数传值
bit1129
struts2

    Struts2中参数传值的3种情况
1.请求参数绑定到Action的实例字段上
2.Action将值传递到转发的视图上
3.Action将值传递到重定向的视图上
  一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上
Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
    

    • 

  • 【Kafka十四】关于auto.offset.reset[Q/A]
bit1129
kafka

    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or 
    

    • 

  • nginx gzip压缩配置
ronin47
nginx gzip 压缩范例

    nginx gzip压缩配置 更多
0
nginx
gzip
配置  
随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？
gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
    

    • 

  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点
bylijinnan
java

    two cursors.
Make the first cursor go K steps first.
/*
* 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点
*/
public void displayKthItemsBackWard(ListNode head,int k){
ListNode p1=head,p2=head;

    

    • 

  • Spring源码学习-JdbcTemplate queryForObject
bylijinnan
javaspring

    JdbcTemplate中有两个可能会混淆的queryForObject方法：
1.
Object queryForObject(String sql, Object[] args, Class requiredType)
2.
Object queryForObject(String sql, Object[] args, RowMapper rowMapper)
第1个方法是只查
    

    • 

  • [冰川时代]在冰川时代,我们需要什么样的技术?
comsci
技术

    
     看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?
     那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...
  &nb
    

    • 

  • js 获取浏览器型号
cuityang
js浏览器

    根据浏览器获取iphone和apk的下载地址
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" content="text/html"/>
    <meta name=
    

    • 

  • C# socks5详解 转
dalan_123
socketC#

    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
    

    • 

  • 运维 Centos问题汇总
dcj3sjt126com
云主机

    一、sh 脚本不执行的原因
sh脚本不执行的原因 只有2个
1.权限不够
2.sh脚本里路径没写完整。
 
二、解决You have new mail in /var/spool/mail/root
修改/usr/share/logwatch/default.conf/logwatch.conf配置文件
MailTo =
MailFrom
 
三、查询连接数
    

    • 

  • Yii防注入攻击笔记
dcj3sjt126com
sqlWEB安全yii

    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表：
http://blog.csdn.net/xinzhu1990/articl
    

    • 

  • MongoDB简介[一]
eksliang
mongodbMongoDB简介

    MongoDB简介
转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用
       MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。
       另外，不
    

    • 

  • zookeeper windows 入门安装和测试
greemranqq
zookeeper安装分布式

    一、序言
      以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。
      栗子1号：
      假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
    

    • 

  • Spring之使用事务缘由(2-注解实现)
ihuning
spring

     
Spring事务注解实现
 
1. 依赖包：
    1.1 spring包：
          spring-beans-4.0.0.RELEASE.jar
          spring-context-4.0.0.
    

    • 

  • iOS App Launch Option
啸笑天
option

    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。
 
launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。
1、若用户直接
    

    • 

  • jdk与jre的区别（_）
macroli
javajvmjdk

    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。 
JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
    

    • 

  • Updates were rejected because the tip of your current branch is behind
qiaolevip
学习永无止境每天进步一点点众观千象git

    $ git push joe prod-2295-1
To [email protected]:joe.le/dr-frontend.git
! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward)
error: failed to push some refs to '[email protected]
    

    • 

  • [一起学Hive]之十四-Hive的元数据表结构详解
superlxw1234
hivehive元数据结构

    关键字：Hive元数据、Hive元数据表结构
 
之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。
本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。
 
文章最后面，会以一个示例来全面了解一下，
    

    • 

  • Spring 3.2.14，4.1.7，4.2.RC2发布
wiselyman
Spring 3

     
Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。
 
其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。
 
其中Spring 4.1.7主要包含这些更新内容。 
    

    •