怡红快绿
怡红快绿

Android网络请求库【Retrofit 2.9.0】基本用法与原理分析


Retrofit官网：https://square.github.io/retrofit/
Github地址：https://github.com/square/retrofit

前言

Retrofit是Square公司开发的一款Android网络请求库，Retrofit仅负责网络请求接口的封装，它使用运行时注解的方式提供请求参数的配置功能，底层基于OkHttp实现真正的网络请求。

如果还不了解OkHttp框架，强烈建议先阅读Android 网络请求库OkHttp基本原理与实现再来阅读本篇文章，会更加酣畅淋漓哦~

本文所提及的网络请求如无特殊说明，都是异步网络请求

为什么选择Retrofit（与其他主流框架对比）

现在市场上比较主流的网络请求框架有：

  • android-async-http（作者停止维护、不推荐使用）
  • Volley（谷歌）
  • OkHttp（Square）
  • Retrofit（Square）

一图让你了解全部的网络请求库和他们之间的区别！


Retrofit基本用法

1. 导入库

    implementation("com.squareup.okhttp3:okhttp:4.9.3")
    // define a BOM and its version
    implementation(platform("com.squareup.okhttp3:okhttp-bom:4.9.3"))
    implementation("com.squareup.okhttp3:logging-interceptor")

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation("com.squareup.retrofit2:converter-gson:2.9.0") //支持返回值为Gson类型的数据

默认情况下，Retrofit只能将数据反序列化为OkHttp的ResponseBody类型，并且它只能接受@Body注解的RequestBody类型。

除了默认情况，我们也可以添加转换器以支持其他类型。

  • 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

2. 注解分类

Retrofit注解分为三大类，分别是请求方法注解、标记类注解和参数类注解。

请求方法注解有8种：GET/POST/PUT/DELETE/HEAD/PATCH/OPTIONS/HTTP，前7种与HTTP请求方法是对应的，最后的HTTP可以替换前面七种，也可以扩展请求方法。

标记类注解有3种：FormUrlEncoded、Multipart、Streaming。

参数类注解有Header、Headers、Body、Path、Field、FieldMap、Query、QueryMap、Part、PartMap等。

3. GET网络请求

首先编写请求网络接口

open interface ApiService {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String?): Call?>?
}

@GET 注解指定当前网络请求方式，注解参数是访问地址，方法返回Call?>类型的数据。@Path注解用来动态配置Url地址，@Path("user")对应@GET注解中的{user}，即使用传入的 user: String?值动态替换{user}

接下来创建Retrofit对象，创建接口类（动态代理）调用网络请求方法，得到Call并发起异步请求，回调的Callback运行在UI线程。

val retrofit = Retrofit.Builder()
        .baseUrl("https://api.github.com/")
        .client(okHttpClient)
        .addConverterFactory(GsonConverterFactory.create())  //数据转换器Factory
        .build()
val listRepos = retrofit.create(ApiService::class.java).listRepos("octocat")
listRepos?.enqueue(object : Callback?> {
    override fun onResponse(call: Call?>, response: Response?>) {
        Log.d("retrofit", response.toString())
    }

    override fun onFailure(call: Call?>, t: Throwable) {

    }
})

请求的Url是由baseUrl和@GET注解参数拼接出来的：https://api.github.com/users/octocat/repos

一般情况下为了更准确地去查找网络数据，我们需要在Url中添加查询参数，这种情况可以使用Query指定查询条件。例如根据id查找数据，我们修改代码如下：

@GET("users/{user}/repos")
fun listRepos(@Path("user") user: String?, 
              @Query("id") id: Int?): Call?>?

val listRepos = retrofit.create(ApiService::class.java).listRepos("octocat", 132935648)

这样请求Url变为：https://api.github.com/users/octocat/repos?id=132935648

如果有多个查询参数使用@QueryMap

@GET("users/{user}/repos")
fun listRepos(@Path("user") user: String?,
              @QueryMap map:HashMap): Call?>?

val hashMap = HashMap()
hashMap.put("id", 132935648)
val listRepos = retrofit.create(ApiService::class.java).listRepos("octocat", hashMap)

4. POST网络请求

POST请求最常见的情况是传输键值对的数据类型，使用@Field注解就可以为POST请求添加键值对

@FormUrlEncoded
@POST("user/edit")
fun listRepos(@Field("first_name") first: String,
              @Field("last_name") last: String, ): Call?>?

val listRepos = retrofit.create(ApiService::class.java).listRepos("张", "三")

@FormUrlEncoded表明这是一个表单请求，使用@Field注解标注对应的键值对。

POST请求除了传输键值对，还可以传输JSON字符串，对应注解@Body。

package android.com.retrofit
data class User(val id: Int,
                val age: Int,
                val school: String) {
    constructor() : this(999, 16, "abc")
}

@POST("user/edit")
fun listRepos(@Body user: User): Call?>?

val listRepos = retrofit.create(ApiService::class.java).listRepos(User())

上传单个文件


 * @param photo 上传的文件
 * @param desc 文件描述（简单的键值对）
 */
@Multipart //表示允许多个part
@POST("user/photo")
fun uploadPhoto(@Part photo: MultipartBody.Part,
                @Part("desc") desc:

val file = File("文件路径")
val create = file.asRequestBody("image".toMediaTypeOrNull())
val photo = MultipartBody.Part.createFormData("photos", "aaa", create)
val requestBodyDesc = "picture".toRequestBody(null)
val listRepos = retrofit.create(ApiService::class.java).uploadPhoto(photo,requestBodyDesc)

上传多个文件
与上传单个文件类似，使用Map封装上传的文件，用@PartMap注解标注

更多用法可参考Carson带你学Android：网络请求库Retrofit使用教程(含实例讲解)

Retrofit原理解析

Retrofit最终的目的是通过使用大量的设计模式进行功能模块的解耦，使得网络请求过程变得更加简单流畅。

下图可以直观对比出一般网络请求流程与Retrofit请求的区别


Retrofit流程

详细步骤如下：

  1. 通过解析网络请求接口的注解配置网络请求参数
  2. 通过动态代理生成网络请求对象
  3. 通过网络请求适配器将网络请求对象进行平台适配（平台包括：Android、Rxjava、Guava和java8）
  4. 通过网络请求执行器发送网络请求
  5. 通过数据转换器解析服务器返回的数据
  6. 通过回调执行器切换线程（子线程 ->>主线程）
  7. 用户在主线程处理返回结果
主要角色说明

源码分析（基于Retrofit 2.9.0）

我们从Retrofit最基本的使用方式作为切入口，一步步深入源码探索Retrofit实现原理。

Retrofit使用主要分为以下几步：

  1. 创建Retrofit对象（建造者模式）
  2. 实例化接口类并调用请求方法（动态代理）
  3. 使用第2步返回的Call发起网络请求，Callback回调会运行在UI线程

接下来展开分析：

1. Retrofit.Builder()

因为Retrofit可配置的参数较多，所以采用建造者模式创建Retrofit实例。

Builder类主要代码如下：

  public static final class Builder {
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private @Nullable HttpUrl baseUrl;  //网络请求基本地址
    private final List converterFactories = new ArrayList<>();   //用于创建Converter.Factory
    private final List callAdapterFactories = new ArrayList<>();   //用于创建CallAdapter.Factory
    private @Nullable Executor callbackExecutor;    //切换线程执行回调任务（默认是主线程）
    private boolean validateEagerly;

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

    //设置baseUrl
    public Builder baseUrl(URL baseUrl) {  
      Objects.requireNonNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl.toString()));
    }

    /** 添加自定义的Converter Factory：用于创建数据转换器Converter  */
    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(Objects.requireNonNull(factory, "factory == null"));
      return this;
    }

    /**
     * Add a call adapter factory for supporting service method return types other than {@link
     * Call}.  添加自定义的CallAdapter Factory：用于创建网络请求适配器CallAdapter
     */
    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      callAdapterFactories.add(Objects.requireNonNull(factory, "factory == null"));
      return this;
    }

    //指定执行回调任务的Executor
    public Builder callbackExecutor(Executor executor) {
      this.callbackExecutor = Objects.requireNonNull(executor, "executor == null");
      return this;
    }

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

      //设置默认OkHttpClient
      okhttp3.Call.Factory callFactory = this.callFactory;  
      if (callFactory == null) {
        callFactory = new OkHttpClient(); 
      }
     //android平台默认使用MainThreadExecutor，用于切换到主线程执行任务
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {  
        callbackExecutor = platform.defaultCallbackExecutor();  
      }

      //添加平台默认CallAdapter.Factory到CallAdapterFactories
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);  
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

      //添加平台默认Converter.Factory到converterFactories 
      List converterFactories =
          new ArrayList<>(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
      converterFactories.add(new BuiltInConverters());
      converterFactories.addAll(this.converterFactories);
      converterFactories.addAll(platform.defaultConverterFactories());

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

如果未配置参数，build()方法会为我们提供大多数的默认配置，例如callAdapterFactories（创建网络请求适配器）、converterFactories（创建数据转换器）、callbackExecutor（执行回调任务）等待。

2. retrofit.create(ApiService::class.java).listRepos("octocat")

第一步：采取动态代理的方式创建请求接口的实现类

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

              @Override
              public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                  throws Throwable {
                // If the method is a method from Object then defer to normal invocation.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                //platform.isDefaultMethod(method)返回true表示方法是公共的非抽象实例方法
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);   //接口方法会执行到此处
              }
            });
  }

ApiService.kt是一个接口类，当我们调用接口内的方法时会执行代码loadServiceMethod(method).invoke(args)，先分析loadServiceMethod(method)方法：

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result = serviceMethodCache.get(method);
    if (result != null) return result;

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

代码很简单，调用ServiceMethod.parseAnnotations(this, method)解析接口中的注解方法并封装成ServiceMethod。并且利用serviceMethodCache缓存解析结果，这样可以防止重复解析，使用缓存是因为解析的过程用到了比较耗费性能的反射机制。

abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    //注释2.1：解析方法注解和参数注解，把注解中的网络请求参数封装到RequestFactory中
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method); 

    //注释2.2：保证方法返回类型不是Unresolvable和void.class
    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    //注释2.3
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

注释2.1：RequestFactory.parseAnnotations(retrofit, method)解析注解信息，把信息封装到RequestFactory中
注释2.2：保证方法返回类型不是Unresolvable和void.class
注释2.3：调用HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory)获取ServiceMethod

#HttpServiceMethod
//这里只贴出部分代码
  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;  //方法返回值类型
    //isKotlinSuspendFunction默认为false，进入else语句获取adapterType 
    if (isKotlinSuspendFunction) {  
      ……
    } else {
      adapterType = method.getGenericReturnType(); 
    }
    //注释2.3.1：从callAdapterFactories列表中取出CallAdapter.Factory创建CallAdapter
    //我们可以使用Retrofit.Builder#addCallAdapterFactory(Factory)添加CallAdapter.Factory到列表callAdapterFactories
    //CallAdapter负责执行网络请求Call的适配工作
    CallAdapter callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);  
    Type responseType = callAdapter.responseType();

    ……

    //注释2.3.2：从converterFactories列表中取出Converter.Factory创建Converter
    //我们可以使用Retrofit.Builder#addConverterFactory(Factory)添加Converter .Factory到converterFactories列表
    //Converter负责将服务端返回的数据转换成对象实例
    Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    //注释2.3.3：把requestFactory, callFactory, responseConverter, callAdapter封装进最终的HttpServiceMethod
    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);
    }
  }

注释2.3.1：从callAdapterFactories列表中取出CallAdapter.Factory创建CallAdapter，具体流程如下：

//HttpServiceMethod.java
  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);
    }
  }

调用retrofit.callAdapter(returnType, annotations)

#Retrofit.java
  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;
    //遍历callAdapterFactories列表获取CallAdapter.Factory来创建CallAdapter
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {  
      CallAdapter adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }

    //获取失败
  }

最终遍历callAdapterFactories列表获取CallAdapterFactory来创建我们需要的网络请求适配器CallAdapter，在构建Retrofit时已经添加Android平台默认的platform.defaultCallAdapterFactories到callAdapterFactories

//Retrofit.Builder#build()
//添加默认Call adapter.
List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

除了使用默认的CallAdapterFactory，我们也可以使用Retrofit.Builder#addCallAdapterFactory(Factory)主动添加CallAdapter.Factory到列表callAdapterFactories

CallAdapter主要负责执行网络请求Call的适配工作，注释2.3.2会详细分析

注释2.3.2：从converterFactories列表中取出Converter.Factory创建Converter，具体流程如下：

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

调用retrofit.responseBodyConverter(responseType, annotations)

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

  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;
    //遍历converterFactories列表获取Converter.Factory来创建Converter
    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列表获取Converter.Factory来创建我们需要的Converter，在构建Retrofit时已经添加Android平台默认的platform.defaultConverterFactories()到defaultConverterFactories

//Retrofit.Builder#build()
List converterFactories = new ArrayList<>(
     1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
converterFactories.addAll(platform.defaultConverterFactories());

除了使用默认的ConverterFactory，我们也可以使用Retrofit.Builder#addConverterFactory(Factory)添加Converter .Factory到converterFactories列表；Converter负责将服务端返回的数据转换成对象实例

注释2.3.3：把requestFactory, callFactory, responseConverter, callAdapter封装进最终的HttpServiceMethod

如果未使用Kotlin的Suspend功能，注释2.3.3处会直接执行if语句，即创建一个CallAdapted，它继承自HttpServiceMethod，代码如下：

  static final class CallAdapted extends HttpServiceMethod {
    private final CallAdapter callAdapter;

    CallAdapted(
        RequestFactory requestFactory,
        okhttp3.Call.Factory callFactory,
        Converter responseConverter,
        CallAdapter callAdapter) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }

    @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }
  }

CallAdapted主要是为了实现HttpServiceMethod的抽象方法ReturnT adapt(Call call, Object[] args)，而具体工作交由callAdapter.adapt(call)方法执行。

我们再回到retrofit.create(ApiService::class.java)方法，重新贴一下代码：

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

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

第二步：当我们调用接口ApiService中的listRepos("octocat")方法，动态代理机制会调用InvocationHandler内的invoke(Object proxy, Method method, @Nullable Object[] args)方法，然后会执行loadServiceMethod(method).invoke(args)。

通过前面的分析我们知道，loadServiceMethod(method)方法返回的是一个ServiceMethod，查看它的invoke()方法：

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

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

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

  abstract @Nullable T invoke(Object[] args);
}

invoke(Object[] args)方法在HttpServiceMethod中实现：

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

创建一个OkHttpCall对象作为adapt(call, args)方法的参数，前面已经分析过CallAdapted中实现了adapt(call, args)方法，call最终传递给callAdapter.adapt(call)方法适配出新call。（适配器模式）

如果没有手动指定callAdapter，默认使用DefaultCallAdapterFactory创建callAdapter：

//精简后的代码
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  private final @Nullable Executor callbackExecutor;

  DefaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  @Override
  public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {

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

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

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

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

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

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

  }
}


默认的网络请求适配器主要做了两件事：


    

  1. 在CallAdapter#adapt(Call call) 方法中将OkHttpCall适配成ExecutorCallbackCall来执行网络请求（适配器模式），真正的网络请求依然由OkHttpCall自己发起（代理模式）

  2. 请求完成后将Callback回调方法切换到callbackExecutor中执行，Retrofit提供的默认callbackExecutor负责将任务提交到主线程
    3. 


    3. OkHttpCall发起网络请求
    

    我们已经知道真正的网络请求由OkHttpCall发起，那还等什么快去看看吧
    

      @Override
  public void enqueue(final Callback callback) {
    Objects.requireNonNull(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();  //注释3.1： 使用OkHttpClient创建okhttp3.Call
        } catch (Throwable t) {
          throwIfFatal(t);
          failure = creationFailure = t;
        }
      }
    }

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

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

    //注释3.2：使用创建好的okhttp3.Call发起异步请求
    call.enqueue(
        new okhttp3.Callback() {
          @Override
          public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
            Response response;
            try {
              response = parseResponse(rawResponse);  //注释3.3：解析服务端返回的数据
            } catch (Throwable e) {
              throwIfFatal(e);
              callFailure(e);
              return;
            }

            try {
              callback.onResponse(OkHttpCall.this, response); 
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }

          @Override
          public void onFailure(okhttp3.Call call, IOException e) {
            callFailure(e);
          }

          private void callFailure(Throwable e) {
            try {
              callback.onFailure(OkHttpCall.this, e);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }
        });
  }

    

    注释3.1： 使用OkHttpClient创建okhttp3.Call
    

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

    

    注释3.2：使用创建好的okhttp3.Call发起异步请求
    

    注释3.3：处理服务端返回的数据
    

      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) {  //返回Body为null的Response
      rawBody.close();
      return Response.success(null, rawResponse);  
    }

    ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
    try {
      //responseConverter开始转换网络数据
      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)方法转换Response数据，那么responseConverter具体类型是什么呢？
    

    我们在初始化Retrofit时调用了Retrofit.Builder()#addConverterFactory(GsonConverterFactory.create())方法
    

    val retrofit = Retrofit.Builder()
        .baseUrl("https://api.github.com/")
        .client(okHttpClient)
        .addConverterFactory(GsonConverterFactory.create())  //添加Gson转换器
        .build()

    

    #Retrofit.java
    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(Objects.requireNonNull(factory, "factory == null"));
      return this;
    }

    

    也就是将GsonConverterFactory添加到列表converterFactories，看一下GsonConverterFactory源码：
    

    public final class GsonConverterFactory extends Converter.Factory {

  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
  public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
  }

  private final Gson gson;

  private GsonConverterFactory(Gson gson) {
    this.gson = gson;
  }

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

  @Override
  public Converter requestBodyConverter(
      Type type,
      Annotation[] parameterAnnotations,
      Annotation[] methodAnnotations,
      Retrofit retrofit) {
    TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonRequestBodyConverter<>(gson, adapter);
  }
}

    

    通过注释2.3.2可知，我们要寻找的responseConverter就是GsonResponseBodyConverter，重新回到注释3.3中的Response转换过程responseConverter.convert，本质上是执行GsonResponseBodyConverter.convert：
    

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

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

  @Override
  public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      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();
    }
  }
}

    

    convert(ResponseBody value)方法负责把ResponseBody转换成指定的数据类型
    

    到此为止，还剩最后一个任务：异步请求任务完成之后会以回调的方式通知发起方请求已经结束，为了方便将请求结果展示到UI上，需要把回调操作切换到主线程执行，这个任务由ExecutorCallbackCall负责完成
    

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

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

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

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

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

    @Override
    public Response execute() throws IOException {
      return delegate.execute();
    }
    
    ……
  }

    

    具体方法是将callback.onXxxxx()回调方法丢到callbackExecutor执行，可以在Retrofit中使用方法callbackExecutor(Executor executor)配置callbackExecutor。
    

    如果未配置callbackExecutor，Retrofit会提供默认callbackExecutor，默认配置相关的实现依然是在Retrofit.Builder#build()方法中
    

    //Retrofit.Builder#build()
  Executor callbackExecutor = this.callbackExecutor;
  if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
  }

    

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

    @Override
    public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Nullable
    @Override
    Object invokeDefaultMethod(
        Method method, Class declaringClass, Object object, Object... args) throws Throwable {
      if (Build.VERSION.SDK_INT < 26) {
        throw new UnsupportedOperationException(
            "Calling default methods on API 24 and 25 is not supported");
      }
      return super.invokeDefaultMethod(method, declaringClass, object, args);
    }

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

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

    

    callbackExecutor默认是MainThreadExecutor，MainThreadExecutor负责将任务提交到主线程执行
    

    源码分析结束！
    

    Retrofit源码真是太牛逼了，本人水平有限，如有错误希望大家批评指正！
    

    

    参考资料
    

      

    • Carson带你学Android：手把手带你深入读懂Retrofit 2.0源码
      • 

    






    



    


    


    




    

    你可能感兴趣的:(Android网络请求库【Retrofit 2.9.0】基本用法与原理分析)
    

    

    

      

    • 斤斤计较的婚姻到底有多难？
白心之岂必有为

      很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
      

      • 

    • QQ群采集助手，精准引流必备神器
2401_87347160
其他经验分享

      功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
      

      • 

    • 机器学习与深度学习间关系与区别
ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python

      一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
      

      • 

    • android系统selinux中添加新属性property
辉色投像

      1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
      

      • 

    • 随笔 | 仙一般的灵气
海思沧海

      仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
      

      • 

    • 一百九十四章. 自相矛盾
巨木擎天

      唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
      

      • 

    • element实现动态路由+面包屑
软件技术NINI
vue案例vue.js前端

      el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
      

      • 

    • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

      在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
      

      • 

    • 学点心理知识，呵护孩子健康
静候花开_7090

      昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
      

      • 

    • c++ 的iostream 和 c++的stdio的区别和联系
黄卷青灯77
c++算法开发语言iostreamstdio

      在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
      

      • 

    • 《投行人生》读书笔记
小蘑菇的树洞

      《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
      

      • 

    • Long类型前后端数据不一致
igotyback
前端

      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      

      • 

    • mysql禁用远程登录
igotyback
mysql

      去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
      

      • 

    • Linux下QT开发的动态库界面弹出操作（SDL2）
13jjyao
QT类qt开发语言sdl2linux

      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      

      • 

    • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

      摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
      

      • 

    • 2021-08-26
影幽

      在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
      

      • 

    • 高级编程--XML+socket练习题
masa010
java开发语言

      1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
      

      • 

    • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
小鹿_33

      预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
      

      • 

    • 回溯 Leetcode 332 重新安排行程
mmaerd
Leetcode刷题学习记录leetcode算法职场和发展

      重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
      

      • 

    • 每日一题——第九十题
互联网打工人no1
C语言程序设计每日一练c语言

      题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
      

      • 

    • Python数据分析与可视化实战指南
William数据分析
pythonpython数据

      在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
      

      • 

    • 《庄子.达生9》
钱江潮369

      【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
      

      • 

    • 水泥质量纠纷案代理词
徐宝峰律师

      贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
      

      • 

    • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享

      Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
      

      • 

    • Goolge earth studio 进阶4——路径修改与平滑
陟彼高冈yu
Googleearthstudio进阶教程旅游

      如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
      

      • 

    • Python教程：一文了解使用Python处理XPath
旦莫
Python进阶python开发语言

      目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
      

      • 

    • Google earth studio 简介
陟彼高冈yu
旅游

      GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
      

      • 

    • 关于提高复杂业务逻辑代码可读性的思考
编程经验分享
开发经验java数据库开发语言

      目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
      

      • 

    • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
成长时间线

      7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
      

      • 

    • 山东大学小树林支教调研团青青仓木队——翟晓楠
山东大学青青仓木队

      过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
      

      • 

    • JAVA基础
灵静志远
位运算加载Date字符串池覆盖

      一、类的初始化顺序
1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器
同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。
二、String
1 String a = "abc";
JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
      

      • 

    • keepalived实现redis主从高可用
bylijinnan
redis

      方案说明
两台机器（称为A和B），以统一的VIP对外提供服务
1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A）
2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务
3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
      

      • 

    • java文件操作大全
0624chenhong
java

      最近在博客园看到一篇比较全面的文件操作文章，转过来留着。
http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html
转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html
一.获得控制台用户输入的信息
   &nbs
      

      • 

    • android学习任务
不懂事的小屁孩
工作

      任务
完成情况 搞清楚带箭头的pupupwindows和不带的使用 已完成 熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成 熟练使用android的线程handler,并敲示例代码 进行中 了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar 研究一下android的动画效果，写一个实例 已完成 复习fragem
      

      • 

    • zoom.js
换个号韩国红果果
oom

      它的基于bootstrap 的
https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序
<link rel="stylesheet" href="style/zoom.css">
<script src=&q
      

      • 

    • 详解Oracle云操作系统Solaris 11.2
蓝儿唯美
Solaris

      当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。  
      

      • 

    • spring学习——springmvc（一）
a-john
springMVC

      Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。
 
1，跟踪Spring MVC的请求
请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
      

      • 

    • hdu4342 History repeat itself-------多校联合五
aijuans
数论

      水题就不多说什么了。
#include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--) 
      

      • 

    • EJB和javabean的区别
asia007
beanejb

      EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了
 
1.EJB用于服务端应用开发, 而JavaBeans
      

      • 

    • Struts的action和Result总结
百合不是茶
strutsAction配置Result配置

       
 
一:Action的配置详解:
     下面是一个Struts中一个空的Struts.xml的配置文件
   
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
&quo
      

      • 

    • 如何带好自已的团队
bijian1013
项目管理团队管理团队

      在网上看到博客"
怎么才能让团队成员好好干活"的评论，觉得写的比较好。 原文如下： 我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点：
1.诚信
        对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
      

      • 

    • Java代码混淆工具
sunjing
ProGuard

      Open Source Obfuscators
ProGuard
http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
      

      • 

    • 【Redis三】基于Redis sentinel的自动failover主从复制
bit1129
redis

      在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。
  什么是Sentine
      

      • 

    • 使用代理实现Hibernate Dao层自动事务
白糖_
DAOspringAOP框架Hibernate

      都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。
public void save(Object obj){
Session session = this.getSession();
Transaction tran = session.beginTransaction();
try 
      

      • 

    • maven3实战读书笔记
braveCS
maven3

      Maven简介
是什么？
Is a software project management and comprehension tool.项目管理工具
是基于POM概念(工程对象模型)
[设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复]
[与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区]
 
 
功能： 
      

      • 

    • 编程之美-子数组的最大乘积
bylijinnan
编程之美

      
public class MaxProduct {
/**
* 编程之美 子数组的最大乘积
* 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。
* 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。
* 但按题目的意思，是要求得这个子数组，而不
      

      • 

    • 读书笔记-2
chengxuyuancsdn
读书笔记

      1、反射
2、oracle年-月-日 时-分-秒
3、oracle创建有参、无参函数
4、oracle行转列
5、Struts2拦截器
6、Filter过滤器(web.xml)
1、反射
(1)检查类的结构
在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。
2、oracle年月日时分秒
s
      

      • 

    • [求学与房地产]慎重选择IT培训学校
comsci
it

            关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题
      培训学校的教学楼和宿舍的环境和稳定性问题
      我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子...
&nb
      

      • 

    • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系
daizj
oraclermanfilespersetPARALLELISM

      RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转
PARALLELISM ---
我们还可以通过parallelism参数来指定同时"自动"创建多少个通道：
RMAN > configure device type disk parallelism 3 ;
表示启动三个通道，可以加快备份恢复的速度。 
      

      • 

    • 简单排序:冒泡排序
dieslrae
冒泡排序

      
public void bubbleSort(int[] array){
for(int i=1;i<array.length;i++){
for(int k=0;k<array.length-i;k++){
if(array[k] > array[k+1]){

      

      • 

    • 初二上学期难记单词三
dcj3sjt126com
sciet

      concert 音乐会
tonight 今晚
famous 有名的；著名的
song 歌曲
thousand 千
accident 事故；灾难
careless 粗心的，大意的
break 折断；断裂；破碎
heart 心（脏）
happen  偶尔发生，碰巧
tourist 旅游者；观光者
science （自然）科学
marry 结婚
subject 题目；
      

      • 

    • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码
dcj3sjt126com
redis

      wget http://download.redis.io/redis-stable.tar.gz
tar xvzf redis-stable.tar.gz
cd redis-stable
make
 
前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。
异常一：
make[2]: cc: Command not found
异常原因：没有安装g
      

      • 

    • 并发容器
shuizhaosi888
并发容器

         通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。
   并发容器ConcurrentHashMap
      替代同步基于散列的Map，通过Lock控制。
  &nb
      

      • 

    • Spring Security（12）——Remember-Me功能
234390216
Spring SecurityRemember Me记住我

      Remember-Me功能
 
目录
 
1.1     概述
1.2     基于简单加密token的方法
1.3     基于持久化token的方法
1.4     Remember-Me相关接口和实现
      

      • 

    • 位运算
焦志广
位运算

      
一、位运算符Ｃ语言提供了六种位运算符：
& 按位与
| 按位或
^ 按位异或
~ 取反
<< 左移
>> 右移
1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。
例如：9&am
      

      • 

    • nodejs 数据库连接 mongodb mysql
liguangsong
mongodbmysqlnode数据库连接

      1.mysql 连接
   package.json中dependencies加入
 
 
"mysql":"~2.7.0"
   执行 npm install
 
   在config 下创建文件 database.js
   

      

      • 

    • java动态编译
olive6615
javaHotSpotjvm动态编译

          在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。
    HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
      

      • 

    • Storm0.9.5的集群部署配置优化
roadrunners
优化storm.yaml

      nimbus结点配置（storm.yaml）信息：
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional inf
      

      • 

    • 101个MySQL 的调节和优化的提示
tomcat_oracle
mysql

      　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。 　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。 　　3. 使用电池供电的RAM（注：RAM即随机存储器）。 　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
      

      • 

    • zoj 3829 Known Notation(贪心)
阿尔萨斯
ZOJ

       题目链接：zoj 3829 Known Notation
题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。
解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
      

      •