关键词：
retrofit 已经流行很久了，它是Square开源的一款优秀的网络框架，这个框架对okhttp进行了封装，让我们使用okhttp做网路请求更加简单。但是光学会使用只是让我们多了一个技能，学习其源码才能让我们更好的成长。
本篇文章是在分析retrofit的源码流程，有大量的代码，读者最好把源码下载下来导入IDE，然后跟着一起看，效果会更好
源码下载地址
retrofit入门
- 定义网络请求的API接口：
interface GithubApiService
@GET("users/name/repos")
Call<ResponseBody> searchRepoInfo(@Path("name") String name);
使用了注解表明请求方式，和参数类型，这是retrofit的特性，也正是简化了我们的网络请求过程的地方！
- 初始化一个retrofit的实例：
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.build();retrofit的实例化很简单，采用链式调用的设计，把需要的参数传进去即可，复杂的参数我们这里就不举例了。
- 生成接口实现类：
GithubApiService githubService = retrofit.create(service)
Call<ResponseBody> call = githubService.searchRepoInfo("changmu175");我们调用retrofit的create方法就可以把我们定义的接口转化成实现类，我们可以直接调用我们定义的方法进行网络请求，但是我们只定义了一个接口方法，也没有方法体，请求方式和参数类型都是注解，create是如何帮我们整理参数，实现方法体的呢？一会我们通过源码解析再去了解。
- 发起网络请求
//同步请求方式
call.request();
//异步请求方式
call.enqueue(new Callback<ResponseBody>()
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response)
//请求成功回调
@Override
public void onFailure(Call<ResponseBody> call, Throwable t)
//请求与失败回调
);至此，retrofit的一次网络请求示例已经结束，基于对okhttp的封装，让网络请求已经简化了很多。当然retrofit最适合的还是REST API类型的接口，方便简洁。
下面我们就看看retrofit的核心工作是如何完成的！
retrofit初始化
retrofit的初始化采用了链式调用的设计
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.build();很明显这个方法是在传一些需要的参数，我们简单的跟踪一下：
首先看看Builder()的源码：
public Builder()
this(Platform.get());
这句代码很简单就是调用了自己的另一个构造函数：
Builder(Platform platform)
this.platform = platform;
这个构造函数也很简单，就是一个赋值，我们把之前的Platform.get()点开，看看里面做在什么：
private static final Platform PLATFORM = findPlatform();
static Platform get()
return PLATFORM;
我们发现这里使用使用了一个饿汉式单例，使用Platform.get()返回一个实例，这样写的好处是简单，线程安全，效率高，不会生成多个实例！
我们再看看findPlatform() 里做了什么：
private static Platform findPlatform()
try
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0)
return new Android();
catch (ClassNotFoundException ignored)
....省略部分代码...
所以是判断了一下系统，然后根据系统实例化一个对象。这里面应该做了一些和Android平台相关的事情，属于细节，我们追究，感兴趣的可以只看看。
再看看baseUrl(url)的源码
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> T create(final Class<T> 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<Object> 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<R> call)
return callAdapter.adapt(call);
这个callAdapter我们在初始化retrofit的时候没有使用：
addCallAdapterFactory(CallAdapterFactory)传值，所以这里是默认的DefaultCallAdapterFactory
那我们再看看DefaultCallAdapterFactory里的adapt(call)方法：
@Override public Call<Object> adapt(Call<Object> 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 <T> 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<Object>[] handlers = (ParameterHandler<Object>[]) 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());
这个方法一开始就构建了RequestBuilder，传进去的参数包含：
httpMethod，baseUrl，relativeUrl，headers，contentType，hasBody，isFormEncoded，isMultipart！
然后获取了parameterHandlers，我们上边分析的时候，知道这个数组是存参数注解的解析结果的，并对其进行遍历调用了如下方法：
for (int p = 0; p < argumentCount; p++)
handlers[p].apply(requestBuilder, args[p]);
把参数值传进RequestBuilder中。
最后调用callFactory.newCall(requestBuilder.build())生成一个okhttp3.Call。
我们看一下这个build方法：
Request build()
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);
if (url == null)
throw new IllegalArgumentException(
"Malformed URL. Base: " + baseUrl + ", Relative: " + 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)
.build();
可以看到okhttp的请求体在这里构建，当所有的参数满足的时候，则调用了
Request.Builder requestBuilder
.url(url)
.method(method, body)
.build();这是发起okhttp的网络请求 。
那这个toCall(args);谁调用的呢？继续往回跟！
private okhttp3.Call createRawCall() throws IOException
okhttp3.Call call = serviceMethod.toCall(args);
return call;
那谁调用了createRawCall()呢？继续看谁调用了！于是发现调用方有三个地方，并且都是OkHttpCall里面！我们一个一个看吧：
- Request request()方法：
- enqueue(final Callback callback)方法
Response execute()的方法
很明显上面三个方法都是retrofit的发起网络请求的方式，分别是同步请求和异步请求。我们的示例中在最后一步就是调用了
request方法和enqueue方法发起网络请求。至此我们已经疏通了retrofit是如何进行网络请求的了。总结：当我们调用Retrofit的网络请求方式的时候，就会调用okhttp的网络请求方式，参数使用的是实现接口的方法的时候拿到的信息构建的
RequestBuilder对象，然后在build方法中构建okhttp的Request，最终发起网络请求
总结
至此retrofit的流程讲完了，文章很长，代码很多，读者最好下载代码导入IDE，跟着文章一起看代码。
Retrofit主要是在create方法中采用动态代理模式实现接口方法，这个过程构建了一个ServiceMethod对象，根据方法注解获取请求方式，参数类型和参数注解拼接请求的链接，当一切都准备好之后会把数据添加到Retrofit的RequestBuilder中。然后当我们主动发起网络请求的时候会调用okhttp发起网络请求，okhttp的配置包括请求方式，URL等在Retrofit的RequestBuilder的build()方法中实现，并发起真正的网络请求。
Retrofit封装了okhttp框架，让我们的网络请求更加简洁，同时也能有更高的扩展性。当然我们只是窥探了Retrofit源码的一部分，他还有更复杂更强大的地方等待我们去探索包括返回值转换工厂，拦截器等，这些都属于比较难的地方，我们需要循序渐进的去学习，当我们一点一点的看透框架的本质之后，我们使用起来才会熟能生巧。大神的代码，对于Android想要进阶的同学来说很有好处，不仅教会我们如何设计代码更多的是解决思想。
retrofit
Retrofit原理（面试）Retrofit工作原理总结Retrofit原理解析最简洁的思路从架构角度看Retrofit的作用、原理和启示 查看详情
retrofit响应体无body时解析eofexception(代码片段)
...决方案自定义处理类型太长不看版由于以下涉及到一些跟Retrofit使用有关的问题及部分Retrofit的代码,如果未使用过Retrofit可能看了很混乱.这里有简洁版.异常Causedby:java.io.EOFException:Endofinputatline1column当出现以上异常时(这时指使用Gso... 查看详情
retrofit流程及设计模式全解析(代码片段)
...模式1.1静态代理模式1.2动态代理模式1.3动态代理的原理2.Retrofit接口代理对象的创建3.Retorfit的Call创建4.CallAdapter接口适配器4.1CallAdapter&Factory4.2平台默认的DefaultCallAdap 查看详情
retrofit流程及设计模式全解析(代码片段)
...模式1.1静态代理模式1.2动态代理模式1.3动态代理的原理2.Retrofit接口代理对象的创建3.Retorfit的Call创建4.CallAdapter接口适配器4.1CallAdapter&Factory4.2平台默认的DefaultCallAdapterFactory4.3RxJava3CallAdapterFactory使Retrofit支持RxJava5.Retrofit请求流... 查看详情
koa2框架原理解析和实现(代码片段)
...文从零开始，循序渐进，讲解koa2的框架源码结构和实现原理，展示和详解koa2框架源码中的几个最重要 查看详情
深入retrofit原理探索~(代码片段)
我们先来回顾一下Retrofit的基本使用implementation'com.squareup.retrofit2:retrofit:2.9.0'implementation'com.squareup.retrofit2:converter-gson:2.9.0'interfaceNetApi@GET("/hotkey/json")fung 查看详情
retrofit源码解析-动态代理(代码片段)
Retrofit源码解析-动态代理背景之前一系列的关于Retrofit使用和封装的讲解过后，想必对Retrofit的灵活性和扩展性有何深入的了解，既然如此我们就对于Retrofit内部实现原理来深入的学习，既然要用就要理解怎么用和怎么... 查看详情
retrofit源码解析-动态代理(代码片段)
Retrofit源码解析-动态代理背景之前一系列的关于Retrofit使用和封装的讲解过后，想必对Retrofit的灵活性和扩展性有何深入的了解，既然如此我们就对于Retrofit内部实现原理来深入的学习，既然要用就要理解怎么用和怎么... 查看详情
站在巨人的肩膀上--retrofit源码解析(代码片段)
前言每次看完Retrofit的源码，下次再看时很容易就忘记了，Retrofit的源码中用了大量的设计模式，刚开始看时感觉就是代码中调来调去。。。绕来绕去。。。真的。。。没有点到即止的话~很容易就晕了，所以这次... 查看详情
retrofit源码剖析-深入(代码片段)
背景前一章节，先系统的讲解了关于Retrofit实现当中的主要技术动态代理，本篇详细结合动态代理在Retrofit中的应用，扩展到结合RxJava来使用Retrofit源码解析-动态代理思路要深入研究一款开源项目最好的入口就是它所... 查看详情
机器学习算法原理解析——分类(代码片段)
1. KNN分类算法原理及应用1.1 KNN概述K最近邻（k-NearestNeighbor，KNN）分类算法是最简单的机器学习算法。KNN算法的指导思想是“近朱者赤，近墨者黑”，由你的邻居来推断你的类型。本质上，KNN算法就是用距离来衡量... 查看详情
数据结构与算法之深入解析“贪心算法“的原理解析和算法实现(代码片段)
一、简介①贪心算法的基本概念贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，它所做出的仅仅是在某种意义上的局部最优解，它是最自然智慧的... 查看详情
转:机器学习算法原理解析-分类(代码片段)
...法；决策树；支持向量机；神经网络；1. KNN分类算法原理及应用1.1 KNN概述K最近邻（k-NearestNeighbor，KNN）分类算法是最简单的机器学习算法。KNN算法的指导思想是“近 查看详情
真实案例出发，再谈retrofit封装(代码片段)
...客项目代码：CameloeAnthony/Ant前言在使用了一段时间的Retrofit之后，今天终于在这里讲解到了网络的部分。目前开源的HTTP框架有很多，Volley，AndroidAsyncHttp，以及OkHttp+Retrofit等。而我在自己的使用中选择了Retrof... 查看详情
站在巨人的肩膀上--retrofit源码解析(代码片段)
上一篇站在巨人的肩膀上–Retrofit源码解析(一)主要是从Retrofit使用的基本API角度，去理清源码中大致的流程，可以说Retrofit是对OkHttp框架做了非常完美的封装，使用了大量的设计模式，使得Retrofit成为了一个简单易... 查看详情
最简单简洁高效的json数据解析
一.无图无真相二.主要代码1.导入jar包拷贝fastjson.jar包到projectlibs包下2.封装工具类JsonUtil.javapackagecom.example.parsejsondemo;importcom.alibaba.fastjson.JSON;importcom.alibaba.fastjson.JSONArray;importcom.alibaba.fastjson.J 查看详情
数据结构与算法之深入解析“拥有最多糖果的孩子”的求解思路与算法示例(代码片段)
一、题目要求给你一个数组candies和一个整数extraCandies，其中candies[i]代表第i个孩子拥有的糖果数目。对每一个孩子，检查是否存在一种方案，将额外的extraCandies个糖果分配给孩子们之后，此孩子有最多的糖果。注意，允许有多个... 查看详情
带你一步步剖析retrofit源码解析：一款基于okhttp实现的网络请求框架(代码片段)
OkHttp与Retrofit的区别与联系是怎样的？参考答案：OkHttp和Retrofit都是目前流行网络开源框架封装不同：Retrofit封装了具体的请求，线程切换以及数据转换。retrofit通过使用代理，外观，策略模式对okhttp进行了封装OkHttp是基于Http协议... 查看详情