AnliaLee
AnliaLee

Android 网络编程：Retrofit源码解析

版权声明：本文为博主原创文章，未经博主允许不得转载
文章分类：Android知识体系 - 网络编程

前言

Retrofit是一个基于OkHttp、遵循RESTful API设计风格的网络请求封装框架，本文将按照其工作流程逐步分析对应的源码（本文使用的Retrofit版本为2.5.0）

源码分析

1. 请求示例

以下是一次简单的请求示例，首先我们需要定义一个接口API，并使用注解描述其中的API方法

public interface ExpressService {
    @GET("query")
    Call get(@Query("type") String type, @Query("postid") String postid);
}

然后是Retrofit的工作流，可以分为三步：

  1. 构建Retrofit对象
  2. 加载API方法配置，生成请求执行器Call
  3. 使用Call对象执行请求，处理响应数据
public void asyncGet() {
    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://www.kuaidi100.com/")
            .build();

    ExpressService expressService = retrofit.create(ExpressService.class);
    Call call = expressService.get("ems", "11111111");

    call.enqueue(new Callback() {
        @Override
        public void onResponse(Call call, Response response) {

        }

        @Override
        public void onFailure(Call call, Throwable t) {

        }
    });
}

下面我们将按照上述过程，分析对应的源码

2. 构建Retrofit对象

本章我们将分析Retrofit对象构建的过程，以下是对应的示例代码

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("http://www.kuaidi100.com/")
        .build();

2.1 Retrofit类的成员变量

首先来看Retrofit类声明了哪些成员变量

public final class Retrofit {
    private final Map> serviceMethodCache = new ConcurrentHashMap<>();

    final okhttp3.Call.Factory callFactory;
    final HttpUrl baseUrl;
    final List converterFactories;
    final List callAdapterFactories;
    final @Nullable Executor callbackExecutor;
    final boolean validateEagerly;

    ...
}

  • serviceMethodCache：serviceMethodCache是一个ConcurrentHashMap类型的Map集合，因此它支持并发操作且线程安全，其存储对象是ServiceMethod。ServiceMethod我们可以理解是API方法的配置器以及代理中转站，具体内容会在后文进行分析

  • callFactory：callFactory就是生产请求执行器的工厂（Call.Factory），Retrofit中默认的请求执行器工厂是OkHttpClient。如果我们没有设置自定义的请求执行器工厂，那么就会在构建Retrofit对象的过程中为我们创建一个OkHttpClient实例

  • baseUrl：API接口基地址的封装对象，类型为HttpUrl

  • converterFactories：数据转换器工厂（Converter.Factory）的集合，该工厂的产品数据转换器（Converter）作用是对请求与响应数据进行序列化和反序列化

  • callAdapterFactories：请求适配器工厂（CallAdapter.Factory）的集合，该工厂的产品请求适配器（CallAdapter）用于改变执行请求的方式，例如我们可以通过添加支持RxJava的请求适配器，将默认执行请求的方式改为RxJava调用链的方式

  • callbackExecutor：回调执行器，主要作用是处理请求回调，例如将回调所在线程从子线程切换至主线程

  • validateEagerly：是否提前加载API方法配置的标志位

2.2 构建Builder

Retrofit对象通过建造者模式进行构建，我们来看下Builder是如何初始化的

public static final class Builder {
    private final Platform platform;
    ...

    Builder(Platform platform) {
        this.platform = platform;
    }

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

我们看见Builder的构造方法需要传入Platform对象，它的主要作用是根据运行平台为Retrofit提供默认的配置方法、工厂类或者工厂类的集合。Platform可以通过Platform.get()方法获取实例，我们来看下方法相关源码

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

调用Platform.get()方法获取的是静态成员变量PLATFORM，PLATFORM则通过findPlatform()方法生成

findPlatform()主要通过是否能查找到指定的类来判断当前Retrofit运行的平台，如果是运行在Android平台，则返回Platform.Android的实例；如果是Java平台，则返回Platform.Java8的实例；如果两者皆非，则返回Platform自身的实例

现在我们是在Android平台下运行Retrofit，所以继续往下看Platform.Android的代码

// Platform
static class Android extends Platform {
    @IgnoreJRERequirement // Guarded by API check.
    @Override
    boolean isDefaultMethod(Method method) {
        if (Build.VERSION.SDK_INT < 24) {
            return false;
        }
        return method.isDefault();
    }

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

    @Override
    List defaultCallAdapterFactories(
            @Nullable Executor callbackExecutor) {
        if (callbackExecutor == null) throw new AssertionError();
        ExecutorCallAdapterFactory executorFactory = new ExecutorCallAdapterFactory(callbackExecutor);
        return Build.VERSION.SDK_INT >= 24
                ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
                : singletonList(executorFactory);
    }

    @Override
    int defaultCallAdapterFactoriesSize() {
        return Build.VERSION.SDK_INT >= 24 ? 2 : 1;
    }

    @Override
    List defaultConverterFactories() {
        return Build.VERSION.SDK_INT >= 24
                ? singletonList(OptionalConverterFactory.INSTANCE)
                : Collections.emptyList();
    }

    @Override
    int defaultConverterFactoriesSize() {
        return Build.VERSION.SDK_INT >= 24 ? 1 : 0;
    }

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

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

Platform.Android中主要定义了以下内容：

  • 默认的回调执行器MainThreadExecutor，负责将请求回调的运行线程切换为主线程
  • 默认的请求适配器工厂集合，当Android版本大于等于24时，集合依次添加了两个适配器工厂CompletableFutureCallAdapterFactory与ExecutorCallAdapterFactory；当Android版本小于24时，则为只存储了ExecutorCallAdapterFactory的单元素集合
  • 默认的数据转换器工厂集合，当Android版本大于等于24时，返回的是只储存了OptionalConverterFactory的单元素集合；当系统版本小于24时，返回的是一个空集合

以上平台默认的内容都会在Builder调用build()完成构建时用到，具体的我们待会再细说，现在先来看下Builder主要提供了哪些方法

// Retrofit.Builder
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;
}

public Builder baseUrl(String baseUrl) {
    checkNotNull(baseUrl, "baseUrl == null");
    return baseUrl(HttpUrl.get(baseUrl));
}

public Builder addConverterFactory(Converter.Factory factory) {
    converterFactories.add(checkNotNull(factory, "factory == null"));
    return this;
}

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

public Builder callbackExecutor(Executor executor) {
    this.callbackExecutor = checkNotNull(executor, "executor == null");
    return this;
}

public Builder validateEagerly(boolean validateEagerly) {
    this.validateEagerly = validateEagerly;
    return this;
}

简单介绍一下这些方法的作用

  • client()：添加自定义配置的OkHttpClient
  • callFactory()：添加自定义的请求执行器工厂
  • baseUrl()：添加API接口的基地址
  • addConverterFactory()：添加自定义的数据转换器
  • addCallAdapterFactory()：添加自定义的请求适配器
  • callbackExecutor()：添加自定义的回调执行器
  • validateEagerly()：设置是否预加载API方法的标志位

完成Retrofit的构建最终需要调用Builder.build()方法，来看下源码

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

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

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

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

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

    // Add the built-in converter factory first. This prevents overriding its behavior but also
    // ensures correct behavior when using converters that consume all types.
    converterFactories.add(new BuiltInConverters());
    converterFactories.addAll(this.converterFactories);
    converterFactories.addAll(platform.defaultConverterFactories());

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

build()方法完成了以下工作：

  • 当用户没有添加自定义的CallFactory时默认使用OkHttpClient
  • 当用户没有添加自定义的CallbackExecutor时默认使用Platform.defaultCallbackExecutor()，即MainThreadExecutor
  • 为callAdapterFactories创建一个保护性拷贝，然后将Platform里定义的所有请求适配器添加进来
  • 为converterFactories创建了一个保护性拷贝，然后依次将内置的转换器工厂BuiltInConverters、所有自定义的转换器工厂、Platform里定义的所有转换器工厂添加进来

完成上述工作后将相关参数传入Retrofit的构造方法中即完成构建Retrofit对象的工作。其中需要注意的是converterFactories和callAdapterFactories都变成了不可修改的List集合，这意味着后续我们不可以再更改这两个集合中的内容了

至此Retrofit对象构建的过程就分析完了，下一章我们将分析API接口方法加载配置以及转换为请求执行器的过程

2.3 本章小结

这一章我们分析了构建Retrofit对象的过程，过程中主要完成了以下工作：

  • 创建内置的成员实例以及工厂集合，用来维持基础的功能
  • 通过构建方法保存用户自定义的内容，例如自定义的数据转换器、请求适配器、回调执行器等等，用来运行扩展的功能

3. 加载API方法配置

本章我们将分析API方法加载配置的过程，以下是对应的示例代码

// 请求示例
ExpressService expressService = retrofit.create(ExpressService.class);
Call call = expressService.get("ems", "11111111");

Retrofit对象构建完毕后，下一步是通过Retrofit.create(Class service)方法实现API接口，该方法的代码如下

// Retrofit
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();
                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);
                    }
                    if (platform.isDefaultMethod(method)) {
                        return platform.invokeDefaultMethod(method, service, proxy, args);
                    }
                    return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
                }
            });
}

该方法主要是通过运用动态代理的方式为请求接口生成一个代理对象，我们对接口所有方法的调用都会转发到代理对象中。现在我们一步步分析是如何完成整个动态代理的过程的

3.1 API方法的校验和预加载

首先是调用Utils.validateServiceInterface(Class service)对接口类进行校验

// Utils
static  void validateServiceInterface(Class 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.");
    }
}

这里规定我们传入的参数必须是一个接口类，并且该接口不能继承其他的接口

回到create方法中，接下来会通过标志位validateEagerly来决定是否提前为API方法加载相应的配置

// Retrofit.create
if (validateEagerly) {
    eagerlyValidateMethods(service);
}

我们知道动态代理是在接口方法被调用时才会生效的，这类似于懒加载策略，Retrofit默认采用的就是这种方式，而我们可以通过Retrofit.Builder.validateEagerly()方法将validateEagerly标志设置为true，Retrofit就会调用eagerlyValidateMethods()提前为接口方法加载配置

eagerlyValidateMethods()源码如下

// Retrofit
private void eagerlyValidateMethods(Class service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
        if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
            loadServiceMethod(method);
        }
    }
}

具体逻辑为遍历接口中的方法（method），然后判断方法是否为默认方法或静态方法（接口的默认方法和静态方法都是Java8新增的特性），若不是则调用loadServiceMethod()为接口方法加载相应的配置。loadServiceMethod()方法的逻辑我们待会再细说，现在继续分析Retrofit.create()方法

经过预加载的逻辑后，下一步就是执行动态代理相关的逻辑

3.2 动态代理中的校验

// Retrofit.create
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);
                }
                if (platform.isDefaultMethod(method)) {
                    return platform.invokeDefaultMethod(method, service, proxy, args);
                }
                return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
            }
        });

首先依然是对接口方法的校验，会判断此次调用的方法是否为Object对象的方法（非接口方法），若是则正常调用，不进行任何代理操作。然后判断该方法是否为默认方法，若是则调用Platform对象提供的配置方法invokeDefaultMethod()并返回。invokeDefaultMethod()在Android平台下会抛出UnsupportedOperationException异常，具体代码如下

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

执行完所有的校验工序之后，最终依然是调用loadServiceMethod()开始加载API方法的配置，我们来看下源码

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

方法的逻辑非常简单，功能可以分为两部分来看

  • 使用retrofit2.ServiceMethod处理接口方法
  • 将处理后的结果缓存至serviceMethodCache中，这样下次再调用该接口方法时就无需重复处理了

继续往下看ServiceMethod的代码

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

ServiceMethod是一个抽象类，它只有两个方法，一个是invoke()，这是一个抽象方法，具体的逻辑由ServiceMethod的子类实现，当调用接口方法时会被动态代理到这个方法中

另一个方法是parseAnnotations()，这是一个静态方法，它的功能如下

  • 创建RequestFactory实例，具体方式为调用RequestFactory.parseAnnotations()方法
  • 校验接口方法的返回类型。Retrofit会判断该返回类型是否属于无法处理的类型（包含类型变量、通配符的返回类型以及void类型），若接收到这些返回类型时会直接抛出异常
  • 继续调用HttpServiceMethod.parseAnnotations()完成接口方法后续的配置加载工作

这一部分最主要的关注点是RequestFactory。RequestFactory是请求体对象（okhttp3.Request）的工厂类，我们可以调用RequestFactory.create()创建一个请求体的实例，下面我们就来详细分析生成RequestFactory的过程

3.3 生成RequestFactory

以下是与RequestFactory.parseAnnotations()方法相关的代码

final class RequestFactory {
    static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
        return new Builder(retrofit, method).build();
    }
    ...
    RequestFactory(Builder builder) {
        method = builder.method;
        baseUrl = builder.retrofit.baseUrl;
        httpMethod = builder.httpMethod;
        relativeUrl = builder.relativeUrl;
        headers = builder.headers;
        contentType = builder.contentType;
        hasBody = builder.hasBody;
        isFormEncoded = builder.isFormEncoded;
        isMultipart = builder.isMultipart;
        parameterHandlers = builder.parameterHandlers;
        isKotlinSuspendFunction = builder.isKotlinSuspendFunction;
    }
    ...
    static final class Builder {
        ...
        Builder(Retrofit retrofit, Method method) {
            this.retrofit = retrofit;
            this.method = method;
            this.methodAnnotations = method.getAnnotations();
            this.parameterTypes = method.getGenericParameterTypes();
            this.parameterAnnotationsArray = method.getParameterAnnotations();
        }

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

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

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

            int parameterCount = parameterAnnotationsArray.length;
            parameterHandlers = new ParameterHandler[parameterCount];
            for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
                parameterHandlers[p] =
                        parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
            }

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

            return new RequestFactory(this);
        }

        ...
    }
}

RequestFactory同样通过建造者模式来构建实例，我们可以看到Builder.build()方法中有许多状态位的校验逻辑，主要作用是当用户在创建请求接口中错误地使用注解或配置参数时，可以抛出相应的异常告知用户。这部分的细节就不一一查看了，感兴趣的同学可以自行研究

这里我们最主要关注的地方有两点：一是遍历接口方法的注解，然后通过Builder.parseMethodAnnotation()方法解析注解的过程；二是遍历方法的参数，然后通过Builder.parseParameter()方法解析参数的过程

3.3.1 解析方法注解

首先来看第一点，parseMethodAnnotation()的代码如下

// RequestFactory.Builder
private void parseMethodAnnotation(Annotation annotation) {
    if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
    } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
    } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
    } else if (annotation instanceof PATCH) {
        parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
    } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
    } else if (annotation instanceof PUT) {
        parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
    } else if (annotation instanceof OPTIONS) {
        parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
    } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
    } else if (annotation instanceof retrofit2.http.Headers) {
        String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
        if (headersToParse.length == 0) {
            throw methodError(method, "@Headers annotation is empty.");
        }
        headers = parseHeaders(headersToParse);
    } else if (annotation instanceof Multipart) {
        if (isFormEncoded) {
            throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isMultipart = true;
    } else if (annotation instanceof FormUrlEncoded) {
        if (isMultipart) {
            throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isFormEncoded = true;
    }
}

这里有大量的判断分支语句，我们可以按照注解的功能分成三类来看。第一类注解主要是描述HTTP方法的，例如@DELETE、@GET、@POST等，解析方法为parseHttpMethodAndPath()，来看下源码

// RequestFactory.Builder
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
    if (this.httpMethod != null) {
        throw methodError(method, "Only one HTTP method is allowed. Found: %s and %s.",
                this.httpMethod, httpMethod);
    }
    this.httpMethod = httpMethod;
    this.hasBody = hasBody;

    if (value.isEmpty()) {
        return;
    }

    // Get the relative URL path and existing query string, if present.
    int question = value.indexOf('?');
    if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
            throw methodError(method, "URL query string \"%s\" must not have replace block. "
                    + "For dynamic query parameters use @Query.", queryParams);
        }
    }

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

这个方法有三个参数

  • httpMethod：表示描述HTTP方法的注解的名称
  • value：注解包含的内容，例如@GET("query?type=ems&postid=11111111")中括号里的内容实际上就是指服务端接口Url的资源路径和查询参数部分。这些内容可以通过调用这一系列注解的value()方法获取，这是在定义注解时设置的
  • hasBody：该HTTP方法是否携带请求正文数据

知道了每个参数的含义，后面的代码就好理解了，流程是这样的：首先会对一个接口方法是否同时设置了多个HTTP方法注解进行了校验；然后校验value是否为空，为空就不需要继续解析了，因为这部分内容不是在方法注解里设置就是在方法参数中设置，这里没有，那就直接交给后面解析参数时再去处理；若value不为空，则校验查询参数部分是否符合要求，符合要求则继续解析查询参数字符串得到参数集合，不符合则抛出异常，这些操作主要通过Java正则解析相关的Matcher类完成的，就不细说了

回到RequestFactory.Builder.parseMethodAnnotation()，我们来看第二类注解。第二类注解只有@Headers一个，负责设置请求头信息，解析的方法为Builder.parseHeaders()，这部分内容比较简单，就不展开了

第三类注解主要负责描述请求报文数据的类型，有@Multipart和@FormUrlEncoded两种，但因为这两种类型都需要配合方法参数的注解使用，所以这里的处理过程只是简单地校验两者不重复设置就行

实际上方法注解中还有第四类，那就是@Streaming，这是用于描述响应正文数据的，因此Retrofit将它的处理过程放到了后面配置响应内容相关的部分再进行

至此解析方法注解的部分我们就分析完了，接下来看解析参数的部分

3.3.2 解析方法参数

解析方法参数对应的方法是Builder.parseParameter()，代码如下

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

            if (annotationAction == null) {
                continue;
            }

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

            result = annotationAction;
        }
    }
    ...
    return result;
}

这里的核心逻辑是通过parseParameterAnnotation()方法解析参数注解生成ParameterHandler对象，同时规定一个参数只能设置一个Retrofit定义的注解

ParameterHandler是一个抽象类，它的子类封装了参数的数据和数据的处理过程，并且和不同注解类型的参数一一对应，例如子类ParameterHandler.Query封装了@Query注解的参数，ParameterHandler.Field则封装了@Field注解的参数

作为参数的处理器，ParameterHandler可以在构建请求体对象时利用专属的参数数据转换器将数据转换成请求需要的格式，这里我们以ParameterHandler.Query为例进行分析

// ParameterHandler
static final class Query extends ParameterHandler {
    private final String name;
    private final Converter valueConverter;
    private final boolean encoded;

    Query(String name, Converter valueConverter, boolean encoded) {
        this.name = checkNotNull(name, "name == null");
        this.valueConverter = valueConverter;
        this.encoded = encoded;
    }

    @Override
    void apply(RequestBuilder builder, @Nullable T value) throws IOException {
        if (value == null) return; // Skip null values.

        String queryValue = valueConverter.convert(value);
        if (queryValue == null) return; // Skip converted but null values

        builder.addQueryParam(name, queryValue, encoded);
    }
}

ParameterHandler.Query有三个成员属性，其中name和encoded对应了@Query定义的属性

@Documented
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Query {
  /** The query parameter name. */
  String value();

  /**
   * Specifies whether the parameter {@linkplain #value() name} and value are already URL encoded.
   */
  boolean encoded() default false;
}

而valueConverter指的就是参数数据转换器，它可以通过调用convert()方法进行数据转换。参数处理的过程都放在Query.apply()方法中，当构建请求体需要此参数的数据时，就会调用apply()方法，然后通过传入的RequestBuilder引用设置数据

ParameterHandler的分析就到这，其他参数处理器就不一一分析了，因为套路基本上都是一样的，现在我们继续分析parseParameterAnnotation()方法是如何生成ParameterHandler的

// RequestFactory.Builder
@Nullable
private ParameterHandler parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {
    if (annotation instanceof Url) {
        ...
        return new ParameterHandler.RelativeUrl(method, p);
    } else if (annotation instanceof Path) {
        ...
        Converter converter = retrofit.stringConverter(type, annotations);
        return new ParameterHandler.Path<>(method, p, name, converter, path.encoded());
    } else if (annotation instanceof Query) {
        ...
        if (Iterable.class.isAssignableFrom(rawParameterType)) {
            ...
            Converter converter = retrofit.stringConverter(iterableType, annotations);
            return new ParameterHandler.Query<>(name, converter, encoded).iterable();
        } else if (rawParameterType.isArray()) {
            ...
            Converter converter = retrofit.stringConverter(arrayComponentType, annotations);
            return new ParameterHandler.Query<>(name, converter, encoded).array();
        } else {
            Converter converter = retrofit.stringConverter(type, annotations);
            return new ParameterHandler.Query<>(name, converter, encoded);
        }
    } else if (annotation instanceof QueryName) {
        ...
        if (Iterable.class.isAssignableFrom(rawParameterType)) {
            ...
            Converter converter = retrofit.stringConverter(iterableType, annotations);
            return new ParameterHandler.QueryName<>(converter, encoded).iterable();
        } else if (rawParameterType.isArray()) {
            ...
            Converter converter = retrofit.stringConverter(arrayComponentType, annotations);
            return new ParameterHandler.QueryName<>(converter, encoded).array();
        } else {
            Converter converter = retrofit.stringConverter(type, annotations);
            return new ParameterHandler.QueryName<>(converter, encoded);
        }
    } else if (annotation instanceof QueryMap) {
        ...
        Converter valueConverter = retrofit.stringConverter(valueType, annotations);
        return new ParameterHandler.QueryMap<>(method, p,
                valueConverter, ((QueryMap) annotation).encoded());
    } else if (annotation instanceof Header) {
        ...
        if (Iterable.class.isAssignableFrom(rawParameterType)) {
            ...
            Converter converter = retrofit.stringConverter(iterableType, annotations);
            return new ParameterHandler.Header<>(name, converter).iterable();
        } else if (rawParameterType.isArray()) {
            ...
            Converter converter = retrofit.stringConverter(arrayComponentType, annotations);
            return new ParameterHandler.Header<>(name, converter).array();
        } else {
            Converter converter = retrofit.stringConverter(type, annotations);
            return new ParameterHandler.Header<>(name, converter);
        }
    } else if (annotation instanceof HeaderMap) {
        ...
        Converter valueConverter = retrofit.stringConverter(valueType, annotations);
        return new ParameterHandler.HeaderMap<>(method, p, valueConverter);
    } else if (annotation instanceof Field) {
        ...
        if (Iterable.class.isAssignableFrom(rawParameterType)) {
            ...
            Converter converter = retrofit.stringConverter(iterableType, annotations);
            return new ParameterHandler.Field<>(name, converter, encoded).iterable();
        } else if (rawParameterType.isArray()) {
            ...
            Converter converter = retrofit.stringConverter(arrayComponentType, annotations);
            return new ParameterHandler.Field<>(name, converter, encoded).array();
        } else {
            Converter converter = retrofit.stringConverter(type, annotations);
            return new ParameterHandler.Field<>(name, converter, encoded);
        }
    } else if (annotation instanceof FieldMap) {
        ...
        Converter valueConverter = retrofit.stringConverter(valueType, annotations);
        return new ParameterHandler.FieldMap<>(method, p, valueConverter, ((FieldMap) annotation).encoded());
    } else if (annotation instanceof Part) {
        ...
        String partName = part.value();
        if (partName.isEmpty()) {
            if (Iterable.class.isAssignableFrom(rawParameterType)) {
                ...
                return ParameterHandler.RawPart.INSTANCE.iterable();
            } else if (rawParameterType.isArray()) {
                ...
                return ParameterHandler.RawPart.INSTANCE.array();
            } else if (MultipartBody.Part.class.isAssignableFrom(rawParameterType)) {
                return ParameterHandler.RawPart.INSTANCE;
            } else {
                ...
            }
        } else {
            Headers headers =
                    Headers.of("Content-Disposition", "form-data; name=\"" + partName + "\"",
                            "Content-Transfer-Encoding", part.encoding());

            if (Iterable.class.isAssignableFrom(rawParameterType)) {
                ...
                Converter converter =
                        retrofit.requestBodyConverter(iterableType, annotations, methodAnnotations);
                return new ParameterHandler.Part<>(method, p, headers, converter).iterable();
            } else if (rawParameterType.isArray()) {
                ...
                Converter converter =
                        retrofit.requestBodyConverter(arrayComponentType, annotations, methodAnnotations);
                return new ParameterHandler.Part<>(method, p, headers, converter).array();
            } else if (MultipartBody.Part.class.isAssignableFrom(rawParameterType)) {
                ...
            } else {
                Converter converter =
                        retrofit.requestBodyConverter(type, annotations, methodAnnotations);
                return new ParameterHandler.Part<>(method, p, headers, converter);
            }
        }
    } else if (annotation instanceof PartMap) {
        ...
        Converter valueConverter =
                retrofit.requestBodyConverter(valueType, annotations, methodAnnotations);
        return new ParameterHandler.PartMap<>(method, p, valueConverter, partMap.encoding());
    } else if (annotation instanceof Body) {
        ...
        Converter converter = retrofit.requestBodyConverter(type, annotations, methodAnnotations);
        return new ParameterHandler.Body<>(method, p, converter);
    } else if (annotation instanceof Tag) {
        ...
        return new ParameterHandler.Tag<>(tagType);
    }
    return null; // Not a Retrofit annotation.
}

由于方法注解很多，parseParameterAnnotation()代码非常的多，因此这里我只把核心的内容展示给大家。parseParameterAnnotation()解析每个参数的过程大致可以总结为三步

  • 校验参数是否设置正确，错误则抛出异常告知用户
  • 生成特定的参数数据转换器
  • 返回对应的ParameterHandler实例

校验过程就不细说了，感兴趣的同学可以自行查阅源码，我们重点关注参数数据转换器是如何生成的。从上面的源码可以看出生成转换器的方式主要有两种，一种是通过Retrofit.stringConverter()方法生成，这类转换器转换出来的数据类型为String；另一种则通过Retrofit.requestBodyConverter()方法生成，对应的转换结果就是请求实体类型RequestBody

先来看Retrofit.stringConverter()

// Retrofit
public  Converter stringConverter(Type type, Annotation[] annotations) {
    checkNotNull(type, "type == null");
    checkNotNull(annotations, "annotations == null");

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

    // Nothing matched. Resort to default converter which just calls toString().
    //noinspection unchecked
    return (Converter) BuiltInConverters.ToStringConverter.INSTANCE;
}

这里的代码主要完成了以下工作：按顺序遍历数据转换器工厂集合converterFactories，到符合要求的转换器工厂，即在实现接口方法Converter.Factory.stringConverter()时不能返回null。这里有一点细节需要注意，在遍历过程中只要发现符合的转换器工厂就会返回，因此转换器工厂添加的顺序决定了它们的优先级，越早添加的优先级越高，就可以优先被征调。还记得我们在构建Retrofit对象时添加的转换器吗？现在我们重新来回顾一下加深记忆

// Retrofit.Builder.build()
converterFactories.add(new BuiltInConverters());// 添加Retrofit内置的数据转换器，优先级最高
converterFactories.addAll(this.converterFactories);// 按顺序添加所有自定义的数据转换器
converterFactories.addAll(platform.defaultConverterFactories());// 添加针对对应运行平台设置的数据转换器工厂

当内置转换器工厂BuiltInConverters以及集合中其他转换器工厂都不符合要求时，则返回特定的转换器BuiltInConverters.ToStringConverter，其代码如下

// BuiltInConverters
static final class ToStringConverter implements Converter {
    static final ToStringConverter INSTANCE = new ToStringConverter();

    @Override
    public String convert(Object value) {
        return value.toString();
    }
}

代码很简单就不细说了，接下来是Retrofit.requestBodyConverter()

public  Converter requestBodyConverter(Type type,
                                                          Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
    return nextRequestBodyConverter(null, type, parameterAnnotations, methodAnnotations);
}

public  Converter nextRequestBodyConverter(
        @Nullable Converter.Factory skipPast, Type type, Annotation[] parameterAnnotations,
        Annotation[] methodAnnotations) {
    checkNotNull(type, "type == null");
    checkNotNull(parameterAnnotations, "parameterAnnotations == null");
    checkNotNull(methodAnnotations, "methodAnnotations == null");

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

    // 没有找到符合要求的请求数据转换器，抛出IllegalArgumentException异常
    ...
}

和之前的处理逻辑差别不大，不过这次调用的方法为Converter.Factory.requestBodyConverter()，而且我们发现BuiltInConverters实现了该接口方法，代码如下

// BuiltInConverters
@Override
public @Nullable Converter requestBodyConverter(Type type,
                                               Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    if (RequestBody.class.isAssignableFrom(Utils.getRawType(type))) {
        return RequestBodyConverter.INSTANCE;
    }
    return null;
}

这里返回了针对RequestBody类型参数的转换器BuiltInConverters.RequestBodyConverter

// BuiltInConverters
static final class RequestBodyConverter implements Converter {
    static final RequestBodyConverter INSTANCE = new RequestBodyConverter();

    @Override
    public RequestBody convert(RequestBody value) {
        return value;
    }
}

可以看见RequestBodyConverter并没有对参数数据进行任何处理，因此该转换器最主要的作用是拦截类型为RequestBody的参数

至此我们就完了解析方法参数的全部工作，也成功生成了请求体对象工厂RequestFactory。

3.4 生成CallAdapter

HttpServiceMethod是ServiceMethod的子类，它的代码有点多，我们直接挑重点看。首先是parseAnnotations()方法

// HttpServiceMethod
static  HttpServiceMethod parseAnnotations(
        Retrofit retrofit, Method method, RequestFactory requestFactory) {
    CallAdapter callAdapter = createCallAdapter(retrofit, method);
    Type responseType = callAdapter.responseType();

    ...

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

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    return new HttpServiceMethod<>(requestFactory, callFactory, callAdapter, responseConverter);
}

这里主要做了下面这些工作

  • 通过createCallAdapter()方法生成请求适配器callAdapter
  • 通过callAdapter.responseType()方法获取响应数据的类型responseType
  • 通过createResponseConverter()方法生成响应体（Response）的数据转换器responseConverter
  • 通过上述实例构建HttpServiceMethod对象

首先我们分析生成请求适配器CallAdapter的过程，以下是createCallAdapter()方法的代码

// HttpServiceMethod
private static  CallAdapter createCallAdapter(
        Retrofit retrofit, Method method) {
    Type returnType = method.getGenericReturnType();
    Annotation[] annotations = method.getAnnotations();
    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
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 = 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;
        }
    }

    // 当所有适配器都不符合要求时抛出IllegalArgumentException异常
    ...
}

可以发现套路基本上是一样的，具体方式为遍历callAdapterFactories找到符合要求的请求适配器后返回，验证的方法为CallAdapter.Factory.get()。通过上一章的分析我们知道，除了用户添加的自定义的请求适配器工厂以外，Retrofit还内置了两种默认的适配器工厂：CompletableFutureCallAdapterFactory（系统版本大于等于24时生效）和ExecutorCallAdapterFactory。这里我们只以ExecutorCallAdapterFactory为例进行分析，来看下源码

final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
    final Executor callbackExecutor;

    ExecutorCallAdapterFactory(Executor callbackExecutor) {
        this.callbackExecutor = callbackExecutor;
    }

    @Override
    public @Nullable
    CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        if (getRawType(returnType) != Call.class) {
            return null;
        }
        final Type responseType = Utils.getCallResponseType(returnType);
        return new CallAdapter>() {
            @Override
            public Type responseType() {
                return responseType;
            }

            @Override
            public Call adapt(Call call) {
                return new ExecutorCallbackCall<>(callbackExecutor, call);
            }
        };
    }
    ...
}
 
  
通过上述代码我们知道，get()方法指定ExecutorCallAdapterFactory的适配目标是返回类型为retrofit2.Call的API方法，其最终返回值是一个新的CallAdapter实例。此外，该CallAdapter实例的adapt()方法生成了retrofit2.Call的子类ExecutorCallbackCall，这实际上是请求执行器的装饰器，具体内容我们在后面用到时再细说，现在继续下一步
 
  
3.5 生成ResponseConverter
 
  
接下来是调用HttpServiceMethod.createResponseConverter()方法生成响应数据转换器（ResponseConverter），我们来看下相关代码
 
  
// HttpServiceMethod
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
public  Converter responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
}

public  Converter nextResponseBodyConverter(
        @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
    checkNotNull(type, "type == null");
    checkNotNull(annotations, "annotations == null");

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

    // 无法找到符合要求的ResponseBodyConverter时抛出IllegalArgumentException异常
    ...
}

 
  
同样这里也是通过遍历转换器工厂集合converterFactories找到符合要求的转换器工厂，验证方法为Converter.Factory.responseBodyConverter()。之前讲过转换器工厂优先级最高的是内置的BuiltInConverters，来看下它的responseBodyConverter()方法
 
  
final class BuiltInConverters extends Converter.Factory {
    ...

    @Override
    public @Nullable Converter responseBodyConverter(
            Type type, Annotation[] annotations, Retrofit retrofit) {
        if (type == ResponseBody.class) {
            return Utils.isAnnotationPresent(annotations, Streaming.class)
                    ? StreamingResponseBodyConverter.INSTANCE
                    : BufferingResponseBodyConverter.INSTANCE;
        }
        if (type == Void.class) {
            return VoidResponseBodyConverter.INSTANCE;
        }
        ...
        return null;
    }
    ...
}

 
  
这里指定BuiltInConverters只能处理类型为okhttp3.ResponseBody以及void的响应体数据。当类型为ResponseBody时，还会判断接口方法是否含有@Streaming注解，然后提供不同的转换器实例。下面我们就看下这三个数据转换器有什么区别吧
 
  
// BuiltInConverters
static final class StreamingResponseBodyConverter implements Converter {
    static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();

    @Override
    public ResponseBody convert(ResponseBody value) {
        return value;
    }
}

static final class BufferingResponseBodyConverter implements Converter {
    static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();

    @Override
    public ResponseBody convert(ResponseBody value) throws IOException {
        try {
            // Buffer the entire body to avoid future I/O.
            return Utils.buffer(value);
        } finally {
            value.close();
        }
    }
}

static final class VoidResponseBodyConverter implements Converter {
    static final VoidResponseBodyConverter INSTANCE = new VoidResponseBodyConverter();

    @Override
    public Void convert(ResponseBody value) {
        value.close();
        return null;
    }
}

 
  
可以看到这三个转换器都实现了Converter接口的convert()方法，这个方法会在后续处理响应数据时调用，现在我们先看下这三个转换器的convert()方法是如何实现的
 
  
     
   
  • StreamingResponseBodyConverter：会将数据流的连接返回给用户，那为什么返回的是数据流的连接而不是数据呢？原因是RessponseBody持有的数据可能会很大，OkHttp并不会将数据直接保存到内存中，实际保存的是数据流的连接，当用户需要时再通过连接从服务端获取数据。因此@Streaming注解适合在执行大文件下载任务的时候使用
    •  
   
  • BufferingResponseBodyConverter：先将响应体数据保存至内存缓冲区中，再返回给用户。这适合在响应体数据较小的场景下使用，也是默认的数据处理方式
    •  
   
  • VoidResponseBodyConverter：当设置返回的响应体数据类型为void时，说明用户无意处理响应的数据，那么直接关闭释放资源即可
    •  
  
 
  
现在回到一开始的请求示例中，我们定义的接口方法是这样的
 
  
public interface ExpressService {
    @GET("query?type=ems&postid=11111111")
    Call get();
}

 
  
这里设置的响应数据类型是ResponseBody，即BuiltInConverters可以处理这个API方法，因此遍历查找转换器工厂的过程到了BuiltInConverters处就被拦截了下来，且由于该接口方法并没有添加@Streaming注解，所以最终HttpServiceMethod.createResponseConverter()构建的响应数据转换器就是BufferingResponseBodyConverter
 
  
3.6 完成API方法的动态代理
 
  
完成所有前置工作后，我们回到Retrofit.create()方法，由之前的分析可知API方法会被动态代理到
 
  
loadServiceMethod(method).invoke(args != null ? args : emptyArgs);

 
  
而loadServiceMethod()最终返回的是HttpServiceMethod的实例，因此我们来看下HttpServiceMethod.invoke()方法的代码
 
  
// HttpServiceMethod
@Override
ReturnT invoke(Object[] args) {
    return callAdapter.adapt(new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
}

 
  
adapt()方法的传参是OkHttpCall的实例，这是Retrofit层的请求执行器，其内部持有真实的请求执行器okhttp3.Call。OkHttpCall作为代理类主要负责Retrofit层与OkHttp层之间交互数据的转换
 
  
此外，从之前的讲解中我们知道adapt()方法的返回结果是ExecutorCallbackCall的实例，因此动态代理API方法最终得到的就是这个实例，其作为OkHttpCall的装饰器，主要负责协同回调执行器为OkHttpCall动态增强回调方面的功能
 
  
至此API方法的动态代理和加载配置的过程就分析完了，下一章我们将分析Retrofit是如何发起请求以及处理响应数据的
 
  
3.7 本章小结
 
  
这一章分析了加载API方法配置的过程，原理是利用动态代理机制，主要完成了以下工作：
 
  
     
   
  • 通过解析方法注解和参数注解生成了【请求对象工厂】以及【参数数据转换器】
    •  
   
  • 通过解析方法返回类型和响应数据类型生成了【请求适配器工厂】、【响应数据转换器工厂】、【请求执行器（装饰器）】
    •  
  
 
  
 
  
4. 请求与响应
 
  
本章我们将分析请求与响应的过程，以下是对应的示例代码
 
  
call.enqueue(new Callback() {
    @Override
    public void onResponse(Call call, Response response) {

    }

    @Override
    public void onFailure(Call call, Throwable t) {

    }
});

 
  
4.1 处理回调
 
  
由上一章我们知道，这里的call实际上是装饰器ExecutorCallbackCall，我们来看下ExecutorCallbackCall.enqueue()方法的代码
 
  
// ExecutorCallAdapterFactory
static final class ExecutorCallbackCall implements Call {
    final Executor callbackExecutor;
    final Call delegate;

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

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

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

    ...
}

 
  
ExecutorCallbackCall有两个成员变量，callbackExecutor与delegate，通过之前的分析我们知道它们分别对应了MainThreadExecutor和OkHttpCall。那么先来分析MainThreadExecutor.execute()方法，该方法在OkHttpCall的请求回调中被调用
 
  
// Platform.Android
static class MainThreadExecutor implements Executor {
    private final Handler handler = new Handler(Looper.getMainLooper());

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

 
  
这里的功能非常好理解，综合之前的代码来看就是将OkHttpCall的请求回调结果发送至主线程。再来看OkHttpCall.enqueue()方法
 
  
// OkHttpCall
@Override
public void enqueue(final Callback callback) {
    okhttp3.Call call;
    call = rawCall = createRawCall();
    ...
    call.enqueue(new okhttp3.Callback() {
        @Override
        public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
            Response response = parseResponse(rawResponse);
            callback.onResponse(OkHttpCall.this, response);
            ...
        }

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

 
  
这里我把核心的代码摘抄出来进行分析，首先是通过createRawCall()方法获取真实的请求执行器
 
  
4.2 生成okhttp3.Call
 
  
// OkHttpCall
private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
    if (call == null) {
        throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
}

 
  
这里有两个需要关注的点，一是调用callFactory.newCall()方法获取真实的请求执行器，callFactory实际上就是OkHttpClient对象的引用，这和我们在OkHttp中生成请求执行器的方法一致；二是通过requestFactory.create()方法获取请求体okhttp3.Request的实例，其中args是通过动态代理API方法拿到的传参。现在我们开始分析生成Request对象的过程
 
  
// RequestFactory
okhttp3.Request create(Object[] args) throws IOException {
    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler[] handlers = (ParameterHandler[]) parameterHandlers;

    int argumentCount = args.length;
    ...
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl,
            headers, contentType, hasBody, isFormEncoded, isMultipart);

    List argumentList = new ArrayList<>(argumentCount);
    for (int p = 0; p < argumentCount; p++) {
        argumentList.add(args[p]);
        handlers[p].apply(requestBuilder, args[p]);
    }

    return requestBuilder.get()
            .tag(Invocation.class, new Invocation(method, argumentList))
            .build();
}
 
  
handlers是参数封装类ParameterHandler的集合，通过apply()方法可以处理参数数据，转换成RequestBuilder需要的格式，然后通过RequestBuilder的引用设置数据，这些数据将在生成Request时用到。先来看下RequestBuilder的构造方法
 
  
// RequestBuilder
RequestBuilder(String method, HttpUrl baseUrl,
               @Nullable String relativeUrl, @Nullable Headers headers, @Nullable MediaType contentType,
               boolean hasBody, boolean isFormEncoded, boolean isMultipart) {
    this.method = method;
    this.baseUrl = baseUrl;
    this.relativeUrl = relativeUrl;
    this.requestBuilder = new Request.Builder();
    this.contentType = contentType;
    this.hasBody = hasBody;

    if (headers != null) {
        requestBuilder.headers(headers);
    }

    if (isFormEncoded) {
        // Will be set to 'body' in 'build'.
        formBuilder = new FormBody.Builder();
    } else if (isMultipart) {
        // Will be set to 'body' in 'build'.
        multipartBuilder = new MultipartBody.Builder();
        multipartBuilder.setType(MultipartBody.FORM);
    }
}

 
  
可以看到我们之前在解析注解、加载API方法配置的过程中生成的属性在这都得到了应用。再来看ParameterHandler.apply()的过程，我们以请求示例中定义的API方法为例，方法参数中使用了@Query注解，对应的参数封装类是Query
 
  
// ParameterHandler
static final class Query extends ParameterHandler {
    private final String name;
    private final Converter valueConverter;
    private final boolean encoded;

    Query(String name, Converter valueConverter, boolean encoded) {
        this.name = checkNotNull(name, "name == null");
        this.valueConverter = valueConverter;
        this.encoded = encoded;
    }

    @Override
    void apply(RequestBuilder builder, @Nullable T value) throws IOException {
        if (value == null) return; // Skip null values.

        String queryValue = valueConverter.convert(value);
        if (queryValue == null) return; // Skip converted but null values

        builder.addQueryParam(name, queryValue, encoded);
    }
}

 
  
参数数据转换器在这里开始发挥作用了，可以通过调用Converter.convert()方法将参数数据转换成RequestBuilder实际需要的数据，通过3.3.2一节的分析我们知道处理String类型数据的转换器是ToStringConverter，因此这里valueConverter就是ToStringConverter实例的引用，重新回顾一下ToStringConverter.convert()方法
 
  
// BuiltInConverters.ToStringConverter
@Override
public String convert(Object value) {
    return value.toString();
}

 
  
数据转换完毕后，继续调用RequestBuilder.addQueryParam()方法设置Query参数的数据
 
  
// RequestBuilder
void addQueryParam(String name, @Nullable String value, boolean encoded) {
    if (relativeUrl != null) {
        // Do a one-time combination of the built relative URL and the base URL.
        urlBuilder = baseUrl.newBuilder(relativeUrl);
        ...
        relativeUrl = null;
    }

    if (encoded) {
        //noinspection ConstantConditions Checked to be non-null by above 'if' block.
        urlBuilder.addEncodedQueryParameter(name, value);
    } else {
        //noinspection ConstantConditions Checked to be non-null by above 'if' block.
        urlBuilder.addQueryParameter(name, value);
    }
}

 
  
到这里就都是OkHttp构建Request的方法了，不再展开细说。回到RequestFactory.create()，继续往下看Request的构建过程
 
  
// RequestFactory.create
return requestBuilder.get()
        .tag(Invocation.class, new Invocation(method, argumentList))
        .build();

 
  
首先调用了RequestBuilder.get()方法，看下源码
 
  
Request.Builder get() {
    HttpUrl url;
    HttpUrl.Builder urlBuilder = this.urlBuilder;
    if (urlBuilder != null) {
        url = urlBuilder.build();
    } else {
        // No query parameters triggered builder creation, just combine the relative URL and base URL.
        //noinspection ConstantConditions Non-null if urlBuilder is null.
        url = baseUrl.resolve(relativeUrl);
        ...
    }

    RequestBody body = this.body;
    if (body == null) {
        // Try to pull from one of the builders.
        if (formBuilder != null) {
            body = formBuilder.build();
        } else if (multipartBuilder != null) {
            body = multipartBuilder.build();
        } else if (hasBody) {
            // Body is absent, make an empty body.
            body = RequestBody.create(null, new byte[0]);
        }
    }

    MediaType contentType = this.contentType;
    if (contentType != null) {
        if (body != null) {
            body = new ContentTypeOverridingRequestBody(body, contentType);
        } else {
            requestBuilder.addHeader("Content-Type", contentType.toString());
        }
    }

    return requestBuilder
            .url(url)
            .method(method, body);
}

 
  
同样这里也都是OkHttp层的调用，成员变量requestBuilder对应的类型就是okhttp3.Request.Builder，调用build()方法就可以生成Request对象了
 
  
至此OkHttpCall.createRawCall()成功创建了一个okhttp3.Call的实例，现在我们回到OkHttpCall.enqueue()方法继续往下看
 
  
4.3 处理okhttp3.Response
 
  
得到okhttp3.Call实例后，下一步就是调用Call.enqueue()发起异步请求，并在回调中得到响应体对象okhttp3.Response，由于这是OkHttp层的，因此还需要解析转换成Retrofit层的响应体对象，解析转换的方法是OkHttpCall.parseResponse()
 
  
// OkHttpCall
Response parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();

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

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

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

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

 
  
这里的重点是调用ResponseConverter.convert()转换响应数据，之前分析过的内置和自定义的响应数据转换器在这发挥了作用，ResponseBody成功转换成用户需要的类型
 
  
至此我们完成了okhttp3.Response的处理过程，下一步再将生成的retrofit2.Response对象通过回调方法返回给用户，请求与响应的过程以及整个Retrofit工作流程的源码分析就完成了
 
  
4.4 本章小结
 
  
这一章分析了请求与响应的过程，主要完成了以下工作：
 
  
     
   
  • 通过上一章生成的请求执行器代理类发起异步请求
    •  
   
  • 通过RequestFactory构建请求体Request，其中包括使用参数数据转换器处理请求参数
    •  
   
  • 通过CallFactory生成真实请求执行器okhttp3.Call，并调用enqueue()方法发起真实的异步请求
    •  
   
  • 处理OkHttp层响应对象okhttp3.Response，生成Retrofit层响应对象retrofit2.Response，其中包括使用响应数据转换器将响应数据转换成用户定义的形式
    •  
   
  • 在请求执行器代理类中使用回调执行器将响应结果返还给用户
    •  
  
 
  
 
  
总结
 
  
最后以一张Retrofit的工作流程图总结之前的分析（ps：为了和流程进行区分，这里我将一些重要成员抽象成了数据源）
 
  
Android 网络编程：Retrofit源码解析_第1张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(android开发)

        

            

                
    
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    
                    
    • 
                    
  • （小白入门）Windows环境下搭建React Native Android开发环境
                        码农老黑
前端ReactNative移动开发Androidstudio
                        
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    
                    
    • 
                    
  • 使用 ADB 命令在 Android 设备上进行截屏
                        开心呆哥
adbandroid
                        
    在Android开发和调试过程中，截取设备屏幕是一项非常有用的功能。ADB（AndroidDebugBridge）是一个强大的工具，可以帮助我们与Android设备进行通信和调试。本文将介绍如何使用ADB命令在Android设备上进行截屏。1.准备工作在开始之前，确保你已经完成以下准备工作：在计算机上安装好AndroidSDK，并且配置好了ADB。连接你的Android设备到计算机，并确保ADB能
    
                    
    • 
                    
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了
                        m0_65322636
程序员架构移动开发android
                        
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
    
                    
    • 
                    
  • Java 学习路线：语言、框架、中间件与数据库
                        高危型
java
                        
    Java是一门功能强大、应用广泛的编程语言，适用于企业级应用、Web开发、大数据处理、Android开发等各种场景。这里为大家介绍了一下我认为较为合适的学习路线一、Java基础1.1Java语言基础1.1.1安装JDK和IDE安装JDK：下载JDK：访问Oracle官网，下载最新的JavaDevelopmentKit（JDK）。安装JDK：按照操作系统要求安装JDK并配置环境变量。Windows上
    
                    
    • 
                    
  • ADB 之 logcat 极简小抄（过滤日志、保存日志到文件）
                        我命由我12345
Android-ADB-极简小抄adb安卓android-studioandroidstudioandroid运维开发运维
                        
    一、logcatlogcat是Android开发中用于查看系统日志信息的工具二、logcat极简小抄1、查看日志adblogcat2、过滤日志按标签过滤日志adblogcat-s【标签】#演示：按标签test过滤日志adblogcat-stest按等级过滤日志adblogcat*:【等级】#V：Verbose，显示所有级别的日志#D：Debug，显示Debug级别及以上的日志#I：Info，显示I
    
                    
    • 
                    
  • Unity 插件 UniWebView，可以内嵌网页/浏览器到应用中
                        Jinx Boy
unity游戏引擎android
                        
    给大家推荐一个非常好用的unity内嵌网页插件：UniWebView最近在做安卓pad应用开发，需要用到内嵌网页的功能，发现这个最好用。一拖一改就可以了就是遇到了两个问题：一个是没有定位权限有些网页会打不开，解决方案可以看这篇：UnityAndroid内嵌网页，网页不开，没有定位权限另一个是加密的网页内容不允许加载，解决方案可以看这篇：Android开发，嵌入网页，网页打不开报错ERR_CLEAR
    
                    
    • 
                    
  • 实例化ViewModel的三种方式及对比
                        兰亭大境
开发语言kotlin
                        
    privatevalvm:DemoViewModelbyviewModels()privatevalvm2bylazy{ViewModelProvider(this).get(DemoViewModel::class.java)}privatevalvm3bylazy{WeakReference(DemoViewModel()).get()}在Android开发中，三种方式用于获取ViewMode
    
                    
    • 
                    
  • 字节跳动资深面试官亲述：15个经典面试问题及回答思路，知乎上转疯了！
                        左夜天
程序员android
                        
    前言这是“拔剑金九银十”的第二篇文章，本文主要针对3年以上的Android开发者进阶面试中高级开发工程师而整理。希望可以对你们有所帮助。不多废话，进入正题。目录：Java中高级计算机网络Android高级面试—性能优化Android优秀第三方库Androidframework相关其他Android高频面试题阿里P7薪资待遇**阿里薪资结构：**一般是12+1+3=16薪•年底的奖金为0-6个月薪资
    
                    
    • 
                    
  • Android开发使用框架手把手搭建一个简单项目
                        TTTTao2323
Androidandroid学习架构javakotlin
                        
    前言：年关将近，公司也没有什么业务了，基本上都是些旧项目维护以及客户给出的功能改动等小需求。正好其中有个需求是关于某个维护了近五年的小项目功能改动，由于这个项目当时搭建得并不好再加上后续的功能变化和最初设计时出入比较大，以至于每次收到有关这个项目的新需求时我都会非常头疼，于是就趁着这段业务空闲期把整个项目优化重构一遍，这样一来就算后续有了新的改动需求维护这个项目的同事也不再会因为“在屎山里面加屎”
    
                    
    • 
                    
  • Jetpack Compose 架构如何选？MVP 、 MVVM 还是 MVI？
                        goodhighting
程序员架构
                        
    首先，先看看不借助任何架构的Compose代码是怎样的？不使用架构的情况下，逻辑代码将与UI代码耦合在一起，在Compose中这种弊端显得尤为明显。常规Android开发默认引入了MVC思想，XML的布局方式使得UI层与逻辑层有了初步的解耦。但是Compose中，布局和逻辑同样都使用Kotlin实现，当布局中夹了杂逻辑，界限变得更加模糊。此外，ComposeUI中混入逻辑代码会带来更多的潜在隐患。
    
                    
    • 
                    
  • 手把手带你搭建一个优秀的Android项目架构
                        赖欣昱

                        
    手把手带你搭建一个优秀的Android项目架构XArchAndroid架构最佳实践-手把手带你搭建一个优秀的Android项目架构项目地址:https://gitcode.com/gh_mirrors/xa/XArch项目介绍在现代Android开发中，一个优秀的项目架构是确保项目可维护性、可扩展性和高效性的关键。本文介绍的开源项目正是为了解决这一需求而诞生的。该项目不仅提供了一个完整的Andro
    
                    
    • 
                    
  • 探索Android开发新境界：MVI架构的卓越实践
                        宣苓滢Rosa

                        
    探索Android开发新境界：MVI架构的卓越实践android-architecture追求android架构更佳实践~项目地址:https://gitcode.com/gh_mirrors/an/android-architecture在快速迭代的Android开发领域，追求高效、可维护的架构一直是开发者们的共同目标。今天，我们聚焦于一个值得关注的开源项目——Android架构更佳实践，这是一
    
                    
    • 
                    
  • 4-5.Android Camera 之其他方式预览图像编码模板（TextureView）
                        我命由我12345
Android-简化编程androidjavajava-eeandroid-studioandroidstudio安卓
                        
    一、CameraCamera用于捕获图像和视频在Android开发的早期阶段，Android提供android.hardware.CameraAPI，开发者用它来访问和控制设备的摄像头硬件然而，随着Android系统的发展，从Android5.0（API级别21）开始，Android引入了一个新的Camera2API，以提供更强大和灵活的控制功能二、Camera图像预览1、UtilMyCamera
    
                    
    • 
                    
  • android 相机预览的分辨率,Android开发 Camera2开发_2_预览分辨率或拍照分辨率的计算...
                        吴适于
android相机预览的分辨率
                        
    前言不管在Camera1或者Camera2在适配不同手机/不同使用场景的情况下都需要计算摄像头里提供的分辨率列表中最合适的那一个分辨率.所以在需要大量机型适配的app,是不建议不经过计算直接自定义分辨率设置到预览或者拍照照片中,有概率会因为摄像头不支持你输入的自定义分辨率导致报错或者打不开摄像头.如果你的确有需求要自定义分辨率,那么使用场景只有一个那就是你是在开发Android设备,并且你输入的自
    
                    
    • 
                    
  • Android 组件化，从入门到不可自拔
                        字节跳不动

                        
    前言组件化技术，在Android开发中有着举足轻重的作用。随着时间推移，软件项目很多都会变得越来越庞杂。此时，采用组件化技术，对项目进行改造，是一种较优的方案。谈谈模块化要聊组件化，惯例是要谈谈模块化的，毕竟它与组件化确实有一些相同点，在组件化的项目中它也会与组件化发生关联。什么是模块化模块化开发，是每个开发者都熟悉的。即将常用的UI、网络请求、数据库操作、第三方库的使用等公共部分抽离封装成基础模
    
                    
    • 
                    
  • 一个Android开发者的React Native之路
                        青灯明月
RNAndroidReactandroidreactnative
                        
    这是一个Android开发者一个月以来学习ReactNative的一些经验和感悟，如有错漏之处敬请指出~1.什么是ReactNativeReactNative是Facebook在2015年开源的一个项目，用官方的话来解释就是：ReactNativeletsyoubuildmobileappsusingonlyJavaScriptReactNative让你只用JavaScript就能编写移动端App
    
                    
    • 
                    
  • 解锁Android开发利器：MVVM架构_android的mvvm
                        2401_86637402
面试辅导大厂内推android架构
                        
    //从网络或其他数据源获取天气数据returnWeather(city,"25°C")}}2.定义View：classWeatherActivity:AppCompatActivity(){privatelateinitvarviewModel:WeatherViewModeloverridefunonCreate(savedInstanceState:Bundle?){super.onCreat
    
                    
    • 
                    
  • React Native新架构系列-C++实现跨平台Turbo Native Module
                        林克在思考
ReactNativereactnativec++react.js
                        
    今天我们介绍在ReactNative新架构中如何C++代码实现一个跨平台的C++TurboNativeModule扩展API。阅读本文前建议阅读上一篇文章。本系列基于ReactNative0.73.4版本，从一名Android开发者的视角进行介绍。本系列介绍的内容默认读者对ReactNative有一定的了解，对基础的开发内容不再赘述。在上一篇文章中ReactNative新架构系列-自定义Turbo
    
                    
    • 
                    
  • 2020年是做安卓开发人员的绝佳时机，android开发面试自我介绍
                        m0_66144765
程序员架构移动开发android
                        
    你这样做仅仅是准备好一个开发环境去构建安卓App,但是你还得去准备好基础和基本知识来理解安卓开发和大多数教程使用的通用术语你现在也可以在安卓系统上构建基本的App，并且可以开发一些功能。随意使用空白画布，用你的想象力填充它。当你玩完创意后，2020年你的下一个目标是加快游戏进度，推动自己成为一名为数十亿人构建应用的开发者。我们现在去第二层！提升自己-作为一个安卓开发者Level2这个列表将作为你学
    
                    
    • 
                    
  • 2024年Android开发60条技术经验总结，2024年最新面试安卓系统架构
                        2301_82243733
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】我个人是做Android开发，已经有十来年了，目前在某创业公司任职CTO兼系统架构师。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。这里
    
                    
    • 
                    
  • SQLite数据库管理与Android应用集成
                        含老司开挖掘机

                        
    本文还有配套的精品资源，点击获取简介：SQLite是一种轻量级的关系型数据库，适用于移动设备和单机应用。它内置了对SQL标准的支持，并提供丰富的数据操作功能。在Android开发中，SQLite是默认的数据库解决方案，可通过SQLiteOpenHelper和SQLiteDatabaseAPI进行管理。本教程将通过实践帮助理解SQLite数据库的创建、管理和使用，以及如何将其与Android应用集成
    
                    
    • 
                    
  • 4-2.Android Camera 之预览图像编码模板（SurfaceView）
                        我命由我12345
Android-简化编程androidjavajava-eeandroid-studioandroidstudio视频
                        
    一、CameraCamera用于捕获图像和视频在Android开发的早期阶段，Android提供android.hardware.CameraAPI，开发者用它来访问和控制设备的摄像头硬件然而，随着Android系统的发展，从Android5.0（API级别21）开始，Android引入了一个新的Camera2API，以提供更强大和灵活的控制功能二、Camera预览图像1、UtilMyCamera
    
                    
    • 
                    
  • Kotlin 枚举类
                        wjs2024
开发语言
                        
    Kotlin枚举类概述Kotlin是一种现代的编程语言，由JetBrains开发，旨在提高开发者的工作效率和代码质量。它运行在Java虚拟机(JVM)上，与Java完全兼容，同时提供了许多现代语言特性，如空安全、扩展函数和协程等。Kotlin的设计哲学是简洁和表达性，这使得它成为Android开发的官方语言，并在后端开发中也越来越受欢迎。Kotlin枚举类简介枚举类是Kotlin中的一种特殊类，用
    
                    
    • 
                    
  • Android开发、adb、monkey测试
                        AoChengi

                        
    一、手机测试概念传统手机测试VS手机应用软件测试传统手机测试：指测试手机本身比如抗压，抗摔，抗疲劳，抗低温高温等。也包括手机本身功能、性能等测试。手机应用软件测试C/SClient/Server手机应用软件是基于手机操作系统之上开发出来的软件，做这样的测试就叫做手机应用软件测试。二、手机端常规测试2.1.What2.1.1.介绍手机测试的概念架构image.pngimage.png对于手机端测试，
    
                    
    • 
                    
  • 单例模式双重锁中volatile的作用
                        Mr Lee_
AndroidJava单例模式java开发语言
                        
    对于学android开发的同学来说，单例模式应该在熟悉不过了吧，单例模式（SingletonPattern）是Java中最简单的设计模式之一，还可以分为饿汉式和懒汉式，这篇文章浅谈下懒汉式，重点讲一下饿汉式的volatile的作用，如有什么问题，还请大家多多指教哈！！！懒汉式顾名思义，就是一个很懒的人，他什么都不想动，就只想着躺平，只有到饿了的时候才会去找吃的，简单来说就是一开始并不会去实例化，只
    
                    
    • 
                    
  • Android Camera系列（三）：GLSurfaceView+Camera
                        如果可以003
AndroidCameraandroidCameraGLSurfaceView
                        
    人类的悲欢并不相通—鲁迅AndroidCamera系列（一）：SurfaceView+CameraAndroidCamera系列（二）：TextureView+CameraAndroidCamera系列（三）：GLSurfaceView+Camera本系列主要讲述Android开发中Camera的相关操作、预览方式、视频录制等，项目结构代码耦合性低，旨在帮助大家能从中有所收获（方便copy:）），
    
                    
    • 
                    
  • Unity 对接 Android 第三方广告，App 切换到后台后，再次打开时，第三方广告被销毁导致无法触发回调逻辑的问题
                        艾沃尼斯
苦大仇深AndroidStudioandroid
                        
    该问题是由发行进行游戏测试时遇到并反馈的。大致情况如下：1.当触发了插屏广告后，在关闭广告前将App切换到后台，之后再次打开App，此时插屏广告消失，并切游戏卡死。2.当触发激励视频广告后，在广告展示完毕前将App切换到后台，之后再次打开App，此时激励视频广告消失，并且不会获得奖励。虽然接第三方广告也接了很长一段时间了，但这个问题头一次遇到，因为不是专业Android开发人员，所以也一脸懵逼。解
    
                    
    • 
                                
  • 对于规范和实现，你会混淆吗？
                                    yangshangchuan
HotSpot
                                    
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： 
 
 JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
    
                                
    • 
                                
  • android 网络
                                    百合不是茶
网络
                                    
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat 
  
服务器代码;  servlet的使用需要在xml中注册 
package servlet;

import java.io.IOException;
import java.util.Arr
    
                                
    • 
                                
  • [读书笔记]读法拉第传
                                    comsci
读书笔记
                                    
     
 
      1831年的时候,一年可以赚到1000英镑的人..应该很少的... 
 
      要成为一个科学家,没有足够的资金支持,很多实验都无法完成 
 
      但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
    
                                
    • 
                                
  • 随机数的产生
                                    沐刃青蛟
随机数
                                    
    c++中阐述随机数的方法有两种： 
  
一是产生假随机数（不管操作多少次，所产生的数都不会改变） 
  
       这类随机数是使用了默认的种子值产生的，所以每次都是一样的。 
  
	//默认种子
	for (int i = 0; i < 5; i++)
	{
		cout<<
    
                                
    • 
                                
  • PHP检测函数所在的文件名
                                    IT独行者
PHP函数
                                    
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 
代码： 
     
[php]   
view plain 
copy    
 
 // Filename: functions.php    
 <?php&nbs
    
                                
    • 
                                
  • 银行各系统功能简介
                                    文强chu
金融
                                    
    银行各系统功能简介     　   业务系统   核心业务系统     业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等       清分清算系统     以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程       国际结算系
    
                                
    • 
                                
  • Python学习1(pip django 安装以及第一个project)
                                    小桔子
pythondjangopip
                                    
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 
第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 
第二部：解压这个压缩文件，会看到一个setup.p
    
                                
    • 
                                
  • php 数组
                                    aichenglong
PHP排序数组循环多维数组
                                    
    1 php中的创建数组 
 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 
2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 
 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 
 $numbers=range(1,10,
    
                                
    • 
                                
  • 安装python2.7
                                    AILIKES
python
                                    
    安装python2.7 
1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 
2、复制解压 
#mkdir -p /opt/usr/python 
#cp  /opt/soft/Python-2
    
                                
    • 
                                
  • java异常的处理探讨
                                    百合不是茶
JAVA异常
                                    
    //java异常  
/* 
1，了解java 中的异常处理机制，有三种操作 
a,声明异常  
b,抛出异常  
c,捕获异常 
2，学会使用try-catch-finally来处理异常 
3，学会如何声明异常和抛出异常 
4，学会创建自己的异常 
  
*/ 
  
//2，学会使用try-catch-finally来处理异常 
  
    
                                
    • 
                                
  • getElementsByName实例
                                    bijian1013
element
                                    
    实例1： 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/x
    
                                
    • 
                                
  • 探索JUnit4扩展：Runner
                                    bijian1013
java单元测试JUnit
                                    
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。 
        文章地址：http://www.blogjava.net/jiangshachina/archive/20
    
                                
    • 
                                
  • [MongoDB学习笔记二]MongoDB副本集
                                    bit1129
mongodb
                                    
    1. 副本集的特性 
  1)一台主服务器(Primary),多台从服务器(Secondary) 
  2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作 
  3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来 
  
2
    
                                
    • 
                                
  • 【Spark八十一】Hive in the spark assembly
                                    bit1129
assembly
                                    
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 
 
  1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
    
                                
    • 
                                
  • Nginx问题定位之监控进程异常退出
                                    ronin47

                                    
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 
1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 
比如，这是一个异常退出的情况： 
$grep signal error.log

2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
    
                                
    • 
                                
  • No grammar constraints (DTD or XML schema).....两种解决方法
                                    byalias
xml
                                    
    方法一：常用方法   关闭XML验证 
工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 
 
方法二：（个人推荐） 
添加 内容如下 
<?xml version=
    
                                
    • 
                                
  • Netty源码学习-DefaultChannelPipeline
                                    bylijinnan
netty
                                    
    package com.ljn.channel;

/**
 * ChannelPipeline采用的是Intercepting Filter 模式
 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现
 * 
 * 下面对ChannelPipeline作一个模拟，只模拟关键代码：
 */
public class Pipeline {
 
    
                                
    • 
                                
  • MYSQL数据库常用备份及恢复语句
                                    chicony
mysql
                                    
      
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 
mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 
 
备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 
mysqldump -–add-drop-table -uusername -ppassword databasename > ba
    
                                
    • 
                                
  • 小白谈谈云计算--基于Google三大论文
                                    CrazyMizzz
Google云计算GFS
                                    
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。 
    我先说说GFS 
  &n
    
                                
    • 
                                
  • hadoop 平衡空间设置方法
                                    daizj
hadoopbalancer
                                    
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： 
<property> 
  <name>dfs.balance.bandwidthPerSec</name> 
    <value>10485760</value> 
    <description&g
    
                                
    • 
                                
  • Eclipse程序员要掌握的常用快捷键
                                    dcj3sjt126com
编程
                                    
       判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。     程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
    
                                
    • 
                                
  • Android学习之路
                                    dcj3sjt126com
Android学习
                                    
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 
以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 
下面说说我学习Android的感受，我学Android首先是看MARS的视
    
                                
    • 
                                
  • java 遍历Map的四种方法
                                    eksliang
javaHashMapjava 遍历Map的四种方法
                                    
    转载请出自出处： 
http://eksliang.iteye.com/blog/2059996 
 
package com.ickes;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
 * 遍历Map的四种方式

    
                                
    • 
                                
  • 【精典】数据库相关相关
                                    gengzg
数据库
                                    
    package C3P0; 
import java.sql.Connection; 
import java.sql.SQLException; 
import java.beans.PropertyVetoException; 
import com.mchange.v2.c3p0.ComboPooledDataSource; 
public class DBPool{       
    
                                
    • 
                                
  • 自动补全
                                    huyana_town
自动补全
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
    
                                
    • 
                                
  • jquery在线预览PDF文件，打开PDF文件
                                    天梯梦
jquery
                                    
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。 
  
核心代码 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
    
                                
    • 
                                
  • ViewPager刷新单个页面的方法
                                    lovelease
androidviewpagertag刷新
                                    
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
    
                                
    • 
                                
  • 利用按位取反（~）从复合枚举值里清除枚举值
                                    草料场
enum
                                    
    以 C# 中的 System.Drawing.FontStyle 为例。  
  
如果需要同时有多种效果， 
如：“粗体”和“下划线”的效果，可以用按位或（|） 
FontStyle style = FontStyle.Bold | FontStyle.Underline; 
  
如果需要去除 style 里的某一种效果， 
    
                                
    • 
                                
  • Linux系统新手学习的11点建议
                                    刘星宇
编程工作linux脚本
                                    
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 
 
　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
    
                                
    • 
                                
  • hibernate dao层应用之HibernateDaoSupport二次封装
                                    wangzhezichuan
DAOHibernate
                                    
    /** 
 * <p>方法描述:sql语句查询 返回List<Class> </p> 
 * <p>方法备注: Class 只能是自定义类 </p> 
 * @param calzz 
 * @param sql 
 * @return 
 * <p>创建人：王川</p> 
 * <p>创建时间：Jul
    
                                
    •