Retrofit源码分析

一航jason 2019-06-28

目录介绍

  • 1.首先回顾Retrofit简单使用方法

  • 2.Retrofit的创建流程源码分析

    • 2.1 Retrofit对象调用Builder()源码解析
    • 2.2 Retrofit对象调用baseUrl(url)源码解析
    • 2.3 addConverterFactory(Converter.Factory factory)源码分析
    • 2.4 addCallAdapterFactory(RxJava2CallAdapterFactory.create())源码分析
    • 2.5 client(okHttpClient)源码分析
    • 2.6 Retrofit对象调用build()源码解析

  • 3.创建ServiceMethod流程源码分析

    • 3.1 首先看看请求网络代码过程
    • 3.2 分析create(final Class<T> service)源码
    • 3.3 serviceMethod对象的创建过程

  • 4.注解的解析

    • 4.1 callAdapter的创建源码分析
    • 4.2 responseConverter的创建源码分析

  • 5.OkHttpCall的创建源码分析

    • 5.1 new OkHttpCall<>(serviceMethod, args)源码分析

  • 6.OkHttpCall的网络请求

    • 6.1 OkHttpCall.execute()同步请求
    • 6.2 OkHttpCall.enqueue()异步请求
    • 6.3 parseResponse解析网络数据源码解析

好消息

  • 博客笔记大汇总【16年3月到至今】，包括Java基础及深入知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，当然也在工作之余收集了大量的面试题，长期更新维护并且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计47篇[近20万字]，转载请注明出处，谢谢！
  • 链接地址：https://github.com/yangchong2...
  • 如果觉得好，可以star一下，谢谢！当然也欢迎提出建议，万事起于忽微，量变引起质变！
  • 关于Retrofit的使用，可以参考这篇文章：https://www.jianshu.com/p/989...

0.思考问题，针对以下问题，看了这篇博客，应该有了初步的认识

  • 0.0.1 Retrofit创建中用了哪些设计模式，请谈谈使用这些设计模式的优势？
  • 0.0.2 Retrofit在创建的时候为什么要判断是否在Android环境中，是如何做到的？
  • 0.0.3 为什么设置baseUrl的时候，会以/结尾，如果没有/会出现什么问题？
  • 0.0.4 addConverterFactory的主要作用是什么？
  • 0.0.5 Factory生产的是CallAdapter，那么CallAdapter又是什么呢？
  • 0.0.6 网络请求的类 service为什么要定义成接口？如果不定义成接口会出现什么情况？
  • 0.0.7 创建了ServiceMethod对象是干什么用的？它是用什么进行存储的？
  • 0.0.8 创建ServiceMethod对象为什么要添加synchronized同步锁
  • 0.0.9 call调用enqueue异步方法中源码是如何实现异步切换线程的？原理是怎样的？
  • 0.1.0 ServiceMethod是如何保存网络请求所需要的数据，具体保存了哪些数据呢？

  • 0.1.1 网络传输都是二进制流，那么解析数据时，如何通过ServiceMethod使用Converter转换成Java对象进行数据解析

    //AdvertCommon是javabean实体类，并没有序列化，那么网络解析数据如何解析java对象呢？
Call<AdvertCommon> getSplashImage(@Query("type") int type);

  • 0.1.2 如下所示，为什么说apiService对象实际上是动态代理对象，而不是真正的网络请求接口创建的对象

    ApiService apiService = retrofit.create(ApiService.class);
  • 0.1.3 如何理解动态代理的机制。retrofit是如何加载接口类ApiService的，为什么这个类要设置成接口？

1.首先回顾Retrofit简单使用方法

  • Api接口

    public interface DouBookApi {
    /**
    * 根据tag获取图书
    * @param tag  搜索关键字
    * @param count 一次请求的数目 最多100
*/
    @GET("v2/book/search")
    Observable<DouBookBean> getBook(@Query("tag") String tag,
                                    @Query("start") int start,
                                    @Query("count") int count);
}
```

  • Model类

    public class DouBookModel {

    private static DouBookModel bookModel;
    private DouBookApi mApiService;

    public DouBookModel(Context context) {
        mApiService = RetrofitWrapper
                .getInstance(ConstantALiYunApi.API_DOUBAN)   //baseUrl地址
                .create(DouBookApi.class);
    }

    public static DouBookModel getInstance(Context context){
        if(bookModel == null) {
            bookModel = new DouBookModel(context);
        }
        return bookModel;
    }

    public Observable<DouBookBean> getHotMovie(String tag, int start , int count) {
        Observable<DouBookBean> book = mApiService.getBook(tag, start, count);
        return book;
    }
}

  • 抽取类

    public class RetrofitWrapper {

    private static RetrofitWrapper instance;
    private Retrofit mRetrofit;

    public RetrofitWrapper(String url) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();

        //打印日志
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        builder.addInterceptor(logging).build();
        OkHttpClient client = builder.addInterceptor(new LogInterceptor("HTTP")).build();

        //解析json
        Gson gson = new GsonBuilder()
                .setLenient()
                .create();
        
        mRetrofit = new Retrofit
                .Builder()
                .baseUrl(url)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .client(client)
                .build();
    }

    public  static RetrofitWrapper getInstance(String url){
        //synchronized 避免同时调用多个接口，导致线程并发
        synchronized (RetrofitWrapper.class){
            instance = new RetrofitWrapper(url);
        }
        return instance;
    }

    public <T> T create(final Class<T> service) {
        return mRetrofit.create(service);
    }
}

  • 使用

    DouBookModel model = DouBookModel.getInstance(activity);
model.getHotMovie(mType,start,count)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber<DouBookBean>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(DouBookBean bookBean) {

            }
        });

  • 针对Retrofit，需要注意

    • Retrofit 是一个 RESTful 的 HTTP 网络请求框架的封装。网络请求的工作本质上是 OkHttp 完成，而 Retrofit 仅负责 网络请求接口的封装。看下图所示，摘自网络
    • Retrofit源码分析

2.Retrofit的创建流程源码分析

  • Retrofit实例是使用建造者模式通过Builder类进行创建的。Builder模式的优势：将一个复杂对象的构建与表示分离，使得用户在不知道对象的创建细节情况下就可以直接创建复杂的对象。
  • 针对builder设计模式，可以参考我的这篇博客：https://blog.csdn.net/m0_3770...
  • 关于使用builder模式写代码的案例，可以参考我的弹窗封装lib：https://github.com/yangchong2...

2.1 Retrofit对象调用Builder()源码解析

  • 首先看看里面的源代码，如下所示

    • 可以看到Platform.get()获取的是单利对象。那么也许你会问，这个方法的作用主要是什么呢？通过Class.forName获取类名的方式，来判断当前的环境是否在Android中，这在之后获取默认的CallAdapterFactory时候将会用到。下面我会分析到……
    • 关于单利设计模式，如果还有疑问，或者想知道所有的获取单利的方法，可以参考我的这篇博客：设计模式之一：单例模式
    //第一步
public Builder() {
  this(Platform.get());
}


//第二步，追踪到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) {
    //此处表示：如果是Android平台，就创建并返回一个Android对象
    return new Android();
  }
} catch (ClassNotFoundException ignored) {
}
try {
  Class.forName("java.util.Optional");
  return new Java8();
} catch (ClassNotFoundException ignored) {
}
return new Platform();
}

  • 然后看一下new Android()是做了什么？

    static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
        // 返回一个默认的回调方法执行器
        // 该执行器作用：切换线程（子->>主线程），并在主线程（UI线程）中执行回调方法
      return new MainThreadExecutor();
    }
    
    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
       // 创建默认的网络请求适配器工厂 
       // 该默认工厂生产的 adapter 会使得Call在异步调用时在指定的 Executor 上执行回调 
       // 采用了策略模式
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    
    static class MainThreadExecutor implements Executor {
    // 获取与Android 主线程绑定的Handler 
      private final Handler handler = new Handler(Looper.getMainLooper());
    
      @Override public void execute(Runnable r) {
       // 该Handler是上面获取的与Android 主线程绑定的Handler 
        // 在UI线程进行对网络请求返回数据处理等操作。
        handler.post(r);
      }
    }
}

2.2 Retrofit对象调用baseUrl(url)源码解析

  • 都知道这个方法主要是设置baseUrl。源码如下所示

    • 首先先对baseUrl进行非空判断。然后再解析baseUrl，如果解析的httpUrl为null，则会抛出IllegalArgumentException非法参数异常。那么思考一下，什么情况下解析baseUrl会导致解析内容httpUrl为null呢？
    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);
}

  • HttpUrl是如何解析url，对url有什么条件，来看一下parse方法源码

    • 可以看到url必须是以http或者https才可以。如果随便写一个url，则会出问题
    public static @Nullable HttpUrl parse(String url) {
    Builder builder = new Builder();
    Builder.ParseResult result = builder.parse(null, url);
    return result == Builder.ParseResult.SUCCESS ? builder.build() : null;
}

ParseResult parse(@Nullable HttpUrl base, String input) {
  int pos = skipLeadingAsciiWhitespace(input, 0, input.length());
  int limit = skipTrailingAsciiWhitespace(input, pos, input.length());

  // Scheme.
  int schemeDelimiterOffset = schemeDelimiterOffset(input, pos, limit);
  if (schemeDelimiterOffset != -1) {
    if (input.regionMatches(true, pos, "https:", 0, 6)) {
      this.scheme = "https";
      pos += "https:".length();
    } else if (input.regionMatches(true, pos, "http:", 0, 5)) {
      this.scheme = "http";
      pos += "http:".length();
    } else {
      return ParseResult.UNSUPPORTED_SCHEME; // Not an HTTP scheme.
    }
  } else if (base != null) {
    this.scheme = base.scheme;
  } else {
    return ParseResult.MISSING_SCHEME; // No scheme.
  }
  
  //下面代码省略了

  • 思考一下，传递的url为什么是String BASE_URL = "http://beta.goldenalpha.com.cn/"这个格式呢？接着看看baseUrl(httpUrl)源码

    • 可以看到这里的url地址必须是以/结尾。所以如果是没有加上/，则会出现异常
    public Builder baseUrl(HttpUrl baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  List<String> pathSegments = baseUrl.pathSegments();
  if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
  }
  this.baseUrl = baseUrl;
  return this;
}
  • 其实个人感觉这块工作并不难，只要有点英文基础的，就可以完全看的明白。接着往下分析，如果想了解更多，欢迎看我的博客汇总：https://github.com/yangchong2...

2.3 addConverterFactory(Converter.Factory factory)源码分析

  • 在创建的时候会调用addConverterFactory(GsonConverterFactory.create(JsonUtils.getJson()))添加Gson转换器

    • 这个方法主要是添加用于对象序列化和反序列化的转换器工厂
    • 将上面创建的GsonConverterFactory放入到 converterFactories数组
    .addConverterFactory(GsonConverterFactory.create(JsonUtils.getGson()))

//看这行代码
public Builder addConverterFactory(Converter.Factory factory) {
    //将上面创建的GsonConverterFactory放入到 converterFactories数组
  converterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

  • 然后看看GsonConverterFactory.creat()方法源码

    • 使用{@code gson}创建一个实例以进行转换。编码到JSON并从JSON解码(当没有由头指定字符集时)将使用UTF-8。
    • 创建了一个含有Gson对象实例的GsonConverterFactory，并返回给addConverterFactory（）
    public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
}

2.4 addCallAdapterFactory(RxJava2CallAdapterFactory.create())源码分析

  • 添加一个调用适配器工厂，用于支持服务方法返回类型

    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  callAdapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

  • CallAdapterFactory：注意Factory生产的是CallAdapter，那么CallAdapter又是什么呢？

    • 可以看到CallAdapter源代码如下所示，它是一个接口。主要作用是：将响应类型{@代码R}的{@链接调用}改编为{@代码T}的类型。实例由{@LinkplanFactory(一个工厂)创建，该工厂}是{@Link平原Retrofit.Builder#addCallAdapterFactory(Factory)已安装}到{@LinkRetroflit}实例中。
    • 网络请求执行器（Call）的适配器，并且在Retrofit中提供了三种CallAdapterFactory： ExecutorCallAdapterFactory（默认）、DefaultCallAdapterFactory、RxJava2CallAdapterFactory
    public interface CallAdapter<R, T> {
  Type responseType();
  T adapt(Call<R> 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);
    }
  }
}

  • 接着，有伙伴可能会问它的作用是什么呢？

    • 将默认的网络请求执行器（OkHttpCall）转换成适合被不同平台来调用的网络请求执行器形式
    • 一开始Retrofit只打算利用OkHttpCall通过ExecutorCallbackCall切换线程；但后来发现使用Rxjava更加方便（不需要Handler来切换线程）。想要实现Rxjava的情况，那就得使用RxJavaCallAdapterFactoryCallAdapter将OkHttpCall转换成Rxjava(Scheduler)
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())

2.5 client(okHttpClient)源码分析

  • 用于请求的HTTP客户端

    • 指定用于创建{@link Call}实例的自定义调用工厂。
    public Builder client(OkHttpClient client) {
  return callFactory(checkNotNull(client, "client == null"));
}

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

2.6 Retrofit对象调用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<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
  callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

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

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

  • 然后看看Retrofit的构造方法

    • 成功建立一个Retrofit对象的标准：配置好Retrofit类里的成员变量，即配置好：

      • serviceMethod：包含所有网络请求信息的对象
      • baseUrl：网络请求的url地址
      • callFactory：网络请求工厂
      • adapterFactories：网络请求适配器工厂的集合
      • converterFactories：数据转换器工厂的集合
      • callbackExecutor：回调方法执行器
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
  List<Converter.Factory> converterFactories, List<CallAdapter.Factory> callAdapterFactories,
  @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
    this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
}

  • 然后总结一下创建的过程

    • 平台类型对象（Platform - Android）
    • 网络请求的url地址（baseUrl）
    • 网络请求工厂（callFactory） 默认使用OkHttpCall
    • 网络请求适配器工厂的集合（adapterFactories） 本质是配置了网络请求适配器工厂- 默认是ExecutorCallAdapterFactory
    • 数据转换器工厂的集合（converterFactories） 本质是配置了数据转换器工厂
    • 回调方法执行器（callbackExecutor） 默认回调方法执行器作用是：切换线程（子线程 - 主线程）

3.创建ServiceMethod流程源码分析

3.1 首先看看请求网络代码过程

  • 大概的流程如下代码所示

    • 定义网络请求的接口类 ApiService
    public interface ApiService {
    @POST("api/v1/user/old")
    Call<ResEntity<UserOld>> isUserOld();
}

//创建接口类实例
ApiService apiService = retrofit.create(ApiService.class);
//生成最终的网络请求对象
Call<ResEntity<UserOld>> userOld = apiService.isUserOld();
//异步机制
userOld.enqueue(new Callback<ResEntity<UserOld>>() {
    @Override
    public void onResponse(Call<ResEntity<UserOld>> call, retrofit2.Response<ResEntity<UserOld>> response) {
        
    }
    @Override
    public void onFailure(Call<ResEntity<UserOld>> call, Throwable t) {

    }
});

3.2 分析create(final Class<T> service)源码

  • 源代码如下所示，这段代码很重要。

    • 创建接口定义的API端点的实现。给定方法的相对路径是从描述请求类型的方法的注释中获得的。
    • 先对service类进行判断是否是接口。这个时候你就知道为何只能定义service为接口呢……
    • 接着就创建了ServiceMethod对象，并且把这个对象以键的形式存储到ConcurrentHashMap集合中

    • 最后创建了网络请求接口的动态代理对象，通过代理模式中的动态代理模式，动态生成网络请求接口的代理类，并将代理类的实例创建交给InvocationHandler类 作为具体的实现，并最终返回一个动态代理对象。

      • service.getClassLoader()作用是动态生成接口的实现类
      • new Class<?>[] { service }作用是动态创建实例
      • new InvocationHandler()作用是将代理类的实现交给 InvocationHandler类作为具体的实现
    • 即通过动态生成的代理类，调用interfaces接口的方法实际上是通过调用InvocationHandler对象的invoke方法来完成指定的功能
    public <T> T create(final Class<T> 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<Object, Object> serviceMethod =
            (ServiceMethod<Object, Object>) loadServiceMethod(method);
        //根据配置好的serviceMethod对象创建okHttpCall对象 
        OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
        //调用OkHttp，并根据okHttpCall返回rejava的Observe对象或者返回Call
        return serviceMethod.adapt(okHttpCall);
      }
    });
}

  • 接着看一下validateServiceInterface方法操作了什么？

    • 通过这个方法可知，如果service类不是接口则会抛异常。同时需要注意API接口不能扩展其他接口
    static <T> void validateServiceInterface(Class<T> service) {
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }
    // Prevent API interfaces from extending other interfaces. This not only avoids a bug in
    // Android (http://b.android.com/58753) but it forces composition of API declarations which is
    // the recommended pattern.
    if (service.getInterfaces().length > 0) {
      throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
    }
}

  • 接着看看eagerlyValidateMethods这个方法的源码

    • 判断是否需要提前验证，主要是给接口中每个方法的注解进行解析并得到一个ServiceMethod对象，然后以Method为键将该对象存入serviceMethodCache集合中。该集合是一个ConcurrentHashMap集合。
    • 关于ConcurrentHashMap集合的源码分析，可以参考我的这篇博客ConcurrentHashMap
    private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        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 = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
}

  • 知道return (T) roxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler invocationHandler)通过代理模式中的动态代理模式，在面试中也经常会问到该模式，那么该模式有什么特点呢？

    • 当NetService对象调用getCall（）接口中方法时会进行拦截，调用都会集中转发到 InvocationHandler#invoke （），可集中进行处理
    • 获得网络请求接口实例上的所有注解

  • 接着看看loadServiceMethod(Method method)方法源码

    • 可以看到先从serviceMethodCache集合中获取result对象，然后对result进行非空判断
    • 并且通过synchronized关键字设置了线程同步锁，创建ServiceMethod对象前，先看serviceMethodCache有没有缓存之前创建过的网络请求实例，若没缓存，则通过建造者模式创建 serviceMethod 对象。创建实例的缓存机制：采用单例模式从而实现一个 ServiceMethod 对象对应于网络请求接口里的一个方法
    • 针对synchronized关键字的作用可以参考我的这篇博客：https://blog.csdn.net/m0_3770...
    • 针对单利设计模式总结笔记：https://blog.csdn.net/m0_3770...
    • Retrofit源码分析

3.3 serviceMethod对象的创建过程

  • 创建之前，首先会尝试根据方法从一个缓存列表中取出ServiceMethod实例，如果没有，在锁保护之后，还有再尝试一次，还是没有的情况下，才会去创建ServiceMethod。

    • Retrofit源码分析

  • 第一步，先看看ServiceMethod的Builder方法

    • 除了传递了两个参数外，还获取网络请求接口方法里的注释，获取网络请求接口方法里的参数类型，获取网络请求接口方法里的注解内容
    Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;
  this.method = method;
  this.methodAnnotations = method.getAnnotations();
  this.parameterTypes = method.getGenericParameterTypes();
  this.parameterAnnotationsArray = method.getParameterAnnotations();
}

  • 第二步，然后看看ServiceMethod的build()方法

    • 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的网络请求适配器callAdapter对象
    • 网络请求接口方法的返回值和注解类型，从Retrofit对象中获取该网络适配器返回的数据类型responseType
    • 然后对responseType类型进行判断，如果是Response类型或者okhttp3.Response类型，则抛出异常
    • 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的数据转换器responseConverter对象
    • 然后采用for循环解析网络请求接口中方法的注解，注解包括：DELETE、GET、POST、HEAD、PATCH、PUT、OPTIONS、HTT等等
    • 如果httpMethod为null。则抛出异常
    public ServiceMethod build() {
  callAdapter = createCallAdapter();
  responseType = callAdapter.responseType();
  if (responseType == Response.class || responseType == okhttp3.Response.class) {
    throw methodError("'"
        + Utils.getRawType(responseType).getName()
        + "' is not a valid response body type. Did you mean ResponseBody?");
  }
  responseConverter = createResponseConverter();

  for (Annotation annotation : methodAnnotations) {
    parseMethodAnnotation(annotation);
  }

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

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

  int parameterCount = parameterAnnotationsArray.length;
  parameterHandlers = new ParameterHandler<?>[parameterCount];
  for (int p = 0; p < parameterCount; p++) {
    Type parameterType = parameterTypes[p];
    if (Utils.hasUnresolvableType(parameterType)) {
      throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
          parameterType);
    }

    Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
    if (parameterAnnotations == null) {
      throw parameterError(p, "No Retrofit annotation found.");
    }

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

  if (relativeUrl == null && !gotUrl) {
    throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
  }
  if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
    throw methodError("Non-body HTTP method cannot contain @Body.");
  }
  if (isFormEncoded && !gotField) {
    throw methodError("Form-encoded method must contain at least one @Field.");
  }
  if (isMultipart && !gotPart) {
    throw methodError("Multipart method must contain at least one @Part.");
  }

  return new ServiceMethod<>(this);
}

  • 第三步，看看ServiceMethod(Builder<R, T> builder) 构造方法

    • 可以看到这里都是参数赋值操作
    ServiceMethod(Builder<R, T> builder) {
    this.callFactory = builder.retrofit.callFactory();
    this.callAdapter = builder.callAdapter;
    this.baseUrl = builder.retrofit.baseUrl();
    this.responseConverter = builder.responseConverter;
    this.httpMethod = builder.httpMethod;
    this.relativeUrl = builder.relativeUrl;
    this.headers = builder.headers;
    this.contentType = builder.contentType;
    this.hasBody = builder.hasBody;
    this.isFormEncoded = builder.isFormEncoded;
    this.isMultipart = builder.isMultipart;
    this.parameterHandlers = builder.parameterHandlers;
}

4.注解的解析

4.1 callAdapter的创建源码分析

  • 首先获取method的对象表示的方法的形式类型。然后获取method的注解。重点看看retrofit.callAdapter(returnType, annotations)主要做了什么？

    private CallAdapter<T, R> createCallAdapter() {
  Type returnType = method.getGenericReturnType();
  if (Utils.hasUnresolvableType(returnType)) {
    throw methodError(
        "Method return type must not include a type variable or wildcard: %s", returnType);
  }
  if (returnType == void.class) {
    throw methodError("Service methods cannot return void.");
  }
  Annotation[] annotations = method.getAnnotations();
  try {
    //noinspection unchecked
    return (CallAdapter<T, R>) 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);
  }
}

  • 看看retrofit.callAdapter(returnType, annotations)源码

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

public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
  Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(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());
}

4.2 responseConverter的创建源码分析

5.OkHttpCall的创建源码分析

5.1 new OkHttpCall<>(serviceMethod, args)源码分析

  • 可以看到创建OkHttpCall对象需要两个参数，参数分别是配置好的ServiceMethod对象和输入的请求参数

    • 源码如下所示
    final class OkHttpCall<T> implements Call<T> {
  private final ServiceMethod<T, ?> serviceMethod;
  private final @Nullable Object[] args;

  OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
    //含有所有网络请求参数信息的对象
    this.serviceMethod = serviceMethod;
    //网络请求接口的参数 
    this.args = args;
  }
}

  • 接着看看return serviceMethod.adapt(okHttpCall)源码分析

    • 创建的OkHttpCall对象传给第一步创建的serviceMethod对象中对应的网络请求适配器工厂的adapt()
    • 返回对象类型：Android默认的是Call<>；若设置了RxJavaCallAdapterFactory，返回的则是Observable<>。如果这个地方不理解，可以继续往下看
    T adapt(Call<R> call) {
    return callAdapter.adapt(call);
}

  • 接着看看实际的调用

    • ApiService对象实际上是动态代理对象Proxy.newProxyInstance()，并不是真正的网络请求接口创建的对象
    • 当ApiService对象调用isUserOld()时会被动态代理对象Proxy.newProxyInstance()拦截，然后调用自身的InvocationHandler # invoke()
    • invoke(Object proxy, Method method, Object... args)会传入3个参数：Object proxy:（代理对象）、Method method（调用的isUserOld()），Object... args（方法的参数，即getCall（*）中的）
    • 接下来利用Java反射获取到isUserOld()的注解信息，配合args参数创建ServiceMethod对象。

    • 最终创建并返回一个OkHttpCall类型的Call对象或者Observable

      • OkHttpCall类是OkHttp的包装类
      • 创建了OkHttpCall类型的Call对象还不能发送网络请求，需要创建Request对象【也就是异步请求方法】才能发送网络请求
ApiService apiService = retrofit.create(ApiService.class);
//返回Android默认的Call
Call<ResEntity<UserOld>> userOld = apiService.isUserOld();


//返回的则是Observable<T>
Observable<AdvertCommon> advert = mApiService.getSplashImage(method)

6.OkHttpCall的网络请求

6.1 OkHttpCall.execute()同步请求

  • 使用方法Response<Bean> response = call.execute();

    • 实际开发中这种我也没有用过……哈哈
    • 首先添加一个synchronized同步锁。先创建一个OkHttp的Request对象请求，然后调用OkHttpCall的execute()发送网络请求，再然后解析网络请求返回的数据。

    • 需要注意：

      • 发送网络请求时，OkHttpCall需要从ServiceMethod中获得一个Request对象
@Override public Response<T> execute() throws IOException {
    okhttp3.Call call;

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

      if (creationFailure != null) {
        if (creationFailure instanceof IOException) {
          throw (IOException) creationFailure;
        } else if (creationFailure instanceof RuntimeException) {
          throw (RuntimeException) creationFailure;
        } else {
          throw (Error) creationFailure;
        }
      }

      call = rawCall;
      if (call == null) {
        try {
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException | Error e) {
          throwIfFatal(e); //  Do not assign a fatal error to creationFailure.
          creationFailure = e;
          throw e;
        }
      }
    }

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

    return parseResponse(call.execute());
  }
  
  //从serviceMethod一个Request对象
private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = serviceMethod.toCall(args);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
}

6.2 OkHttpCall.enqueue()异步请求

  • 关于异步操作封装库，可以看我的开源线程池封装库：https://github.com/yangchong2...

  • 如何调用可以看前面的代码介绍。这里就不介绍呢！

    • 首先添加一个synchronized同步锁。创建OkHttp的Request对象，然后发送网络请求，然后解析返回数据。在这里，可能会想到，究竟是如何做到异步操作的呢？
    @Override public void enqueue(final Callback<T> 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) {
          throwIfFatal(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) {
        Response<T> response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }

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

      @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) {
          t.printStackTrace();
        }
      }
    });
  }
  
  
private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = serviceMethod.toCall(args);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
 }

  • 从上可以知道，call操作异步，那么这个call是什么呢？那么我们看一下ExecutorCallAdapterFactory这个类，关于CallAdapterFactory是做什么用的？前面已经介绍呢！

    • 如果你对异步线程还不是很熟悉，可以参考我的线程池封装库，里面已经很详细实现了异步线程操作，参考链接：https://github.com/yangchong2...
    • 线程切换，即将子线程切换到主线程，从而在主线程对返回的数据结果进行处理
    static final class ExecutorCallbackCall<T> implements Call<T> {
final Executor callbackExecutor;
final Call<T> delegate;

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

@Override public void enqueue(final Callback<T> callback) {
  checkNotNull(callback, "callback == null");

  delegate.enqueue(new Callback<T>() {
    @Override public void onResponse(Call<T> call, final Response<T> response) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          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<T> call, final Throwable t) {
      callbackExecutor.execute(new Runnable() {
        @Override public void run() {
          callback.onFailure(ExecutorCallbackCall.this, t);
        }
      });
    }
  });
}

6.3 parseResponse解析网络数据源码解析

  • 解析网络数据

    • 关于网络状态栏，我已经整理了一篇十分详细的博客，可以看我的这篇文章：07.Http状态码详解
    • 调用serviceMethod.toResponse(catchingBody)，解析数据时，还需要通过ServiceMethod使用Converter（数据转换器）转换成Java对象进行数据解析
    • 关于网络请求的基础介绍，可以参考我的这篇博客：https://blog.csdn.net/m0_3770...
    Response<T> 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);
    }

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

关于其他内容介绍

01.关于博客汇总链接

02.关于我的博客

一航jason

一航jason

相关推荐

Retrofit反射修改baseUrl

通过测试后发现final值是可以修改的，但是final值的初始化要在构造方法中赋值。当网络请求正在进行时，这种暴力切换方式，可能会有些意想不到的问题，至于其它问题，后续发现追加。

霸气的名字 / 0评论 2020-06-23

【Android】Retrofi的基础使用教程

文章参考学习自 阳光沙滩，是我在B站上发现的宝藏Up主，超级棒！在前段时间我写了一个java web后台，想做一个安卓端的打卡社区，后来发现请求和解析过于麻烦，就耽搁了。趁着空闲，研究了一下大部分项目中都采用的MVP+RxJava+Retrofit模式中的

smaillift / 0评论 2020-02-17

阿里二面：关于 Retrofit 你知道多少？

从使用方法出发，首先是怎么使用，其次是我们使用的功能在内部是如何实现的， 实现方案上有什么技巧，有什么范式。全文基本上是对 Retrofit 源码的一个分析与 导读，非常建议大家下载 Retrofit 源码之后，跟着本文，过一遍源码。先看定义，非常简洁，也

霸气的名字 / 0评论 2020-02-15

Retrofit的优点

将接口的定义与使用分离开来，实现结构。支持多种返回数据解析的Converter可以快速进行数据转换。因为容易和RxJava结合使用，所以对于异步请求，同步请求也不需要做额外的工作。在Application中初始化Retrofit，因为一个Retrofit对

RikkaTheWorld / 0评论 2019-12-08

Android RxJava系列三: 与Retrofit2结合使用和封装处理

本篇文章主要介绍Rxjava与Retrofit结合使用,对Rxjava和Retrofit不熟悉的可以去看我之前的两篇介绍。Observable<School> postSchool;//根据学校名获取学校。//此处处理请求失败业务(code !

TOmyhonour / 0评论 2019-11-08

Retrofit2源码分析

从简单的例子开始分析Retrofit2是怎么和其他的库一起合作的，下边是一个很简单的例子，是rxjava2 + retrofit2 + okhttp3 + gson混合使用，是访问淘宝的ip地址查询服务，返回信息输出到EditText里。

齐天大圣数据候 / 0评论 2019-10-31

Android OkHttp + Retrofit 下载文件与进度监听

下载文件是一个比较常见的需求。给定一个url，我们可以使用URLConnection下载文件。给OkHttp中添加拦截器，即可实现下载进度的监听功能。获取并使用字节流，需要注意两个要点，一个是服务接口方法的 @Streaming 注解，另一个是获取到Res

kcstrong / 0评论 2019-10-19

Android封装Retrofit2+OkHttp3+RxJava网络请求

现在Android 市面上很火的当然是 Retrofit＋RxJava + OkHttp, 功能强大，简单易用，因此选用这套方案来改造网络库。Retrofit: Retrofit是Square 公司开发的一款正对Android 网络请求的框架。底层基于Ok

冰川孤辰 / 0评论 2019-09-08

Android 组件化最佳实践 ARetrofit 原理

ARetrofit 是一款针对Android组件之间通信的路由框架，实现快速组件化开发的利器。本文主要讲述 ARetrofit 实现的原理。开发ARetrofit 这个项目的思路来源其实是 Retrofit，Retrofit 是Square公司开发的一款针

kangtingting0 / 0评论 2019-09-07

Retrofit 使用

A type-safe HTTP client for Android and Java翻译：Android和Java的类型安全的HTTP客户端。首先简单介绍下Retrofit这个框架，Retrofit是底层是基于Okhttp的也就是说用法和Okhttp很

俊光 / 0评论 2018-08-10

Android第三方库解析

很多人面试之前，可能没有在互联网公司工作过或者说工作过但年头较短，不知道互联网公司技术面试都会问哪些问题?再加上可能自己准备也不充分，去面试没几个回合就被面试官几个问题打蒙了，最后以惨败收场。

俊光 / 0评论 2019-07-30

Android Retrofit 2.5.0使用基础详解

前言在Andrroid开发中，网络请求必不可少而在Android所有网络请求库中，Retrofit是最受开发者欢迎的一个网络请求库retrofit:2.5.0 官方文档。// 如果想直接获得Responsebody中的内容，可以定义网络请求返回值为Call

xzw / 0评论 2019-07-01

【Android】RxJava + Retrofit完成网络请求

前言本文基于RxJava、Retrofit的使用，若是对RxJava或Retrofit还不了解的简友可以先了解RxJava、Retrofit的用法再来看这篇文章。在这片文章之前分别单独介绍过Rxjava以及Retrofit的使用：Android Retro

smaillift / 0评论 2019-07-01

【Android】Retrofit 2.0 的使用

来自官网的介绍：。A type-safeHTTP clientfor Android and JavaRest API是一种软件设计风格，服务器作为资源存放地。客户端去请求GET,PUT, POST,DELETE资源。并且是无状态的，没有session的参

javashu0 / 0评论 2019-07-01

RxRetroHttp，为多套API请求适配而生

前言"后端更新换代，新接口返回全用新的规则，老接口不变！“我们的这几个网站，要做一个统一的App，后端都是现成的，这是API文档。”。。。千万只草泥马呼啸而过。。。虽然说现在已经有很多Http请求框架了，也有很多针对RxJava+Retrofit

needh / 0评论 2019-06-30

轻量级kotlin + Mvp + Rxjava + Retrofit框架

适合团队的框架才是好的框架1.项目简介本项目是基于kotlin + Mvp + Rxjava + Retrofit 封装的轻量级模板项目。项目没有过多冗余的依赖，适用于快速开发以及新手练手。但是之前用过一段时间MvpArms，也从中学到了很多东西，但是并不

kcstrong / 0评论 2019-06-28

Android网络请求框架Retrofit使用笔记

并提供了多种数据转换工厂和RxJava适配工厂接口。}演示了一个带参Get请求，使用Gson做json数据转换。

qjbagu / 0评论 2016-04-05

解决Retrofit多BaseUrl及运行时动态改变BaseUrl(二)

前言我在之前的文章 《解决Retrofit多BaseUrl及运行时动态改变BaseUrl》 中，介绍了市面上能够解决此类问题的 4 个常见的解决方案，并开源了自己经过优化后的解决方案 RetrofitUrlManager，现在再为大家带来此系列的第二篇文章

霸气的名字 / 0评论 2019-06-27

Retrofit源码分析三 源码分析

repos.enqueue上面是Retrofit的最基本使用方法，当然现在使用最多的还是RxJava2+Retrofit搭配使用，关于RxJava2，大家可以看我的另一篇 RxJava2源码分析 ，当然RxJava2与Retrofit搭配使用的解析我会在稍

RikkaTheWorld / 0评论 2019-06-27

Retrofit2 源码解析之动态代理

}如上所示，Retrofit 的使用非常简单。// If the method is a method from Object then defer to normal invocation.

mirahs / 0评论 2019-06-27

RTFSC系列之Retrofit

Retrofit基本介绍Retrofit是Square开源的一个适用于Android和Java的类型安全的HTTP网络框架。其本质是对OKHttp的进一步封装，通过接口的方式进行网络请求，结合了注解、动态代理等技术实现模块解耦，简化了网络请求的上层逻辑。从

huangliuyu00 / 0评论 2019-06-27

从 ServiceMethod 开始理解 retrofit

目的是想让我们对 retrofit 的执行流程有一个框架性的了解，同时也是为了面试的时候，可以跟面试官“有的聊”。通过对 method 对象 find usage ，我们可以发现，一共有两处使用了这个 method 对象：。getAnnotations()

smaillift / 0评论 2019-06-27

Retrofit源码分析二 代理模式

Retrofit源码分析二 代理模式上一节我们讲了一些Retrofit的概览，这一节我们主要来说一下代理模式。有同学可能要问，这不是Retrofit的源码分析吗，怎么都第二节了还不分析源码呢？其实Retrofit这个框架中应用了很多的设计模式，其中最重要

kcstrong / 0评论 2019-06-27

Retrofit源码分析一 概览

Retrofit源码分析一 概览Retrofit的本质和与Okhttp的关系 说到Retrofit，免不了要提起Okhttp，因为二者通常是绑定到一起使用的。二者都是Squire公司的开源框架，Retrofit并不能脱离OKhttp，因为底层的网络

霸气的名字 / 0评论 2019-06-27

Rxjava Retrofit App

Retrofit+RxJava+Dagger2 开源练手小项目 - Gan 物妹干货集中营 Android 客户端：运用 Dagger2+Retrofit2+RxJava 所制作的一个关于干货分享的开源项目，API 接口由 gank.io 提供，欢迎 F

霸气的名字 / 0评论 2019-06-26

Android 学习资料

安卓开发终极指南: 50 多个初高级开发资源（译）我仍记得几年前刚开始进入 Android 开发这个广阔而又神秘的世界时，手足无措的样子。为了帮助像我这样的开发者，我整理了一份比较全的学习资料，对几乎所有开发者都有用，不管是初学者还是经验丰富的老油条。本文

蓝蓝的天 / 0评论 2019-06-26

Android设计模式、框架

急速开发系列——RxJava 实战技巧大全这几天一直看《激荡三十年》，感觉非常不错。这篇文章本身并不想写，总觉得没什么含量, 后面写着写着，发现其中的有些点还是非常有意思的，因此这篇文章的重点在 rxjava 使用场景说明及 rxjava 内存优化上。rx

csclmf / 0评论 2019-06-26

优秀开源

2016 年末，腾讯，百度，华为，搜狗和滴滴面试题汇总2016 年未，腾讯，百度，华为，搜狗和滴滴面试题汇总。自定义 viewgroup+viewdraghelper 仿探探卡片式滑动自定义 viewgroup+viewdraghelper 仿探探卡片式滑

smaillift / 0评论 2019-06-26

Java进阶之路

周月切换日历一个可以进行周月切换的日历，左右滑动的切换月份，上下滑动可以进行周，月不同的视图切换，可以进行事件的标记，以及节假日的显示，功能丰富。Android鬼点子-如此Q弹！设计的很漂亮做出来有点差强人意系列。你所不知的TARS，却帮阅文集团完成技术架

smaillift / 0评论 2019-06-26

有用的框架级的东西

可以通过输入的数据以及可设置的颜色、画笔大小等属性方便的创建图表。Realm，为移动设备而生替代 SQLite 和 Core Data。为你省下数周的时间和数千行的代码，帮你创造出更棒的用户体验。2017 年初你绝对想尝试的 25 个新安卓库 这是一份 2

霸气的名字 / 0评论 2019-06-26

聊聊 Android 的网络请求框架 Retrofit 2 + okhttp 3

工作中跟客户端沟通时产生了点问题, 记录一下.id=1&name=张三 是调不通的。只能处理 Content-Type 为 application/json 的请求, 需要把参数放在 post 请求体内。解决后端没有找到优雅的解决方式, 被迫修改接

Palingenesis / 0评论 2019-06-26

Android网络框架

Android OKHttp3.0 以上使用方法Android OKHttp3.0 以上使用方法详解。Retrofit源码解析Retrofit的源码分析将从基本的使用方法入手，分析retrofit的实现方案，以及其中涉及到的一些有趣的技巧。使用 Retro

Miryou / 0评论 2019-06-26

Android常用架构之MVP

MVC由Model、View、Control组成。Model数据模型，提供数据View视图模型，提供视图展示Control控制器，负责控制Model和View通信。View箭头指向Control意为传递数据，那就是Control获取View的数据传递给Mo

Android进阶 / 0评论 2019-06-25

Android MVP+Retrofit(封装)+RxJava实例

RetrofitRetrofit是Square开发的一个Android和java的REST客户端库。这两天工作不是很忙，写了一个当前流行的Android MVP+Retrofit(封装)+RxJava实例，mvp和retrofit我就不详细讲的，以后会详细

xuweinet / 0评论 2019-06-21

RxEasyHttp网络库简介（一）

本库就不介绍Retrofit和Rxjava的用法。为什么会封装此库？在使用retrofit来请求网络的时候，项目的需求越来越多，api也随之越来越多，一个普通的应用api一般也在100+左右。如果把这些api放在一个ApiService内会很臃肿，不利于查

laibowon / 0评论 2019-06-21

完整app - 收藏集 - 掘金

Android 实践：做一款新闻 APP - Android - 掘金跟代码相关的工作，大多唯手熟尔，所以这里花了点时间做了款简易版的新闻 APP，虽然都是些基础的内容，不过还是可以加深自己对部分代码的理解。至少，可以加深自己的记忆 ...高仿全民直播 -

xzw / 0评论 2019-06-21

网络请求 - 收藏集 - 掘金

Retrofit+RxJava 简单封装 - Android - 掘金本文对Retrofit+RxJava的使用进行简单封装，简化使用。请求结果统一封装成HttpResult类，并利用泛型对不通结果统一处理。基于RxJava2+Retrofit+RxCac

OliverLau / 0评论 2019-06-21

android使用retrofit

// Creates the json object which will manage the information received. // Register an adapter to manage the date types as long v

总Li / 0评论 2019-06-20

新建Android工程需要的开源项目

网络框架 retrofit 结合okhttpRetrofit很有创意的一款开源网络框架，让用户自定义接口，并使用其提供的注解，对接口进行解析和调用，是Square旗下的产品之一;动态代理和反射。其实Retrofit无非就是让用户创建接口，使用自己指定的规则

darongzi / 0评论 2019-06-20

如何对 Android 库进行依赖管理？

Android 开发人员为项目选择库的时候，考虑的因素不仅仅是功能、可用性、性能、文档丰富度和技术支持情况。他们还关心库的大小，以及要添加的方法数量。因为项目越大，依赖也越多，要把应用的方法数量控制在65k 以下，开发人员感觉很有压力。另外，对于非发行版项

xuweinet / 0评论 2019-06-20

Android GitHub 常用开源框架汇总

现在 GitHub 上流行的开源库极大地节省了开发者从 0 开发的时间，很多公司和个人都在 GitHub 上开源自己的项目，今天我们就来整理一下 Android 开发中一些非常流行的库，也是我们必须掌握的，这样可以使我们在使用到时快速的查找到，这里的总

doomvsjing / 0评论 2019-06-11

SocketTimeoutException android retrofit

解决办法：把socket的超时时间设置的长一些。

laibowon / 0评论 2017-11-27

Android 教你一步步搭建MVP+Retrofit+RxJava网络请求框架

MVP其实就是一种项目的整体框架，能让你的代码变得更加简洁，说起框架大家可能还会想到MVC、MVVM。这时候Presenter这个继父来到了这个家庭。Presenter对Activity说，我来了，以后你就别这么辛苦了，你就好好打理好View这个家，我专门

zhangjp / 0评论 2017-10-17

retrofit使用SimpleXmlConverterFactory

.build();String baseUrl = "you url!!!";.build();MovieService movieService = retrofit.create(MovieService.class);//

总Li / 0评论 2017-04-18

Android开发之Retrofit+RxJava的使用

Retrofit是Square公司开发的一款针对Android网络请求的一个当前很流行的网络请求库。Call<解析实体类>getInfo1(); @Query String key用于接口键值对类型参数。Call<UserInfo>

firefoxwyw / 0评论 2017-04-18

retrofit rxjava android 封装 使用

捐助开发者在兴趣的驱动下,写一个免费的东西，有欣喜，也还有汗水，希望你喜欢我的作品，同时也能支持一下。

ccccsky / 0评论 2017-04-12

使用聚合数据的接口进行的RxAndroid学习

例子比较简单，没事使用什么复杂的操作符。Api可以去聚合数据官网申请。

kangtingting0 / 0评论 2016-10-09

Android Retrofit的使用

Retrofit分析-漂亮的解耦套路 特别是课时5 讲的很不错Retrofit分析-经典设计模式案例这两篇文章都是stay写的，觉得真心赞。当然我也不重复他文章里面的内容了，读者们完全可以直接看他的文章。当然我写这篇文章，主要想自我总结下，谈谈自己的认识

霸气的名字 / 0评论 2016-08-22

围观：开发者不容错过的十二大Android开发资源

借着周一这个新一周工作的开始，DEV资讯小编在这里给各位Android开发者介绍的资源包括工具、库和网站等。有效地利用它们，将有助于减轻我们的工作量，提高我们的工作效率。

ChaoYoung / 0评论 2015-07-24