lovejjfg
lovejjfg

Retrofit相关源码解析

Retrofit这个开源库出来也有一定年头了，记得之前还是在V1.0的版本的时候，之前在三月份也写过一个Retrofit的使用简析，那会儿正是1.0向2.0过渡的时候，所以新版本老版本对比了一下！时至今日，相关文章已经层出不穷了，今天主要是打开它的源码，了解一些细节的问题！

准备工作

基于版本：

compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0'

相关问题：

1、Retrofit是使用注解确定对应的请求方式和参数的，那么具体的url是怎么产生出来的的呢？

2、我们定义的是一个接口，那么Retrofit又是怎么生成对应的实现类的呢？

3、网络请求V2.0开始统一使用OkHttp了，那么异步回调到主线程是如何实现的？

4、同一个方法，支持Call 的返回类型，又可以支持Observable的返回类型，这个又是如何实现的？

5、同一个方法，支持不同的转换（Gson、Jackson、Moshi、FastJson等等）,这个又是如何实现的呢？

带着这些问题，我们可以更好的进行相关的源码分析

第一部分 Retrofit && ServiceMethod的创建

从Retrofit的构建方法开始说起

new Retrofit.Builder()
        .baseUrl("http://10.0.60.115:60321/1.0/")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .client(new OkHttpClient.Builder()
                .addInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        return chain.proceed(RequestUtils.createLoginJsonRequest(chain.request()));
                    }
                })
                .addNetworkInterceptor(
                        new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.HEADERS))
                .build())
        .build()
        .create(LoginApi.class);

这里就是显而易见的builder模，通过Builder去构建我们需要的一些必要数据（比如说baseUrl,callAdapter,Conver等等），接下来看看Builder里面具体做了些什么！！

调用Retrofit内部的Builder的空参数构造方法！：

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

Builder(Platform platform) {
      this.platform = platform;
      // 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());
}

在这里，又去调用了Platform.get()初始化了一个Platform,并把默认的转换器BuiltInConverters初始化并加入了集合中！！

那么问题来了，这个Platform是何方神圣，具体有撒作用？？顺藤摸瓜，这里开始介绍内部的第一个神秘嘉宾！！

Platform 初始化

private static final Platform PLATFORM = findPlatform();//初始化`Platform`的静态方法

Platform字面意思就是平台啦，所以Platform相当于一个抽象类，这个类里面有对应的实现类：Android iOS Java 8对应的是各种具体平台。

  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) {
    }
    try {
      Class.forName("org.robovm.apple.foundation.NSObject");
      return new IOS();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

可以看到，在调用findPlatform()方法之后就回去判断初始化对应的具体平台，具体的实现类就是上面说到的三个，Android Java iOS，你没有看错，还有iOS的(这里是用的Swift)，啧啧。。

  static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

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

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

各个不同的平台其实就是根据不同的环境初始化不同的MainThreadExecutor,像上面的Android平台当然就是获取主线程的Handler!!这里可以看到，在初始化Platform之后，通过Platform得到的ExecutorCallAdapterFactory的工厂的Executor其实就是运行在主线程的Executor！

Builder的默认构造函数基本上讲完了！其实就是通过对应的平台构建了一个具体的Platform，通过这个Platform构建出了对应平台的主线程队列的线程池，方便后面的方法回调到主线程中！这里基本上也可以回答第三个问题了，异步怎么回调到主线程的！

添加baseUrl

public Builder baseUrl(HttpUrl baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  List pathSegments = baseUrl.pathSegments();
  if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
  }
  this.baseUrl = baseUrl;
  return this;
}

这里没撒说的，就是检测一下url的格式，然后完成赋值！

addConverterFactory && addCallAdapterFactory

/** Add converter factory for serialization and deserialization of objects. */
public Builder addConverterFactory(Converter.Factory factory) {
  converterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

/**
 * Add a call adapter factory for supporting service method return types other than {@link
 * Call}.
 */
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  adapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

这里忍不住必须说两句了，这两个方法套路是完全一样——适配器模式，CallAdapter是请求Call对应的适配器，CallAdapter.Factory是创建对应CallAdapter的抽象工厂！！ Converter是解析的转换器，这里提供了三种转换场景，responseBodyConverter、requestBodyConverter、stringConverter。Converter.Factory则是Convert的抽象工厂，这样利于我们的后期扩展，比如说外国人肯定没有写对应FastJson的Covert,但是它提供了工厂的嘛，我们继承这个抽象工厂，实现出来就好了！！

RxJavaCallAdapterFactory

在RxJavaCallAdapterFactory这个工厂中，又定义了两种 ,一种是SimpleCallAdapter另外一种是ResultCallAdapter,

    //SimpleCallAdapter
    @Override public  Observable adapt(Call call) {
  Observable observable = Observable.create(new CallOnSubscribe<>(call)) //
      .flatMap(new Func1, Observable>() {
        @Override public Observable call(Response response) {
          if (response.isSuccessful()) {
            return Observable.just(response.body());
          }
          return Observable.error(new HttpException(response));
        }
      });
  if (scheduler != null) {
    return observable.subscribeOn(scheduler);
  }
  return observable;
}

//ResultCallAdapter
@Override public  Observable> adapt(Call call) {
  Observable> observable = Observable.create(new CallOnSubscribe<>(call)) //
      .map(new Func1, Result>() {
        @Override public Result call(Response response) {
          return Result.response(response);
        }
      }).onErrorReturn(new Func1>() {
        @Override public Result call(Throwable throwable) {
          return Result.error(throwable);
        }
      });
  if (scheduler != null) {
    return observable.subscribeOn(scheduler);
  }
  return observable;
}

通俗的说其实就是根据返回值类型判断返回的Observable是否需要处理一下对应的Response！！使用flatMap()将其包装为一个新的Observable返回！！

Retrofit在创建的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();
  }

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

  // Make a defensive copy of the adapters and add the default Call adapter.
  List adapterFactories = new ArrayList<>(this.adapterFactories);
  //添加完之后再添加一个defaultCallAdapterFactory
  adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

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

//这个方法是上面提到的platform里面的方法，通过这个方法，将主线程的线程池和ExecutorCallAdapterFactory关联起来了！！
  CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
    if (callbackExecutor != null) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    return DefaultCallAdapterFactory.INSTANCE;
  }

到这里，Builder的创建过程分析完毕，总结起来就是创建出具体的Platform,通过具体的Platform创建出主线程的线程池，然后构建出默认的ExecutorCallAdapterFactory,另外就是添加对应的CallAdapter.Factory(比如说RxJavaCallAdapterFactory 等)和Converter.Factory!

生成接口的代理对象

build()方法创建对应的Retrofit之后就是create(Class service)的方法，这里就是生成对应的接口的代理类的方法！！

  @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  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();

          @Override public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

可以看到，在调用create()方法之后，是通过Proxy生成对应的动态代理！这里就很好说咯，在对应的invoke()的方法中完成具体的请求！

如果Java的动态代理不清楚或者已经忘记了的亲们，这里先简单脑补一下，代理的对应方法最后都会交给InvocationHandler这个类，并通过invoke(Object proxy, Method method, Object... args)的方法去执行相关的逻辑，这里的Method是对应具体方法的信息摘要，反射对象，里面包含了method的名称，参数类型，包括注解那些反正是应有尽有啦！这个args就是具体的方法参数了！

接下来就要注意啦，在创建好了Retrofit之后，在生成动态代理之后，咱们的请求方法还没有构建出来呢！所以呢，接下来肯定就是构建相关的请求方法咯！！

但是明确看到，在返回动态代理之前我们看到这里有一个判断validateEagerly，而且对应的Builder 对外提供了一个设置的方法！

/**
 * When calling {@link #create} on the resulting {@link Retrofit} instance, eagerly validate
 * the configuration of all methods in the supplied interface.
 */
public Builder validateEagerly(boolean validateEagerly) {
  this.validateEagerly = validateEagerly;
  return this;
}

这个方法到底是来做撒的呢？英语好的应该都看明白了！我先绕个关子不讲了！！

直接到代理的invoke()方法中，这里有两个条件判断，第一个是判断返回的类型如果就是Object，那就撒都不搞了，直接执行！

第二个判断如果这个方法是Default的，这个主要是针对java8来说得呢！所以重点还是要跳过到最下面！

ServiceMethod serviceMethod = loadServiceMethod(method);

ServiceMethod的创建

继上面说过的Platform之后，ServiceMethod是我们开始讲解的第二个类了！这里开始创建出对应的ServiceMethod对象，到这个方法里面具体看看！

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

举个例子，比如说我们在LoginApi这个接口里面定义了两个方法：

@POST("users")//https://api.bmob.cn/1/ 注册用户
Call registerUser( @Body UserBean bean);
@GET("getUserInfo")//https://api.bmob.cn/1/用户登陆
Observable> login(@QueryMap Map map);

那么当我们执行login()方法的时候，就会创建Retrofit，并且创建这个LoginApi的动态代理，然后调用login()方法，那么这里loadServiceMethod(Method method)中的method方法就是login()这个方法的对象。然后通过ServiceMethod.Builder去构建这个具体的ServiceMethod。

//ServiceMethod.Builder的构造方法
public Builder(Retrofit retrofit, Method method) {
  this.retrofit = retrofit;
  this.method = method;
  this.methodAnnotations = method.getAnnotations();//获取方法的对应注解@retrofit2.http.POST(value=files/{fileName})
  this.parameterTypes = method.getGenericParameterTypes();//获取方法参数的类型
  this.parameterAnnotationsArray = method.getParameterAnnotations();//获取方法参数的注解
}

接下来重点看看ServiceMethod.Builder.builder()的构建过程！这里算是Retrofit里面比较重要的一块了吧，因为它要开始拼接url、确定返回类型、明确CallAdapter和responseConverte！

  public ServiceMethod build() {
      //1、获取对应的callAdapter
      callAdapter = createCallAdapter();
      //2、获取对应的response的类型
      responseType = callAdapter.responseType();
      //3、创建response的转换器
      responseConverter = createResponseConverter();
      for (Annotation annotation : methodAnnotations) {
        //4、根据方法的注解（GET POST）开始具体的解析
        parseMethodAnnotation(annotation);
      }
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
          ..........

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
          ........
        //5、解析对应的方法参数注解
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

      return new ServiceMethod<>(this);
    }

  • 1、获取对应的callAdapter

      private CallAdapter createCallAdapter() {
        //获取返回值的Type,后面会用到
        Type returnType = method.getGenericReturnType();
        ......
        Annotation[] annotations = method.getAnnotations();
        try {
                  //调用retrofit的方法
          return retrofit.callAdapter(returnType, annotations);
        } catch (RuntimeException e) { // Wide exception range because factories are user code.
          throw methodError(e, "Unable to create call adapter for %s", returnType);
        }
      }
     //callAdapter()方法最终调用nextCallAdapter()来确定具体的callAdapter
    public CallAdapter nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
      ....

      int start = adapterFactories.indexOf(skipPast) + 1;
      for (int i = start, count = adapterFactories.size(); i < count; i++) {
                //get是抽象方法，由具体的factory去实现
        CallAdapter adapter = adapterFactories.get(i).get(returnType, annotations, this);
        if (adapter != null) {
          return adapter;
        }
      }
     .....
    }

前面在说Retrofit的初始化的时候，就说了默认会添加ExecutorCallAdapterFactory，如果我们添加了RxJava支持了添加一个RxJavaCallAdapterFactory的话，那我们这里就有两个CallAdapter了，那么Retrofit是如何明确到底应该使用哪个Adapter的呢？（问题四）相关的答案都在get()的方法中！我们可以看看这两个Factory里面具体的get方法是怎么处理的！

      //ExecutorCallAdapterFactory中
        @Override
      public CallAdapter> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        //可以处理Call的返回类型
        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);
          }
        };
      }

      //RxJavaCallAdapterFactory中
        @Override
      public CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        Class rawType = getRawType(returnType);
        String canonicalName = rawType.getCanonicalName();
        boolean isSingle = "rx.Single".equals(canonicalName);
        boolean isCompletable = "rx.Completable".equals(canonicalName);
        //可以处理 Observable rx.Single rx.Completable的类型
        if (rawType != Observable.class && !isSingle && !isCompletable) {
          return null;
        }
      ....
      }

答案很是清晰明了啊，不同的adapter在get()中处理不同的逻辑！

  • 2、获取对应的response的类型

这里的response其实就是之前的获取到的returnType在获取到的里面的具体类型，比如说returnType是Call,那么这里就获取到对应的UserInfo，相关方法封装放在Utils这个工具类中滴！！

  • 3、创建response的转换器

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


    public  Converter nextResponseBodyConverter(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;
    }
  }
  ....
  }

这里其实和前面的创建CallAdapter的原理是一致的！最后调用Retrofit的responseBodyConverter()方法，最后调用nextResponseBodyConverter()的方法，这里这个行为模式就是传说中的责任链模式吧！如果添加了多个，json解析的是要放最后面的，因为它是来者不拒的了！！

  • 4、根据方法的注解（GET POST）开始具体的解析
    到这里就要开始解析方法上的对应注解了！

比如说下面这个Get请求：

@GET("news/before/{date}")
Observable getBeforeDailyStories(@Path("date") String date);

在通过parseMethodAnnotation()方法之后，会继续执行parseHttpMethodAndPath("GET", ((GET) annotation).value(), false)的方法！

    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);
        if (!Void.class.equals(responseType)) {
          throw methodError("HEAD method must use Void as response type.");
        }
      } 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("@Headers annotation is empty.");
        }
        headers = parseHeaders(headersToParse);
      } else if (annotation instanceof Multipart) {
        if (isFormEncoded) {
          throw methodError("Only one encoding annotation is allowed.");
        }
        isMultipart = true;
      } else if (annotation instanceof FormUrlEncoded) {
        if (isMultipart) {
          throw methodError("Only one encoding annotation is allowed.");
        }
        isFormEncoded = true;
      }
    }

在parseHttpMethodAndPath()中进行httpMethod、hasBody、relativeUrl、relativeUrlParamNames的赋值！

    private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      ...
      this.httpMethod = httpMethod;//GET
      this.hasBody = hasBody;//false
      ...
      this.relativeUrl = value;//news/before/{date}
      this.relativeUrlParamNames = parsePathParameters(value);
    }

最后一个parsePathParameters()需要我们着重看一下，到这就要进行相关{date}的替换了！

  static Set parsePathParameters(String path) {
    //static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
    Matcher m = PARAM_URL_REGEX.matcher(path);
    Set patterns = new LinkedHashSet<>();
    while (m.find()) {
      patterns.add(m.group(1));
    }
    return patterns;
  }

因为{date}这一块是需要替换成方法参数里面对应的那个具体值的，这里通过relativeUrlParamNames()的方法，先将{date}取出存入了set集合中！！方便后面根据方法上对应的参数进行替换！！

解析对应的方法参数

接下来就是解析方法对应的参数的注解了：

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

这里出现了一个新的类ParameterHandler，这也是第三个需要介绍的类了！

ParameterHandler

Retrofit相关源码解析_第1张图片
ParameterHandler.png

如图所示，ParameterHandler它是一个抽象类，有这么多具体的实现小弟来管理某个具体参数！里面还有一个抽象方法apply()需要每个子类去实现的。这个方法将在后面将具体参数封装到RequestBuilder里面。在上面举例的方法：

  //parameterCount=1，parameterTypes[0]=String.class
   getBeforeDailyStories(@Path("date") String date)

所以最后就是执行parseParameter(0,String,Path)，并且返回的就是ParameterHandler的对象！接下来具体看内部是怎么操作的。

    private ParameterHandler parseParameter(
        int p, Type parameterType, Annotation[] annotations) {
      ParameterHandler result = null;
      for (Annotation annotation : annotations) {
        ParameterHandler annotationAction = parseParameterAnnotation(
            p, parameterType, annotations, annotation);

        if (annotationAction == null) {
          continue;
        }

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

        result = annotationAction;
      }

      if (result == null) {
        throw parameterError(p, "No Retrofit annotation found.");
      }

      return result;
    }

这里接着去调用parseParameterAnnotation()的方法，这也是ParameterHandler具体创建的方法！

    private ParameterHandler parseParameterAnnotation(
    int p, Type type, Annotation[] annotations, Annotation annotation) {
      ...

      } else if (annotation instanceof Path) {
      ...
        gotPath = true;

        Path path = (Path) annotation;
        String name = path.value();
        validatePathName(p, name);

        Converter converter = retrofit.stringConverter(type, annotations);
        //创建出对应的PathParameterHandler！！
        return new ParameterHandler.Path<>(name, converter, path.encoded());

      } .......

      return null; // Not a Retrofit annotation.
    }

这里会根据不同的类型创建不同的Convert,比如说解析Path就是使用StringConver，并且会先调用validatePathName()的方法去判断之前的Set集合里面是否有这个值，如果有，那么就创建出一个ParameterHandler.Path的对象！
同理解析Body的时候就会去调用nextRequestBodyConverter()的方法最终确认对应的Convert,就这样，最后创建出了ParameterHandler.Body这个具体的ParameterHandler对象！并且相关方法的参数的注解也解析出来并封装到了parameterHandlers数组中！

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

到了这里，ServiceMethod的初始化完成，那么每次都去辛辛苦苦的构建这些注解和参数是不是太累了？！所以必须把它缓存起来咯！这里也是上面提出的那个validateEagerly和eagerlyValidateMethods()问题的答案：如果我们需要尽快构建出每个方法的ServiceMethod,那么就将validateEagerly设置为true就好了！

第二部分 HTTP请求 响应 转换

经过上面一系列的准备工作，接下来就是开始相关的网络请求了！回到Retrofit的代理方法中:

 //上面已经创建好对应的ServiceMethod了！
ServiceMethod serviceMethod = loadServiceMethod(method);
//初始化OkHttpCall 
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
//执行具体的call
return serviceMethod.callAdapter.adapt(okHttpCall);

OkHttpCall

没有记错的话，OkHttpCall是我们要介绍的第四个对象了！也是比较重要的一个对象了，OkHttpCall 实现了 Call接口，内部持有okhttp3.Call的引用，所以可以理解为它是OkHttp的Call的代理对象！

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

这里构建出一个具体的OkHttpCall的对象!然后调用了serviceMethod.callAdapter.adapt(okHttpCall)这个方法，接下来着重分析这个方法做了些什么操作！
adapt()是CallAdapter里面的抽象方法，由具体的子类实现！如果我们返回的是Call类型的，那么由上面第一部分分析，ServiceMethod这里就是是用的ExecutorCallAdapterFactory！那么到ExecutorCallAdapterFactory中看看具体的实现逻辑！！

  @Override 
  public  Call adapt(Call call) {
      return new ExecutorCallbackCall<>(callbackExecutor, call);
  }

这里又返回了一个ExecutorCallbackCall的对象！这里的callbackExecutor就是在讲初始化Platform创建的！
当我们调用具体的方法时:

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

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

        }
    });

其实就是调用ExecutorCallbackCall里面的对应方法咯！

 @Override 
 public void enqueue(final Callback callback) {
  if (callback == null) throw new NullPointerException("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);
        }
      });
    }
  });
}

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

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

通过上面的方法就可以完全明白为什么enqueue的方法都是在主线程上的了！！

这里的delegate就是之前传入的OkHttpCall对象，所以这里又会去执行OkHttpCall里面的enqueue()方法，绕了半天，终于又回到了OkHttpCall里面了！

  @Override 
public void enqueue(final Callback callback) {
    ....
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          //如果call没有创建那么就去创建！
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          failure = creationFailure = t;
        }
      }
    }

    ....

    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

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

      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

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

这个方法有点儿长，主要是判断有木有创建okhttp3.Call，没有就去创建，创建了就调用call的call.enqueue()方法，最后再将结果通过传入的Callback回调出去！

RequestBuilder

先说okhttp3.Call的创建：

call = rawCall = createRawCall();

这里调用了OkHttpCall里面的createRawCall()方法：

  private okhttp3.Call createRawCall() throws IOException {
    //首先创建出okhttp3.Request 
    Request request = serviceMethod.toRequest(args);
    //通过request构建 okhttp3.Call
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

那么从这里开始，这些任务又回到了ServiceMethod这个类中了！所以说ServiceMethod完全服务于Http请求响应的相关过程！

    /** Builds an HTTP request from method arguments. */
  Request toRequest(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 requestBuilder.build();
  }
 
 
它构建出一个RequestBuilder的类，这也是第五个需要讲解的类了！看名字都知道它就是用来构建Request的Builder啦！,构建出Builder之后，注意这次是带上具体的参数过来的，所以它会进行参数的封装，构建出最终要去请求的url!!之前有说过对应的每个参数注解已经封装到ParameterHandler这个类中了，这里就需要遍历parameterHandlers这个数组，完成对每一个参数的具体赋值，赋值其实也很简单，就是依次调用各个ParameterHandler的apply(requestBuilder, arg)方法，apply()方法其实就是调用之前构建好的Convert将对应的参数（arg）解析成Request里面具体需要的对象！里面StringConvert居多！比如之前说到的@Body的情况(第一部分的结尾)！，因为Body你也可以传入一个Bean对象，所以不一定使用的是StringConvert，这里它会通过nextRequestBodyConverter()遍历寻找合适Convert。
 
 
 
 
  
 
   
 
    Retrofit相关源码解析_第2张图片 
   
 
  
 
  

    Convert.png 
  
 
 
 
 
 
 
比如说调用了GsonRequestBodyConverter中的convert方法完成相关解析：
 
 
      @Override 
      public RequestBody convert(T value) throws IOException {
        Buffer buffer = new Buffer();
        Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
        JsonWriter jsonWriter = gson.newJsonWriter(writer);
        adapter.write(jsonWriter, value);
        jsonWriter.close();
        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
      }

 
 
接着就是调用requestBuilder.build()的方法了！
 
 
Request build() {
            //1.构建HttpUrl
            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.
              url = baseUrl.resolve(relativeUrl);
              if (url == null) {
                throw new IllegalArgumentException(
                    "Malformed URL. Base: " + baseUrl + ", Relative: " + relativeUrl);
              }
            }
            2.构建RequestBody
            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();
          }

 
 
到这里Request终于是构建好了！接下来是真正的去创建okhttp3.Call了！
 
 
okhttp3.Call call = serviceMethod.callFactory.newCall(request);

 
 
这里其实最终使用的是Retrofit里面构建的okhttp3.Call.Factory
 
 
okhttp3.Call.Factory callFactory = this.callFactory;
  if (callFactory == null) {
    callFactory = new OkHttpClient();
  }

 
 
Response
 
 
最后终于到结果的位置了，这个Response也是我们要介绍的第六个对象了！它算是okhttp.Response的一个装饰类吧！也是最后返回给调用者使用的类！
 
 
  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) {
      return Response.success(null, rawResponse);
    }

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

 
 
无论是同步或者异步的方法，最后总会通过parseResponse()的方法将okhttp3.Response包装为Response对象返回！！而具体的解析又会交给ServiceMethod里面的的toResponse()去处理！！
 
 
    T toResponse(ResponseBody body) throws IOException {
        return responseConverter.convert(body);
      }

 
 
其实就是调用之前确认好的responseConverter去解析对应的Body!
 到这里，http请求完成，结果也被封装为指定的对象返回了！
 
 
总结
 
 
 
  
 
   
 
    Retrofit相关源码解析_第3张图片 
   
 
  
 
  

    Retrofit.png 
  
 
 
 
 
1、Call(接口)：向服务器发送请求并返回响应的调用；
 2、CallAdapter(接口)：Call的适配器，将Call适配为不同的类型返回（Call、Observable）；
 3、CallBack(接口)：顾名思义Call的回调,Call执行时的回调；
 4、Converter(接口)：数据转换器，将一个对象转化另外一个对象；
 5、CallAdapter.Factory(接口)：CallAdapter的工厂，通过get()方法获取CallAdapter,使用adapt()执行对应的Call请求；
 6、Converter.Factory(抽象类) ： 数据转换器Converter的工厂；
 
 
     
  
  •  responseBodyConverter：将ResponseBody转换为具体的对象。
    •  
  
  •  requestBodyConverter ： 将对应的Body，Part和PartMap注解转换为RequestBody(OkHttp3)，以便http请求的时候使用。
    •  
  
  •  StringConverter：将Field，FieldMap 值，Header，Path，Query,和QueryMap值转化为String，以便http请求的时候使用。
    •  
 
 
 
7、ParameterHandler ： 方法参数的处理类；
 
 
8、ServiceMethod ：请求方法的生成处理类，用于确定CallAdapter、ResponseConverter，生成具体的请求Request,解析对应的Response数据，算是一个灰常重要的类了；
 9、Platform：确认不同运行环境的类；
 10、OkHttpCall ：实现Call接口，是okhttp3.Call的代理类，获取传入的Call，通过Retrofit.callFactory执行Call请求，获取数据并使用ResponseConverter进行解析；
 
 
再回到之前说的那些问题上：
 1、Retrofit是使用注解确定对应的请求方式和参数的，那么具体的url是怎么产生出来的的呢？
 （ServiceMethod里面的相关处理）
 2、我们定义的是一个接口，那么Retrofit又是怎么生成对应的实现类的呢？
 （动态代理）
 3、网络请求V2.0开始统一使用OkHttp了，那么异步回调到主线程是如何实现的？
 （MainThreadExecutor）
 4、同一个方法，支持Call的返回类型，又可以支持Observable
 的返回类型，这个又是如何实现的？
 （确定对应CallAdapter！）
 5、同一个方法，支持不同的转换（Gson、Jackson、Moshi、FastJson等等）,这个又是如何实现的呢？
 （确定对应的Convert！）
 
 
搞了这么久，学习到什么呢？从一开始的一脸懵逼到最后的暗自窃喜，这也算是一种进步吧！其中不得不提的是各种设计模式的使用，模块间解耦和扩展的思想！创建型的抽象工厂模式、Builder模式；结构性的代理模式、adapter模式、装饰者模式；行为性的责任链模式等等。。
 
 
---- Edit By Joe ----
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Retrofit相关源码解析)

        

            

                
    
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • html 中如何使用 uniapp 的部分方法
                        某公司摸鱼前端
htmluni-app前端
                        
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 水泥质量纠纷案代理词
                        徐宝峰律师

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

                        
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
    
                    
    • 
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • python os 环境变量
                        CV矿工
python开发语言numpy
                        
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    
                    
    • 
                    
  • 【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    
                    
    • 
                    
  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。
                        那一叶秋

                        
    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
    
                    
    • 
                    
  • 在Ubuntu中编译含有JSON的文件出现报错
                        芝麻糊76
Linuxkill_buglinuxubuntujson
                        
    在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
    
                    
    • 
                    
  • 4招写出高价值文章
                        zhiliner

                        
    文章写得泛泛是因为思考得不够深，思考得越深文章会越有价值。拿到一个主题一定要去深入挖掘事件背后的东西，比如人物困境以及趋势性的东西。写作过程中有几个深度思考的方法一、解剖，让旧素材焕发新意作为一个写作者，我们能够做的最大贡献，就是给出自己看世界的角度。解剖其实就是把这个话题相关的信息都列出来，详细的列出来，看清楚它的内部。我们看到一个老话题或者一段旧素材的时候，不要只看这个素材或者话题本身，一定要
    
                    
    • 
                    
  • 【从浅识到熟知Linux】Linux发展史
                        Jammingpro
从浅学到熟知Linuxlinux运维服务器
                        
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
    
                    
    • 
                    
  • 2023-08-08
                        2023梦启支教团张牧泽

                        
    学汉字历史，行传统书法——中国矿业大学梦启支教团梦启三班开展书法文化课7月20日上午8时，中国矿业大学梦启支教团在贵州省金沙县西洛街道彩虹小学开展了“书法文化”课程。该课程意在向孩子们传授汉字演变的相关知识，围绕书法发展历史讲解不同时期的字形字体特点。此课程由梦启支教团成员王耀民讲授，梦启三班全体成员参加。中国文字的发展有数千年的历史，从早期雏形的象形文字到殷商时期的甲骨文、金文，再到西周、秦朝的
    
                    
    • 
                    
  • 《吹牛大王历险记》读书随笔
                        赵炳森

                        
    这本书的作者是埃·拉斯伯戈·毕尔格。（没查到相关内容，好像他只写过《吹牛大王历险记》。）最让人百思不得其解的是他居然能自己拉自己的辫子出泥潭？！我觉得自己拉自己的辫子只会把自己的辫子拉断，而不会飞出泥潭。（问:图片中底下的屁股为什么插了一根钢针？）屁股底下居然有根钢针？在泥潭应该是滑滑的吧，可是他怎么能夹紧马肚呢？马肚子应该是在马的下方。还有如果能从泥潭里把连人带马都给拽出来的话，他力气肯定很大，
    
                    
    • 
                    
  • 我与《红楼梦》‖纪念曹雪芹出生307周年！归海逸舟是周成功子阳佳乐
                        归海逸舟是周成功子阳佳乐

                        
    【今日作家推荐】中国古典小说之首《红楼梦》，其作者曹雪芹是文坛泰斗。约1715年5月28日，曹雪芹出生。所以，今天推荐的是中国人众所周知的作家——曹雪芹。曹雪芹在世界读者心目中也影响广大，可以与西方世界引以为豪的莎士比亚、歌德等媲美。1、我与《红楼梦》我一直想写一篇和《红楼梦》相关的文章，现在机会终于来了！《红楼梦》作为我国家喻户晓的文学名著，其影响是空前的。还在我很小的时候，姥姥经常讲《红楼梦》
    
                    
    • 
                    
  • 2020-8-19晨间日记：看过的电影
                        盐大虾

                        
    今天是周三起床：6点半就寝：11点天气：晴心情：正常纪念日：周三任务清单今日完成的任务，最重要的三件事：1.整理写过的文档2.电影《电灯泡》3.这就是街舞第三季第五期改进：早睡早起习惯养成：早睡早起，看书周目标·完成进度两篇文章学习·信息·阅读电影艺术发展史相关教材健康·饮食·锻炼吃了挺多零食，还喝了果粒橙，还是得少吃，多锻炼，不然会慢慢死掉的。人际·家人·朋友淡定交流，不放在心上。工作·思考专心
    
                    
    • 
                    
  • 系统架构设计师 需求分析篇二
                        AmHardy
软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
                        
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
    
                    
    • 
                    
  • 上班族可以做线上副业兼职有哪些？盘点7个适合上班族做的副业兼职！
                        高省APP大九

                        
    对于许多上班族来说，工资往往不能满足他们的生活需求，因此许多人开始寻找副业来增加收入。以下是一些适合普通人的副业赚钱路子，希望能给您带来一些灵感。1、做好物推荐现在很多职场人其实有大量的个人时间，只不过这些个人时间比较碎片化，他们不能够很好的利用起来，其实可以利用这些碎片化的时间去做副业，比如做好物推荐。在网上有很多的平台，比如头条抖音等等都开通了一个商品的分销功能，只要你发布相关的视频或者文章，
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • 网络通信流程
                        记得开心一点啊
服务器网络运维
                        
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
    
                    
    • 
                    
  • 4.C_数据结构_队列
                        荣世蓥
数据结构数据结构
                        
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
    
                    
    • 
                    
  • MongoDB知识概括
                        GeorgeLin98
持久层mongodb
                        
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    
                    
    • 
                    
  • 光盘文件系统 (iso9660) 格式解析
                        穷人小水滴
光盘文件系统iso9660denoGNU/Linuxjavascript
                        
    越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
    
                    
    • 
                    
  • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1)
                        穷人小水滴
游戏科幻设计
                        
    游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
    
                    
    • 
                    
  • 阅读《认知觉醒》读书笔记
                        就看看书

                        
    本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
    
                    
    • 
                    
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程
                        极客小张
stm32qt机器人物联网人机交互毕业设计c语言
                        
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
    
                    
    • 
                    
  • 冬练太极虽好，也需做好防护！
                        武当功夫传人郑师和

                        
    俗话说，夏练三伏，冬练三九，练功绝非一日之功，必须持之以恒。太极拳是一项集文化、养生、锻炼于一体的活动。现在已经进入冬季，许多喜爱太极拳的朋友们仍然会到户外进行锻炼。这种精神固然可嘉，但是也一定要注意一些相关事项，以避免影响养生的效果。冬季练拳要“养汗”太极拳一日不练十日空,入冬天冷以后要“守汗”，春生夏长秋收冬藏，冬天练功，万物冬藏，要养阳气，需要藏精，顺天时天利，盘拳时，身体微热要见汗，还没出
    
                    
    • 
                                
  • ASM系列四 利用Method 组件动态注入方法逻辑
                                    lijingyao8206
字节码技术jvmAOP动态代理ASM
                                    
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
    
                                
    • 
                                
  • java编程思想 --内部类
                                    百合不是茶
java内部类匿名内部类
                                    
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅 
  
1,内部类的创建  内部类是创建在类中的 
 
package com.wj.InsideClass;

/*
 * 内部类的创建
 */
public class CreateInsideClass {

	public CreateInsideClass(
    
                                
    • 
                                
  • web.xml报错
                                    crabdave
web.xml
                                    
    web.xml报错 
  
The content of element type "web-app" must match "(icon?,display- 
 name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
    
                                
    • 
                                
  • 泛型类的自定义
                                    麦田的设计者
javaandroid泛型
                                    
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 
采用泛型类，完成扩展。 
  例如有一个学生类 
    
Student{
  Student(){
   System.out.println("I'm a student.....");
  }
} 
 有一个老师类 
  

    
                                
    • 
                                
  • CSS清除浮动的4中方法
                                    IT独行者
JavaScriptUIcss
                                    
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 
1、结尾处加空div标签 clear:both      1   2   3   4      
.div 
1 
{ 
background 
: 
#000080 
; 
border 
: 
1px   
s
    
                                
    • 
                                
  • Cygwin使用windows的jdk 配置方法
                                    _wy_
jdkwindowscygwin
                                    
    1.[vim /etc/profile] 
   JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43) 
   PATH="$JAVA_HOME/bin:${PATH}" 
   CLAS
    
                                
    • 
                                
  • linux下安装maven
                                    无量
mavenlinux安装
                                    
    Linux下安装maven(转)  1.首先到Maven官网 
下载安装文件，目前最新版本为3.0.3，下载文件为 
apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 
 
2.进入下载文件夹，找到下载的文件，运行如下命令解压 
  tar -xvf  apache-maven-2.2.1-bin.tar.gz  
解压后的文件夹
    
                                
    • 
                                
  • tomcat的https 配置,syslog-ng配置
                                    aichenglong
tomcathttp跳转到httpssyslong-ng配置syslog配置
                                    
    1) tomcat配置https,以及http自动跳转到https的配置 
    1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令) 
     keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
    
                                
    • 
                                
  • 关于领号活动总结
                                    alafqq
活动
                                    
    关于某彩票活动的总结 
具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 
活动要求 
1，随机性，一定要有随机性； 
2，最少中奖概率，如果注数为3200注，则最多中4注 
3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 
4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 
 
解决方案 
1，事先产生随机数1000个，并打
    
                                
    • 
                                
  • java数据结构 冒泡排序的遍历与排序
                                    百合不是茶
java
                                    
    java的冒泡排序是一种简单的排序规则 
  
冒泡排序的原理：  
         比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样； 
        针对所有的元素重复以上的步骤，除了最后一个 
  
  
例题；将int array[] 
    
                                
    • 
                                
  • JS检查输入框输入的是否是数字的一种校验方法
                                    bijian1013
js
                                    
    如下是JS检查输入框输入的是否是数字的一种校验方法： 
<form method=post target="_blank">
   数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br>
</form>

    
                                
    • 
                                
  • Test注解的两个属性：expected和timeout
                                    bijian1013
javaJUnitexpectedtimeout
                                    
    JUnit4：Test文档中的解释： 
　　The Test annotation supports two optional parameters. 
　　The first, expected, declares that a test method should throw an exception. 
　　If it doesn't throw an exception or if it 
    
                                
    • 
                                
  • [Gson二]继承关系的POJO的反序列化
                                    bit1129
POJO
                                    
    父类 
  
  
package inheritance.test2;

import java.util.Map;

public class Model {
    private String field1;
    private String field2;

    private Map<String, String> infoMap
    
                                
    • 
                                
  • 【Spark八十四】Spark零碎知识点记录
                                    bit1129
spark
                                    
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 
ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中 
  
   
    
                                
    • 
                                
  • WAS各种脚本作用大全
                                    ronin47
WAS 脚本
                                    
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 
　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 
　　　 
获取下载 
这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
    
                                
    • 
                                
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句
                                    bylijinnan
switch
                                    
    借鉴网上的思路，用java实现： 
 




public class NoIfWhile {

	/**
	 * @param args
	 * 
	 * find x=1+2+3+....n
	 */
	public static void main(String[] args) {
		int n=10;
		int re=find(n);
		System.o
    
                                
    • 
                                
  • Netty源码学习-ObjectEncoder和ObjectDecoder
                                    bylijinnan
javanetty
                                    
    Netty中传递对象的思路很直观： 
Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 
那把对象序列化为字节流，就可以在Netty中传递对象了 
相应的从ChannelBuffer恢复对象，就是反序列化的过程 
 
Netty已经封装好ObjectEncoder和ObjectDecoder 
 
先看ObjectEncoder 
ObjectEncoder是往外发送
    
                                
    • 
                                
  • spring 定时任务中cronExpression表达式含义
                                    chicony
cronExpression
                                    
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 
代表含义            是否必须 允许的取值范围         &nb
    
                                
    • 
                                
  • Nutz配置Jndi
                                    ctrain
JNDI
                                    
    1、使用JNDI获取指定资源： 
 

var ioc = {
    dao : {
        type :"org.nutz.dao.impl.NutDao",
        args : [ {jndi :"jdbc/dataSource"} ]
    }
}
 
以上方法,仅需要在容器中配置好数据源,注入到NutDao即可. 
    
                                
    • 
                                
  • 解决 /bin/sh^M: bad interpreter: No such file or directory
                                    daizj
shell
                                    
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。 
  
分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 
解决： 
1）在windows下转换： 
利用一些编辑器如UltraEdit或EditPlus等工具
    
                                
    • 
                                
  • [转]for 循环为何可恨？
                                    dcj3sjt126com
程序员读书
                                    
      
Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 
不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
    
                                
    • 
                                
  • Android实用小技巧
                                    dcj3sjt126com
android
                                    
    1、去掉所有Activity界面的标题栏 
　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar" 
  
2、去掉所有Activity界面的TitleBar 和StatusBar  
　　修改AndroidManifes
    
                                
    • 
                                
  • Oracle 复习笔记之序列
                                    eksliang
Oracle 序列sequenceOracle sequence
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 
1.序列的作用 
 
 序列是用于生成唯一、连续序号的对象 
 一般用序列来充当数据库表的主键值 
 
2.创建序列语法如下： 
  
create sequence s_emp
start with 1      --开始值
increment by 1    --増长值
maxval
    
                                
    • 
                                
  • 有“品”的程序员
                                    gongmeitao
工作
                                    
    完美程序员的10种品质　　 
  
 完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的 
  
完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 
　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强 
  
（范围：用简单方式解决复杂问题）　　 
 
    
                                
    • 
                                
  • 使用KeleyiSQLHelper类进行分页查询
                                    hvt
sql.netC#asp.nethovertree
                                    
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
    
                                
    • 
                                
  • SVG 教程 （三）圆形，椭圆，直线
                                    天梯梦
svg
                                    
    SVG <circle>   SVG 圆形 - <circle> 
<circle> 标签可用来创建一个圆： 
下面是SVG代码： 
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <circle cx="100" c
    
                                
    • 
                                
  • 链表栈
                                    luyulong
java数据结构
                                    
    
public class Node {
	private Object object;
	private Node next;

	public Node() {
		this.next = null;
		this.object = null;
	}

	public Object getObject() {
		return object;
	}

	public
    
                                
    • 
                                
  • 基础数据结构和算法十：2-3 search tree
                                    sunwinner
Algorithm2-3 search tree
                                    
      
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
    
                                
    • 
                                
  • spring配置定时任务
                                    stunizhengjia
springtimer
                                    
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到： 
  
  
//------------------------定时任务调用的方法------------------------------
    /**
     * 存储过程定时器
    */
    publi
    
                                
    • 
                                
  • ITeye 8月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
8月试读活动回顾： 
http://webmaster.iteye.com/blog/2102830 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《跨终端Web》 
 
 
 
 gleams：http
    
                                
    •