public Builder baseUrl(String baseUrl) {

checkNotNull(baseUrl, “baseUrl == null”);

HttpUrl httpUrl = HttpUrl.parse(baseUrl);

…

return baseUrl(httpUrl);

}

public Builder baseUrl(HttpUrl baseUrl) {

checkNotNull(baseUrl, “baseUrl == null”);

…

this.baseUrl = baseUrl;

return this;

}

这两段代码也很简单，校验URL，生成httpUrl对象，然后赋值给baseUrl

看看build() 方法在做什么

参数基本设置完了，最后就要看看build() 这个方法在做什么：

public Retrofit build() {

if (baseUrl == null) {

throw new IllegalStateException(“Base URL required.”);

}

okhttp3.Call.Factory callFactory = this.callFactory;

if (callFactory == null) {

callFactory = new OkHttpClient();

}

…

return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),

unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);

}

}

}

代码中有大量的参数校验，有些复杂的参数我们没有传，所以我就把那些代码删除了。简单看一下也能知道，这段代码就是做一些参数校验，baseUrl不能为空否则会抛异常，至于其他的参数如果为null则会创建默认的对象。其中callFactory就是okhttp的工厂实例，用于网络请求的。

最后我们看到，这个方法最终返回的是一个Retrofit的对象，初始化完成。

生成接口实现类

刚才我们就讲过retrofit.create这个方法很重要，它帮我们生成了接口实现类，并完成了方法体的创建，省去了我们很多工作量。那我们来看看它是如何帮我们实现接口的。

public T create(final Class 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<Object, Object> serviceMethod =

(ServiceMethod<Object, Object>) loadServiceMethod(method);

OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

return serviceMethod.adapt(okHttpCall);

}

});

}

这段代码实际上是使用了动态代理的设计模式，而且这个方法封装的非常好，我们只需要调用 方法就可以获得我们需要的实现类，遵循了迪米特法则（最少知道原则）。

了解动态代理的人都知道我们要重写Object invoke(Object proxy, Method method, [@Nullable]( ) Object[] args) 方法，这个方法会传入我们需要的实现的方法，和参数，并返回我们需要的返回值。

retrofit在重写这个方法的时候做了三件事：

• 1、先判断了这个方法的类是不是一个Object.class)，就直接返回方法原有的返回值。

• 2、判断这个方法是不是DefaultMethod，大家都知道这个方法是Java 8出来的新属性，表示接口的方法体。

• 3、构建一个ServiceMethod<Object, Object>对象和OkHttpCall<Object>对象，并调用

serviceMethod.adapt(okHttpCall)方法将二者绑定。

我们看看这个方法的源码：

T adapt(Call call) {

return callAdapter.adapt(call);

}

这个callAdapter我们在初始化retrofit的时候没有使用：

addCallAdapterFactory(CallAdapterFactory)传值，所以这里是默认的DefaultCallAdapterFactory

那我们再看看DefaultCallAdapterFactory里的adapt(call)方法：

@Override public Call adapt(Call call) {

return call;

}

直接返回参数，也就是OkHttpCall<Object>的对象。所以如果没有自定义callAdapter的时候，我们定义接口的时候返回值类型应该是个Call类型的。

那么，至此这个create方法已经帮我们实现了我们定义的接口，并返回我们需要的值。

请求参数整理

我们定义的接口已经被实现，但是我们还是不知道我们注解的请求方式，参数类型等是如何发起网络请求的呢？

这时我们可能应该关注一下ServiceMethod<Object, Object>对象的构建了：

ServiceMethod<Object, Object> serviceMethod =

(ServiceMethod<Object, Object>) loadServiceMethod(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;

}

逻辑很简单，就是先从一个 serviceMethodCache中取ServiceMethod<?, ?>对象，如果没有，则构建ServiceMethod<?, ?>对象，然后放进去serviceMethodCache中，这个serviceMethodCache是一个HashMap:

private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();

所以构建ServiceMethod<?, ?>对象的主要逻辑还不在这个方法里，应该在new ServiceMethod.Builder<>(this, method).build();里面。这也是个链式调用，一般都是参数赋值，我们先看看Builder<>(this, method)方法：

Builder(Retrofit retrofit, Method method) {

this.retrofit = retrofit;

this.method = method;

this.methodAnnotations = method.getAnnotations();

this.parameterTypes = method.getGenericParameterTypes();

this.parameterAnnotationsArray = method.getParameterAnnotations();

}

果然，这里获取了几个重要的参数：

• retrofit实例

• method，接口方法

• 接口方法的注解methodAnnotations，在retrofit里一般为请求方式

• 参数类型parameterTypes

• 参数注解数组parameterAnnotationsArray，一个参数可能有多个注解

我们再看看build()的方法：

public ServiceMethod build() {

callAdapter = createCallAdapter();

responseType = callAdapter.responseType();

responseConverter = createResponseConverter();

for (Annotation annotation : methodAnnotations) {

parseMethodAnnotation(annotation);

}

if (httpMethod == null) {

throw methodError(“HTTP method annotation is required (e.g., @GET, @POST, etc.).”);

}

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

}

return new ServiceMethod<>(this);

}

这个方法挺长的，删了些无关紧要的代码还是很长。首先一开始先获取几个重要对象：callAdapter、responseType和responseConverter，这三个对象都跟最后的结果有关，我们先不管。

看到一个for循环，遍历方法的注解，然后解析：

for (Annotation annotation : methodAnnotations) {

parseMethodAnnotation(annotation);

}

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

}

…

这个方法的方法体我删掉了后面的一部分，因为逻辑都是一样，根据不同的方法注解作不同的解析，得到网络请求的方式httpMethod。但是主要的方法体还是if里面的方法：

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {

…

// 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("URL query string “%s” must not have replace block. "

• “For dynamic query parameters use @Query.”, queryParams);

}

}

this.relativeUrl = value;

this.relativeUrlParamNames = parsePathParameters(value);

}

逻辑不复杂，就是校验这个value的值 是否合法，规则就是不能有“？”如果有则需要使用@Query注解。最后this.relativeUrl = value;。这个relativeUrl就相当于省略域名的URL，一般走到这里我们能得到的是：users/{name}/repos这样的。里面的“{name}”是一会我们需要赋值的变量。

我们继续看刚才的build()方法：

解析完方法的注解之后，需要解析参数的注解数组，这里实例化了一个一维数组：

parameterHandlers = new ParameterHandler<?>[parameterCount];

然后遍历取出参数的类型：

Type parameterType = parameterTypes[p];

取出参数注解：

Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

然后把参数类型、参数注解都放在一起进行解析，解析的结果放到刚才实例化的数组parameterHandlers里面：

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

那我们再看看这个方法里做了什么：

private ParameterHandler<?> parseParameter(int p, Type parameterType, Annotation[] annotations) {

ParameterHandler<?> result = null;

for (Annotation annotation : annotations) {

ParameterHandler<?> annotationAction = parseParameterAnnotation(

p, parameterType, annotations, annotation);

}

}

这个方法的主要代码也很简单，解析参数注解，得到一个ParameterHandler<?> annotationAction对象。

那我继续看方法里面的代码。当我们点进parseParameterAnnotation( p, parameterType, annotations, annotation);的源码里面去之后发现这个方法的代码接近500行！但是大部分逻辑类似，都是通过if else判断参数的注解，我们取一段我们刚才的例子相关的代码出来：

if (annotation instanceof Path) {

if (gotQuery) {

throw parameterError(p, “A @Path parameter must not come after a @Query.”);

}

if (gotUrl) {

throw parameterError(p, “@Path parameters may not be used with @Url.”);

}

if (relativeUrl == null) {

throw parameterError(p, “@Path can only be used with relative url on @%s”, httpMethod);

}

gotPath = true;

Path path = (Path) annotation;

String name = path.value();

validatePathName(p, name);

Converter<?, String> converter = retrofit.stringConverter(type, annotations);

return new ParameterHandler.Path<>(name, converter, path.encoded());

}

前面做了一些校验，后面取出注解的名字：name，然后用正则表达校验这个name是否合法。然后构建一个Converter<?, String>对象：

Converter<?, String> converter = retrofit.stringConverter(type, annotations);

点击去看看：

public Converter<T, String> stringConverter(Type type, Annotation[] annotations) {

…

for (int i = 0, count = converterFactories.size(); i < count; i++) {

Converter<?, String> converter =

converterFactories.get(i).stringConverter(type, annotations, this);

if (converter != null) {

//noinspection unchecked

return (Converter<T, String>) converter;

}

}

return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;

}

看到核心代码是converter的stringConverter(type, annotations, this)方法：

因为我们刚才的示例中被没有通过：addConverterFactory(ConverterFactory)添加一个ConverterFactory，所以这里会返回一个空：

public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,

Retrofit retrofit) {

return null;

}

所以最后会执行最后一句代码：

return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;

我们点进去看看这个INSTANCE：

static final ToStringConverter INSTANCE = new ToStringConverter();

是BuiltInConverters内的内部类ToStringConverter的单例。所以这里我们得到的就

是BuiltInConverters.ToStringConverter的实例。

最后用这个对象构建一个Path（因为示例中的参数类型是path，所以我们看这个代码）：

new ParameterHandler.Path<>(name, converter, path.encoded());

我们看看这个Path类的构造函数：

Path(String name, Converter<T, String> valueConverter, boolean encoded) {

this.name = checkNotNull(name, “name == null”);

this.valueConverter = valueConverter;

this.encoded = encoded;

}

只是赋值，并且我们看到这个类继承自：ParameterHandler<T>，所以我们回到刚才的build()方法，发现把参数类型，参数注解放在一起解析之后存储到了这个ParameterHandler<T>数组中，中间主要做了多种合法性校验，并根据注解的类型，生成不同的

ParameterHandler<T>子类，如注解是Url则生成ParameterHandler.RelativeUrl()对象，如果注解是Path，则生成：

ParameterHandler.Path<>(name, converter, path.encoded())对象等等。

我们查看了ParameterHandler<T>类，发现它有一个抽象方法：

abstract void apply(RequestBuilder builder, @Nullable T value) throws IOException;

这个方法每个子类都必须复写，那我们看看Path里面怎么复写的：

@Override

void apply(RequestBuilder builder, @Nullable T value) throws IOException {

builder.addPathParam(name, valueConverter.convert(value), encoded);

}

就是把value被添加到RequestBuilder中，我们看一下这个addPathParam方法：

void addPathParam(String name, String value, boolean encoded) {

relativeUrl = relativeUrl.replace(“{” + name + “}”, canonicalizeForPath(value, encoded));

}

这个方法把我们传进来的值value按照编码格式转换，然后替换relativeUrl中的{name}，构成一个有效的省略域名的URL。至此，URL的拼接已经完成！

总结：Retrofit使用动态代理模式实现我们定义的网络请求接口，在重写invoke方法的时候构建了一个ServiceMethod对象，在构建这个对象的过程中进行了方法的注解解析得到网络请求方式httpMethod，以及参数的注解分析，拼接成一个省略域名的URL

Retrofit网络请求

我们刚才解析了apply方法，我们看看apply方法是谁调用的呢？跟踪一下就发先只有toCall(args);方法：

okhttp3.Call toCall(@Nullable Object… args) throws IOException {

RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,

contentType, hasBody, isFormEncoded, isMultipart);

@SuppressWarnings(“unchecked”) // It is an error to invoke a method with the wrong arg types.

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

int argumentCount = args != null ? args.length : 0;

if (argumentCount != handlers.length) {

throw new IllegalArgumentException(“Argument count (” + argumentCount

• “) doesn’t match expected count (” + handlers.length + “)”);

}

for (int p = 0; p < argumentCount; p++) {

handlers[p].apply(requestBuilder, args[p]);

}

return callFactory.newCall(requestBuilder.build());

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

尾声

面试成功其实都是必然发生的事情，因为在此之前我做足了充分的准备工作，不单单是纯粹的刷题，更多的还会去刷一些Android核心架构进阶知识点，比如：JVM、高并发、多线程、缓存、热修复设计、插件化框架解读、组件化框架设计、图片加载框架、网络、设计模式、设计思想与代码质量优化、程序性能优化、开发效率优化、设计模式、负载均衡、算法、数据结构、高级UI晋升、Framework内核解析、Android组件内核等。

不仅有学习文档，视频+笔记提高学习效率，还能稳固你的知识，形成良好的系统的知识体系。这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家梳理了多年的架构经验，筹备近6个月最新录制的，相信这份视频能给你带来不一样的启发、收获。

Android进阶学习资料库

一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！

大厂面试真题

PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

《2017-2021字节跳动Android面试历年真题解析》

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

解读、组件化框架设计、图片加载框架、网络、设计模式、设计思想与代码质量优化、程序性能优化、开发效率优化、设计模式、负载均衡、算法、数据结构、高级UI晋升、Framework内核解析、Android组件内核等。**
[外链图片转存中…(img-GlJZCeqE-1712416961612)]

不仅有学习文档，视频+笔记提高学习效率，还能稳固你的知识，形成良好的系统的知识体系。这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家梳理了多年的架构经验，筹备近6个月最新录制的，相信这份视频能给你带来不一样的启发、收获。

[外链图片转存中…(img-tzlDir2K-1712416961612)]

Android进阶学习资料库

一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！

[外链图片转存中…(img-P2OSgH03-1712416961612)]

大厂面试真题

PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

[外链图片转存中…(img-pqt3rvYh-1712416961613)]

《2017-2021字节跳动Android面试历年真题解析》

[外链图片转存中…(img-b58aYCg5-1712416961613)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！