javalong
javalong

Retrofit2源码分析(一)

前言

很早之前就开始接触Retrofit,自己也写了一个项目，但是一直没有深入研究过源码。

正文

版本

v2.0.2

项目结构

Retrofit2源码分析(一)_第1张图片
image.png

源码文件并不多，所以相对看起来还是比较方便的。

接口

阅读源码，我认为可以先了解作者定义的接口，这样可以有助于我们把握整体的流程，而且优秀的代码也是依赖接口而不是具体的实现。所以要阅读好的三方框架，最好是先了解他的接口，非常有助于源码阅读。

这里主要有4个接口。我简单介绍。

Call

真正发出请求的对象接口

CallAdapter

可以把Call对象转化为另外一个对象，如Observable

Callback

请求回调

Converter

把请求到的数据进行转化

先对所有的接口有个大致的了解

从一个简单的例子入手

  var retrofit = Retrofit.Builder()
                .baseUrl("http://www.baidu.com")
                .build()
        retrofit.create(TestApi::class.java)
                .test("http://www.baidu.com")
                .enqueue(object : Callback {
                    override fun onResponse(call: Call?, response: Response?) {
                    }

                    override fun onFailure(call: Call?, t: Throwable?) {
                    }
                })
...
interface TestApi{
   @GET
    fun test(@Url url:String):Call
    }
第一步: Retrofit构建

从上面例子中可以看出，创建Retrofit时候，只有添加有一个必须添加的baseUrl

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

除了可以添加baseUrl，其实还有2个可选的参数可以添加。

  1. Convert 的实现对象的工厂类
  2. CallAdapter的实现对象的工厂类

为了先最简单地了解整个源码的流程，所以这些可选的参数我都先不加。

可以从上面的build的代码中，可以看出，会创建一个
List和List用来存放传进来的参数。所以我们可以知道，Retrofit是可以传入多个CallAdapter.Factory和Converter.Factory

但是这里我们先不管，先往下走。

第二步:使用create创建方法接口
  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);
          }
        });
  }

使用Proxy.newProxyInstance创建了方法接口的一个代理对象，调用接口的方法的时候会进入invoke回调。

在返回这个代理对象之前，其实还有几行代码，我们可以简单看下

  1. 判断接口是否合法，方法数是否>0
    Utils.validateServiceInterface(service) 
 static  void validateServiceInterface(Class service) {
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }
    if (service.getInterfaces().length > 0) {
      throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
    }
  }
  1. 预先加载接口中所有方法
    eagerlyValidateMethods(service); 
private void eagerlyValidateMethods(Class service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        loadServiceMethod(method);
      }
    }
  }
第三步:调用接口中的方法

由第二步，我们可以知道，其实调用接口的方法，其实最后是调用了刚才创建的代理对象中的方法，然后进入了invoke方法。所以调用的其实是这一段代码。(一般情况下，是调用下面代码，但是也有一些例外，这里就不多介绍了)

 ServiceMethod serviceMethod = loadServiceMethod(method);
 OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
 return serviceMethod.callAdapter.adapt(okHttpCall);

由于这3行代码是最最关键的部分，这里做详细的分析。

  1. 加载接口方法
    ServiceMethod serviceMethod = loadServiceMethod(method); 
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;
  }

通过反射的Method对象获取一个ServiceMethod对象。

 注意：ServiceMethod: Adapts an invocation of an interface method into an HTTP call

首先会先从cache中获取一个ServiceMethod，如果没有，就创建一个新的ServiceMethod，再存入cache.

前面已经介绍了，就是ServiceMethod可以进行预先加载，默认使用懒加载，就是调用的时候再去加载，如果对方法调用有时间要求，可以使用预先加载，减少一些时间。

下面来看下ServiceMethod的创建

 public ServiceMethod build() {
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      responseConverter = createResponseConverter();

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

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

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

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

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

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

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

      return new ServiceMethod<>(this);
    }

创建ServiceMethod一共是2个参数,一个是Retrofit对象，一个是Method对象。

可以看到，这个方法中抛出了很多错误，如果使用过retrofit的人，可以看出，都是一些很常见的错误，大部分是注解用错了。

这里最重要的内容有3点

  1. 创建CallAdapter对象
  2. 创建Converter对象
  3. 对接口方法的注释进行解析

我们一个个来看下:

callAdapter = createCallAdapter();

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

retrofit.callAdapter(returnType, annotations)

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

  /**
   * Returns the {@link CallAdapter} for {@code returnType} from the available {@linkplain
   * #callAdapterFactories() factories} except {@code skipPast}.
   *
   * @throws IllegalArgumentException if no call adapter available for {@code type}.
   */
  public CallAdapter nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    checkNotNull(returnType, "returnType == null");
    checkNotNull(annotations, "annotations == null");

    int start = adapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      CallAdapter adapter = adapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }

    StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
        .append(returnType)
        .append(".\n");
    if (skipPast != null) {
      builder.append("  Skipped:");
      for (int i = 0; i < start; i++) {
        builder.append("\n   * ").append(adapterFactories.get(i).getClass().getName());
      }
      builder.append('\n');
    }
    builder.append("  Tried:");
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      builder.append("\n   * ").append(adapterFactories.get(i).getClass().getName());
    }
    throw new IllegalArgumentException(builder.toString());
  }

创建CallAdapter主要调用Retrofit中的nextCallAdapter,从adapterFactories中获取一个Factory去创建对应的CallAdapter.如果adapterFactories中所有的Factory都无法创建对应的CallAdapter则会报错。

前面介绍到adapterFactories，其实是可以在构建Retrofit对象的时候传入的。但是我们在前面并未传入CallAdapter.Factory,会不会直接报错呢？不会。

 public Retrofit build() {
     ...
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
      ...
    }
  }

在创建adapterFactories对象时，会预先在里面添加一个默认的CallAdapter.Factory。

创建Convert的过程和CallAdapter是一致的，我就不过多介绍了

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());
    }
...
List converterFactories = new ArrayList<>(this.converterFactories);
...

这里稍微有点不太一样的地方是，直接在创建Retrofit.Build对象的时候，就先把默认的Convert也就是BuiltInConverters添加到了converterFactories中。

由于Retrofit的注解比较多，所以对接口方法进行解析的过程也比较复杂。也不是整个框架的重点，所以我这里简单介绍下，其中有些地方还是值得我们去学习的。

解析注释，一共分2部分，一个是解析方法上的注释，一个是解析参数上的注释。

 public ServiceMethod build() {
      ...
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      ...
      for (int p = 0; p < parameterCount; p++) {
        ...
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }
      ...
      return new ServiceMethod<>(this);
    }
  1. 方法上的注释:
    parseMethodAnnotation 
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;
      }
    }

方法上的注释，确实是没啥好说的，就是判断不同的注解进行不同的解析，然后给自己的一些当前变量赋值。我就不说了。

  1. 方法参数上的注释
    parseParameter 
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;
    }

我就不再深入了，简单点说就是把参数上的注释转化为ParameterHandler对象。来看下ParameterHandler对象是啥。

abstract class ParameterHandler {
  abstract void apply(RequestBuilder builder, T value) throws IOException;
  final ParameterHandler> iterable() {
    return new ParameterHandler>() {
      @Override void apply(RequestBuilder builder, Iterable values) throws IOException {
     ...
    };
  }

  final ParameterHandler array() {
    return new ParameterHandler() {
      @Override void apply(RequestBuilder builder, Object values) throws IOException {
       ...
      }
    };
  }

  static final class RelativeUrl extends ParameterHandler {
    @Override void apply(RequestBuilder builder, Object value) {
      builder.setRelativeUrl(value);
    }
  }

  static final class Header extends ParameterHandler {
    ...
  }

  static final class Path extends ParameterHandler {
    ...
  }

  static final class Query extends ParameterHandler {
   ...
  }

  static final class QueryMap extends ParameterHandler> {
    ...
  }

  static final class Field extends ParameterHandler {
  ...
  }

  static final class FieldMap extends ParameterHandler> {
    ...
  }

  static final class Part extends ParameterHandler {
    ...
  }

  static final class RawPart extends ParameterHandler {
   ...
  }

  static final class PartMap extends ParameterHandler> {
   ...
  }

  static final class Body extends ParameterHandler {
    ...
}
 
 
所有的注解对应的都有自己的一个ParameterHandler实现。然后在里面进行解析。
 
 
解析方法注释得到的参数，以及解析方法参数的注释得到的ParameterHandler都是为了构建Request对象，代码如下:
 
 
 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();
  }
 
 
其中handlers[p].apply(requestBuilder, args[p]);是循环调用ParameterHandler这个抽象类的抽象方法。这里是值得我们学习的，依赖抽象类和接口，而不依赖具体的实现。
 
 
下面我们可以再回过头来看
 /** Adapts an invocation of an interface method into an HTTP call. */
 官方对ServiceMethod的说明。
 其实就我个人理解，是不是改成
 /** Adapts an invocation of an interface method into an HTTP request. */
 会更好点，因为ServiceMethod是把接口方法最终转化为一个Request对象而不是一个Call对象，当然也只是个人的理解。
 
 
 
 
     
  
  1. 创建OkHttpCall对象
     OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args); 
    2.  
 
 
 
 OkHttpCall(ServiceMethod serviceMethod, Object[] args) {
    this.serviceMethod = serviceMethod;
    this.args = args;
  }

 
 
OkHttpCall的构造方法很简单，OkHttpCall实现了Call接口。
 
 
     
  
  1. CallAdapter对Call对象进行转换
    2.  
 
 
 
在介绍这个之前，我们再回顾下前面的默认的CallAdapter。
 adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
 
 
这里需要了解Platform
 
 
class Platform {
 ..
  }
  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);
      }
    }
  }

  static class IOS extends Platform {
    ...
  }
}

 
 
对不同的平台进行不同的处理。这里肯定是Android平台，所以应该调用Android中的方法。
 
 
所以，默认的CallAdapter.Factory是ExecutorCallAdapterFactory
 下面我们继续刚才最重要的3句代码中的最后一句代码
 return serviceMethod.callAdapter.adapt(okHttpCall);
 
 
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
 ...
  @Override
  public 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);
      }
    };
  }

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

 
 
使用adapt方法后，返回了ExecutorCallbackCall这个对象
 
 
第四步:enqueue发送请求(execute大同小异)
 
 
具体的代码请看上面，从ExecutorCallbackCall开始。
 前面一步步走下来，我们已经知道，调用接口方法后，真正返回的是ExecutorCallbackCall对象。
 
 
调用enqueue方法，其实是调用创建ExecutorCallbackCall对象时传入的Call对象。我们在前面第三步时解析了最关键的三句代码，了解到了其实这里的Call对象，就是OkHttpCall对象。
 
 
@Override public void enqueue(final Callback callback) {
    ...
    call = rawCall = createRawCall();
    ...
    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
          ...
          response = parseResponse(rawResponse);
         ...
    });
  }
...
private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }
...
Response parseResponse(okhttp3.Response rawResponse) throws IOException {
     ...
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
     ...
  }

 
 
其中最重要的2个方法就是
 
 
     
  
  1. createRawCall
    2.  
  
  2. parseResponse
    3.  
 
 
 
这里我们分别来分析下。
 
 
 
 
createRawCall
 这里主要调用了serviceMethod.toRequest(args)其实我们在前面已经介绍过了，ServiceMethod中的toRequest就是把前面解析完成的参数，转化为对应的Request，这里就不多说了。
 
 
这里我们还要了解serviceMethod.callFactory是什么？
 ServiceMethod.java
 
 
...
 ServiceMethod(Builder builder) {
    this.callFactory = builder.retrofit.callFactory();
     ...
  }

 
 
Retrofit.java
 
 
...
 public Builder client(OkHttpClient client) {
      return callFactory(checkNotNull(client, "client == null"));
    }

    /**
     * Specify a custom call factory for creating {@link Call} instances.
     * 

     * Note: Calling {@link #client} automatically sets this value.
     */
    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }
...
 public Retrofit build() {
      ...
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
      ...
...

 
 
由上代码可看出，ServiceMethod中的callFactory就是Retrofit中的callFactory，可以在构建Retrofit对象的时候传入，不传入默认为OkHttpClient。
 
 
所以
 okhttp3.Call call = serviceMethod.callFactory.newCall(request);
 这里的serviceMethod.callFactory其实就是OkHttpClient然后创建了一个Call对象。真正发起请求的也是这个Call对象。
 
 
这里可能会看起来有点糊涂，因为这里的Call是okhttp3.Call，而前面一直在说的Call是retrofit2.Call大家不要把这2个搞混了。
 
 
我们可以把这2个做一下对比会发现，它们的方法基本一致。
 
 
Retrofit我们可以理解为在okhttp3外面的一层封装，真正去发生http请求的还是原来的okhttp3 。
 
 
 
 
parseResponse
 代码在上面已贴出，其中最重要的一句是:
 T body = serviceMethod.toResponse(catchingBody);
 
 
...
this.responseConverter = builder.responseConverter;
...
T toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }
...

 
 
使用Convert对象把ResponseBody转化为另一个对象。由代码可以看出，ServiceMethod中的responseConverter也是来自Retrofit对象。也就是前面介绍的默认的Convert.Factory对象，也就是BuiltInConverters，产生的Convert对象。
 
 
final class BuiltInConverters extends Converter.Factory {
  @Override
  public Converter responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    if (type == ResponseBody.class) {
      if (Utils.isAnnotationPresent(annotations, Streaming.class)) {
        return StreamingResponseBodyConverter.INSTANCE;
      }
      return BufferingResponseBodyConverter.INSTANCE;
    }
    if (type == Void.class) {
      return VoidResponseBodyConverter.INSTANCE;
    }
    return null;
  }

 
 
在ServiceMethod中会根据方法的返回类型，在里面获取到对应的Convert对象。如果返回的类型没有相应的Convert则会返回null。
 Retrofit.java
 
 
 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 =
        //**在这里真正去获取对应的Convert**
          converterFactories.get(i).responseBodyConverter(type, annotations, this);
      if (converter != null) {
        //noinspection unchecked
        return (Converter) converter;
      }
    }

    StringBuilder builder = new StringBuilder("Could not locate ResponseBody converter for ")
        .append(type)
        .append(".\n");
    if (skipPast != null) {
      builder.append("  Skipped:");
      for (int i = 0; i < start; i++) {
        builder.append("\n   * ").append(converterFactories.get(i).getClass().getName());
      }
      builder.append('\n');
    }
    builder.append("  Tried:");
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      builder.append("\n   * ").append(converterFactories.get(i).getClass().getName());
    }
    throw new IllegalArgumentException(builder.toString());
  }

 
 
从代码中可以看出，如果返回为null，那么会从下一个Convert.Factory中去获取对应的Convert由于我们前面并未添加Convert.Factory，所以这里只有一个默认的BuiltInConverters，并且它只支持返回值是ResponseBody,Void这2种类型的或者注释中有Streaming的方法，否者会报错。
 
 
第五步:在Callback接口中对转换后的对象进行处理
 
 
到了这一步的时候其实源码代码已经分析的差不多了。但是前面提到的默认的
 CallAdapter.Factory也就是ExecutorCallAdapterFactory中其实有个细节刚才我没有细讲，现在可以回过去看。
 
 
 @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去执行真正的callback中的onResponse和onFailure**
          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);
            }
          });
        }
      });

 
 
我们往回追溯，看下callbackExecutor是什么
 
 
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);
      }
    }
  }

 
 
defaultCallbackExecutor其实就是把Runnable抛到主线程中去执行。
 所以在我们自己的Callback中的onResponse和onFailure已经都是在主线程中执行了。
 
 
总结
 
 
Retrofit的源码相对来说是比较少的，非常适合新手阅读(包括我)，可以快速体验阅读源码的乐趣，感觉对整个框架的使用都会得心应手。
 
 
另外自己也感受到了阅读源码的3个好方法。
 
 
     
  
  1. 先了解所有的接口，对整个框架有个大致的了解
    2.  
  
  2. 可以写一个简单的demo，一步步深入
    3.  
  
  3. 从后往前，想要知道一个变量的由来，可以往前追溯
    4.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Retrofit2源码分析(一))

        

            

                
    
                    
  • 基于LSTM的空气污染情况预测与可视化平台设计与实现
                        QQ346127357
javaweblstm人工智能rnn
                        
    一、选题来源及意义（一）选题来源改革开放以来，中国经济取得了举世瞩目的伟大成就。随着城市化进程的加快和工业发展的加速，空气污染问题已经成为影响我国城市居民生活质量的重要因素。但与此同时，以高能耗和高排放为代价的发展模式也给中国的环境治理带来了严峻挑战[1]。空气污染不仅对环境造成破坏，还对人类健康产生严重影响[2]。给人们的生产生活带来极大的困扰。现阶段，我国城市高度重视环境污染治理工作，并采取相
    
                    
    • 
                    
  • 终极秘诀：打破无代码状态的小方法
                        
前端javascript
                        
    终极秘诀：打破无代码状态的小方法大家有没有遇到过不想写代码或学习的时候呢？这种情况下，你们会选择放松还是停下来呢？我很好奇大家是怎么度过这段时间的。我个人的情况是，当我不想写代码或学习的时候，我会去探索一些我感兴趣的东西。比如说，最近我对BashTerminal路径配置很感兴趣。为什么会对这个感兴趣呢？因为我在vscode中使用git作为默认的终端，但是bash的路径看起来太长了，我总是想着怎么能
    
                    
    • 
                    
  • RabbitMQ怎么避免消息被重复消费
                        Amagi.
rabbitmq分布式
                        
    去重表的方案：为每条消息分配一个唯一的标识符（例如UUID）。消费者在处理消息时，可以将这个标识符存储在数据库中或者内存中，处理后再进行确认。如果系统重启或者重复消费了同一消息，消费者可以先检查标识符是否已存在，从而避免重复处理。MVCC多版本并发控制（乐观锁）：消息生产者在生产消息的时候带上数据的版本号
    
                    
    • 
                    
  • 在vmware esxi上安装openwrt
                        
openwrtesxi
                        
    前面写过一篇在台式机上安装openwrt的文章，最近又有了在VMWwareesxi上安装openwrt的需求。回看了下历史的文章，发现思路虽然给出了，但由于没有给出具体的软件下的链接，所以可能起到的帮助作用不大。本文将在给出安装方法的基础上，在最后给出软件的下载地址：下载资源vmware直接安装的文件格式是vmdk，而openwrt官方给出的是dmg格式。所以我们除了需要下载官网对应的dmg格式的
    
                    
    • 
                    
  • docker能用来做什么
                        Amagi.
docker容器
                        
    Docker可以用于多种场景和用途，主要包括：应用程序开发：开发人员可以使用Docker创建一致的开发环境，确保在不同机器上运行的应用程序具有相同的依赖和配置。微服务架构：Docker非常适合构建和管理微服务架构，允许将应用程序拆分为多个独立的服务，每个服务可以在自己的容器中运行。持续集成和持续交付（CI/CD）：Docker可以与CI/CD工具（如Jenkins、GitLabCI等）集成，自动化
    
                    
    • 
                    
  • 解决tsconfig.json配置paths, 却依然报错can't find module?
                        

                        
    NodeJs程序中若使用typescript经常会遇到一个问题,即明明在tsconfig.json里配置了paths映射，为啥import使用路径别名,例如@test/a.ts时，会报错can'tfindmodule'@test/a.ts'?其实根本原因在于typescript只负责编译期检查，而执行模块时，tsconfig.json配置的paths自然无法影响js的模块查找机制,故报错分享:要解
    
                    
    • 
                    
  • Leetcode高频 SQL 50 题（基础版）（一）
                        LiquoriceG
mysql
                        
    一、可回收且低脂的产品表：Products+-------------+---------+|ColumnName|Type|+-------------+---------+|product_id|int||low_fats|enum||recyclable|enum|+-------------+---------+product_id：是该表的主键（具有唯一值的列）。low_fats：   
    
                    
    • 
                    
  • python str byte 转换
                        LI4836
Python字符串python
                        
    bytes转字符串方式一b=b'\xe9\x80\x86\xe7\x81\xab'string=str(b,'utf-8')print(string)#逆火bytes转字符串方式二b=b'\xe9\x80\x86\xe7\x81\xab'string=b.decode()#第一参数默认utf8，第二参数默认strictprint(string)#逆火bytes转字符串方式三b=b'\xe9\x80
    
                    
    • 
                    
  • Spring Boot 整合 Knife4j：打造更优雅的 API 文档
                        十二同学啊
SpringBootspringboot后端java
                        
      在现代Web应用开发中，API文档的重要性不言而喻。清晰、准确、易用的API文档不仅可以方便开发者理解和使用API，还能提高团队协作效率。Knife4j是一个基于Swagger的增强型API文档工具，它可以为SpringBoot项目生成美观、易于交互的API文档，本文将介绍如何在SpringBoot项目中整合Knife4j，并提供详细的代码示例和最佳实践。一、为什么选择Knife4j？  Kn
    
                    
    • 
                    
  • MyBatis学习笔记
                        繁星依月
开发技术学习笔记mybatis学习笔记
                        
    MyBatis学习笔记MyBatis绪论功能：访问数据库相当于增强版JDBC官网：mybatis–MyBatis3|简介MyBatis环境JDK1.8MySQL5.7/8.0（经典！）maven3.6+IDEAMyBatis前序JDBC、MySQL、Java基础、Maven、JunitMyBatis简介什么是MyBatisMyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映
    
                    
    • 
                    
  • 【拒绝算法PUA】3065. 超过阈值的最少操作数 I
                        BigDark的笔记
#LEETCODE#每日一题算法
                        
    系列文章目录【拒绝算法PUA】0x00-位运算【拒绝算法PUA】0x01-区间比较技巧【拒绝算法PUA】0x02-区间合并技巧【拒绝算法PUA】0x03-LeetCode排序类型刷题【拒绝算法PUA】LeetCode每日一题系列刷题汇总-2025年持续刷新中C++刷题技巧总结：[温习C/C++]0x04刷题基础编码技巧文章目录系列文章目录LeetCode3065.超过阈值的最少操作数I链接题目解题
    
                    
    • 
                    
  • 后悔呀，自从用了SkyWalking分布式链路追踪，现在睡得越来越香了
                        Bad_Ape
java编程语言程序人生经验分享架构
                        
    本篇文章介绍链路追踪的另外一种解决方案Skywalking，文章目录如下：什么是Skywalking？上一篇文章介绍了分布式链路追踪的一种方式：SpringCloudSleuth+ZipKin，这种方案目前也是有很多企业在用，但是作为程序员要的追逐一些新奇的技术，Skywalking作为后起之秀也是值得大家去学习的。skywalking是一个优秀的国产开源框架，2015年由个人吴晟（华为开发者）开
    
                    
    • 
                    
  • Python 网络爬虫高级教程：分布式爬取与大规模数据处理
                        Milk夜雨
pythonpython爬虫网络
                        
    经过基础爬虫和进阶爬虫的学习，我们已经掌握了爬虫的基本原理、动态内容处理及反爬机制的应对。然而，当我们面对海量数据或需要高效爬取多个站点时，分布式爬虫和数据存储、处理能力就显得尤为重要。本篇博客将带你迈向网络爬虫的高级阶段，学习分布式爬取、大规模数据处理以及性能优化。一、分布式爬虫的概念1.什么是分布式爬虫？分布式爬虫是指通过多个节点协作完成大规模网页爬取任务的爬虫架构。它能有效解决以下问题：单台
    
                    
    • 
                    
  • 【SpringBoot】用一个常见错误说一下@RequestParam属性
                        
后端springboot
                        
    问题复现在开发过程中，我们经常会用到@RequestParam，我们常常会遇到另外一个问题。当需要特别多的请求参数时，我们往往会忽略其中一些参数是否可选。例如存在类似这样的代码：@RequestMapping(path="/hi4",method=RequestMethod.GET)publicStringhi4(@RequestParam("name")Stringname,@RequestPa
    
                    
    • 
                    
  • AI绘画工具介绍
                        编程小郭
ai作画
                        
    市面上AI绘画工具众多，它们利用深度学习和图像处理技术，为用户提供了丰富的创作体验和可能性。以下是对几款主流AI绘画工具的详细介绍及横向对比：一、主流AI绘画工具介绍Midjourney简介：Midjourney是一个独立的研究实验室，专注于人工智能绘图，被广泛应用于设计、艺术创作、广告制作等领域。特点：以其强大的图像生成能力和跨界融合的创新特点著称，能够根据文本描述和视觉输入生成兼具故事性与视觉
    
                    
    • 
                    
  • 文心一言vsGPT-4全面对比
                        编程小郭
文心一言chatgptjavapython人工智能ai
                        
    文心一言和GPT-4都是当前非常先进的人工智能语言模型，它们各自具有独特的特点和优势。以下是对这两款工具的全面比较：文心一言是由百度开发的一款大型人工智能语言模型，它基于强大的深度学习技术和海量的数据资源，具备出色的语言理解和生成能力。文心一言在中文处理方面尤为出色，能够准确理解中文语境和语义，生成流畅、自然的中文文本。文心一言还具备丰富的知识库和推理能力，能够回答各种问题，提供有用的信息和建议。
    
                    
    • 
                    
  • Gateway网关
                        胡尔摩斯.
后端springcloudjavagateway
                        
    GatewayGateway网关是微服务架构中的重要组件，作为所有微服务的统一入口，扮演着“门卫”的角色。它负责处理进入系统的所有请求，并根据预设的规则将请求路由到相应的微服务进行处理。(需要进行服务的注册与发现)官网地址:SpringCloudGatewayhttps://docs.spring.io/spring-cloud-gateway/docs/4.0.4/reference/html/
    
                    
    • 
                    
  • 应用"懒加载"模式，优化@Transactional事务性能
                        
程序员
                        
    背景在项目开发中，使用@Transactional注解来管理事务非常方便，且优雅。但是也存在一个问题：长事务问题很多被@Transactional标记的方法，实际上并不需要进行数据库操作，或者说，它们在执行的很长一段时间内都不会真正触发数据库访问。举个例子，我们的业务逻辑可能如下：@ServicepublicclassOrderService{@Transactionalpublicvoidpro
    
                    
    • 
                    
  • 求质因数个数
                        程序猿小假
算法
                        
    什么是质因数？质因数：在数论里是指能整除给定正整数的质数。也就是说，如果一个质数是某个数的因数，那么这个质数就是这个数的质因数。例如，对于数字12，它的因数有1、2、3、4、6、12。其中2和3是质数，所以12的质因数是2和3。如何求一个数有多少个质因数呢？举一个例子，方便大家理解~例：求2024有几个质因数？1.从最小的质数开始尝试分解最小的质数是2，我们先看2024能否被2整除。2024/2=
    
                    
    • 
                    
  • 揭秘Fluss核心功能 - 底层存储和查询
                        
java
                        
    大家好，我是大圣。Fluss提供了可靠的底层存储设计与灵活的查询更新机制。然而，这一切听起来似乎很复杂，里面有太多看似晦涩的技术名词——比如日志表（LogTablet）、键值表（KvTablet）、Tablet、TabletServer等等。那么，Fluss的存储到底是怎么运作的？本文将从一个具体的数据例子出发，带你逐步了解Fluss的底层存储逻辑，以及查询和更新数据时，系统背后的变化过程。从一个
    
                    
    • 
                    
  • Dart语言的软件工程
                        Code侠客行
包罗万象golang开发语言后端
                        
    Dart语言的软件工程引言随着技术的快速发展，各种编程语言层出不穷。Dart语言作为Google开发的一种现代编程语言，近年来获得了越来越多的关注。其在移动应用开发、网页开发以及后端服务等领域的广泛应用，使得Dart在软件工程中扮演了越来越重要的角色。在本文中，我们将深入探讨Dart语言的特性、生态系统以及在实际软件工程中的应用。Dart语言简介Dart是一种面向对象、类定义的编程语言，具有明确的
    
                    
    • 
                    
  • Objective-C语言的语法糖
                        Quantum&Coder
包罗万象golang开发语言后端
                        
    Objective-C语言的语法糖引言语法糖是编程语言设计中的一个重要概念。它指的是一种可以使得代码更易读和易写的语法形式。对于程序员来说，语法糖就像是糖衣，让一些看似复杂的逻辑变得简单明了。在编程语言中，好的语法糖能够提高开发效率，降低代码的复杂度。在这篇文章中，我们将深入探讨Objective-C语言中的语法糖，如何利用这些语法糖来优化我们的代码结构和可读性。一、Objective-C简介1.
    
                    
    • 
                    
  • Lua语言的数据结构
                        Quantum&Coder
包罗万象golang开发语言后端
                        
    Lua语言的数据结构及其应用引言Lua是一种轻量级的编程语言，因其简单易学和高效灵活而广受欢迎。尤其在游戏开发、嵌入式系统以及其他需要高性能的场合中，Lua常常作为脚本语言被使用。在Lua中，数据结构的设计充分考虑了其简洁性与高效性，使得开发者能够更方便地进行各种数据处理。本文将深入探讨Lua语言中的主要数据结构及其应用，帮助读者更好地理解和使用Lua。Lua的数据结构概述Lua主要提供了两种内置
    
                    
    • 
                    
  • MATLAB语言的数据库交互
                        Quantum&Coder
包罗万象golang开发语言后端
                        
    MATLAB语言的数据库交互引言在当今数据驱动的时代，掌握数据库的使用和管理是非常重要的。MATLAB作为一种强大的数值计算和数据分析工具，广泛应用于科学研究、工程设计和数据分析等领域。为了更有效地处理和分析数据，MATLAB提供了与各类数据库交互的功能。本文将探讨MATLAB语言如何与数据库进行交互，包括连接数据库、执行SQL查询、读取和写入数据等基本操作，并结合实例进行详细说明，以帮助读者理解
    
                    
    • 
                    
  • 云手机：虚拟技术的革命性应用与实体手机的优劣对比
                        云云321
智能手机服务器矩阵线性代数安全
                        
    在近年来，随着互联网的火速发展，云手机作为一种新兴的技术产品，在游戏行业特别是手游市场中掀起了一股热潮。云手机，顾名思义，是架设在ARM虚拟服务器上的手机，其独特的虚拟技术为用户带来了前所未有的使用体验。那么，云手机与实体手机相比，究竟有哪些优劣呢？让我们来一探究竟。云手机的优势应用不占本地内存实体手机中，应用的安装和运行都会占用手机的内存空间。随着用户下载的应用越来越多，内存空间往往会变得捉襟见
    
                    
    • 
                    
  • 蓝桥杯模拟赛第二届题目
                        敲代码的啦哇嘻
蓝桥杯职场和发展
                        
    1.如果一个数p是个质数，同时又是整数a的约数，则p称为a的一个质因数。请问，2024的最大的质因数是多少？2.对于两个整数a,b，既是a的整数倍又是b的整数倍的数称为a和b的公倍数。公倍数中最小的正整数称为a和b的最小公倍数。请问，2024和1024的最小公倍数是多少？3.两个数按位异或是指将这两个数转换成二进制后，最低位与最低位异或作为结果的最低位，次低位与次低位异或作为结果的次低位，以此类推
    
                    
    • 
                    
  • 亚矩阵云手机:搭建TikTok视频矩阵的高效解决方案
                        云云321
矩阵智能手机线性代数
                        
    随着TikTok在全球范围内的快速崛起，越来越多的企业和个人创作者开始重视这一平台的推广营销潜力。TikTok视频作为一种有效的营销策略，通过多个账号的矩阵协同运营，能够显著提升品牌影响力和内容传播效果。而亚矩阵云手机，作为一种创新的云手机技术解决方案，为TikTok视频矩阵的搭建提供了强大的支持。TikTok视频矩阵概述TikTok视频矩阵是指通过创建和管理多个TikTok账号，形成一个相互协同
    
                    
    • 
                    
  • 云手机能用来干什么？云手机在跨境电商领域的用途
                        云云321
智能手机线性代数安全服务器矩阵
                        
    近年来，随着云手机的兴起，云技术越来越多的应用在我们工作和生活当中。云手机是一种在云端运行的手机，所有的运算和存储都在服务器上完成，用户端只是起到输入和输出的作用。作为一种全新的技术，它具体有哪些应用场景呢？作为跨境电商领域的从业者，我们能用亚矩阵云手机做什么呢？亚矩阵云手机是海外市场营销的好工具对跨境电商来说最大的困境是没有流量，怎么样增加产品的曝光，让全球60亿人看到我们的产品是每个外贸企业都
    
                    
    • 
                    
  • 最近，大模型岗位爆了。。。
                        IT猫仔
人工智能学习ai
                        
    重磅消息，国资委打响了国内AI第一枪！宣布央企将把发展AI放在全局统筹地位上，并加快建设一批智能算力中心。这意味着传统行业又迎来了一次大洗牌，这个过程需要大量AI人才！！现在国内头部人工智能公司已经开始用AI数字人助力各行各业，央企+交互数字人将成今年一整年的趋势。除此之外，知名大厂也都在布局AI市场。懂AI的程序员年薪已经翻到80w-96w!风口之下，与其焦虑被行业淘汰，不如先人一步掌握AI大模
    
                    
    • 
                    
  • 职工管理系统c++
                        LE715
c++开发语言
                        
    职工管理系统一.头文件部分职工抽象类worker.h老板类boss.h普通员工类employee.h经理类manager.h职工管理类workerManager.h二.源文件部分老板类boss.cpp普通员工类employee.cpp经理类manager.cpp职工管理类workerManager.cpp职工管理系统.cpp三.系统运行界面职工管理系统职工管理系统可以用来管理公司内所有员工的信息本
    
                    
    • 
                                
  • java解析APK
                                    3213213333332132
javaapklinux解析APK
                                    
    解析apk有两种方法 
1、结合安卓提供apktool工具，用java执行cmd解析命令获取apk信息 
2、利用相关jar包里的集成方法解析apk 
 
这里只给出第二种方法，因为第一种方法在linux服务器下会出现不在控制范围之内的结果。 
 
 

public class ApkUtil
{
	/**
	 * 日志对象
	 */
	private static Logger	 
    
                                
    • 
                                
  • nginx自定义ip访问N种方法
                                    ronin47
nginx 禁止ip访问
                                    
    　　　因业务需要，禁止一部分内网访问接口，　由于前端架了F5，直接用deny或allow是不行的，这是因为直接获取的前端Ｆ５的地址。 
　　　所以开始思考有哪些主案可以实现这样的需求，目前可实施的是三种： 
　　　一：把ip段放在redis里，写一段lua 
          二：利用geo传递变量，写一段
    
                                
    • 
                                
  • mysql timestamp类型字段的CURRENT_TIMESTAMP与ON UPDATE CURRENT_TIMESTAMP属性
                                    dcj3sjt126com
mysql
                                    
    timestamp有两个属性，分别是CURRENT_TIMESTAMP 和ON UPDATE CURRENT_TIMESTAMP两种，使用情况分别如下： 
  
1. 
  
CURRENT_TIMESTAMP  
  
当要向数据库执行insert操作时，如果有个timestamp字段属性设为 
  
CURRENT_TIMESTAMP，则无论这
    
                                
    • 
                                
  • struts2+spring+hibernate分页显示
                                    171815164
Hibernate
                                    
    分页显示一直是web开发中一大烦琐的难题，传统的网页设计只在一个JSP或者ASP页面中书写所有关于数据库操作的代码，那样做分页可能简单一点，但当把网站分层开发后，分页就比较困难了，下面是我做Spring+Hibernate+Struts2项目时设计的分页代码，与大家分享交流。 
 
　　1、DAO层接口的设计，在MemberDao接口中定义了如下两个方法： 
 
 
 
 
 
public in
    
                                
    • 
                                
  • 构建自己的Wrapper应用
                                    g21121
rap
                                    
            我们已经了解Wrapper的目录结构，下面可是正式利用Wrapper来包装我们自己的应用，这里假设Wrapper的安装目录为:/usr/local/wrapper。 
  
        首先，创建项目应用 
  
&nb
    
                                
    • 
                                
  • [简单]工作记录_多线程相关
                                    53873039oycg
多线程
                                    
         最近遇到多线程的问题,原来使用异步请求多个接口(n*3次请求)     方案一 使用多线程一次返回数据,最开始是使用5个线程,一个线程顺序请求3个接口,超时终止返回     缺点       测试发现必须3个接
    
                                
    • 
                                
  • 调试jdk中的源码，查看jdk局部变量
                                    程序员是怎么炼成的
jdk 源码
                                    
    转自：http://www.douban.com/note/211369821/ 
  
 学习jdk源码时使用-- 
    学习java最好的办法就是看jdk源代码，面对浩瀚的jdk（光源码就有40M多，比一个大型网站的源码都多）从何入手呢，要是能单步调试跟进到jdk源码里并且能查看其中的局部变量最好了。 
 
可惜的是sun提供的jdk并不能查看运行中的局部变量
    
                                
    • 
                                
  • Oracle RAC Failover 详解
                                    aijuans
oracle
                                    
    Oracle RAC 同时具备HA(High Availiablity) 和LB(LoadBalance). 而其高可用性的基础就是Failover(故障转移). 它指集群中任何一个节点的故障都不会影响用户的使用，连接到故障节点的用户会被自动转移到健康节点，从用户感受而言， 是感觉不到这种切换。 
 
 Oracle 10g RAC 的Failover 可以分为3种： 
 1. Client-Si
    
                                
    • 
                                
  • form表单提交数据编码方式及tomcat的接受编码方式
                                    antonyup_2006
JavaScripttomcat浏览器互联网servlet
                                    
    原帖地址：http://www.iteye.com/topic/266705 
 
form有2中方法把数据提交给服务器，get和post,分别说下吧。 
（一）get提交 
1.首先说下客户端（浏览器）的form表单用get方法是如何将数据编码后提交给服务器端的吧。 
   
对于get方法来说，都是把数据串联在请求的url后面作为参数，如：http://localhost:
    
                                
    • 
                                
  • JS初学者必知的基础
                                    百合不是茶
js函数js入门基础
                                    
    JavaScript是网页的交互语言,实现网页的各种效果, 
JavaScript 是世界上最流行的脚本语言。

JavaScript 是属于 web 的语言，它适用于 PC、笔记本电脑、平板电脑和移动电话。

JavaScript 被设计为向 HTML 页面增加交互性。

许多 HTML 开发者都不是程序员，但是 JavaScript 却拥有非常简单的语法。几乎每个人都有能力将小的 
    
                                
    • 
                                
  • iBatis的分页分析与详解
                                    bijian1013
javaibatis
                                    
            分页是操作数据库型系统常遇到的问题。分页实现方法很多，但效率的差异就很大了。iBatis是通过什么方式来实现这个分页的了。查看它的实现部分，发现返回的PaginatedList实际上是个接口，实现这个接口的是PaginatedDataList类的对象，查看PaginatedDataList类发现，每次翻页的时候最
    
                                
    • 
                                
  • 精通Oracle10编程SQL(15)使用对象类型
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用对象类型
 */
--建立和使用简单对象类型
--对象类型包括对象类型规范和对象类型体两部分。
--建立和使用不包含任何方法的对象类型
CREATE OR REPLACE TYPE person_typ1 as OBJECT(
  name varchar2(10),gender varchar2(4),birthdate date
);

drop type p
    
                                
    • 
                                
  • 【Linux命令二】文本处理命令awk
                                    bit1129
linux命令
                                    
    awk是Linux用来进行文本处理的命令，在日常工作中，广泛应用于日志分析。awk是一门解释型编程语言，包含变量，数组，循环控制结构，条件控制结构等。它的语法采用类C语言的语法。 
  awk命令用来做什么？ 
1.awk适用于具有一定结构的文本行，对其中的列进行提取信息 
2.awk可以把当前正在处理的文本行提交给Linux的其它命令处理，然后把直接结构返回给awk 
3.awk实际工
    
                                
    • 
                                
  • JAVA(ssh2框架)+Flex实现权限控制方案分析
                                    白糖_
java
                                    
      
目前项目使用的是Struts2+Hibernate+Spring的架构模式，目前已经有一套针对SSH2的权限系统，运行良好。但是项目有了新需求：在目前系统的基础上使用Flex逐步取代JSP，在取代JSP过程中可能存在Flex与JSP并存的情况，所以权限系统需要进行修改。 
【SSH2权限系统的实现机制】 
权限控制分为页面和后台两块：不同类型用户的帐号分配的访问权限是不同的，用户使
    
                                
    • 
                                
  • angular.forEach
                                    boyitech
AngularJSAngularJS APIangular.forEach
                                    
    angular.forEach   描述:   循环对obj对象的每个元素调用iterator, obj对象可以是一个Object或一个Array. Iterator函数调用方法: iterator(value, key, obj), 其中obj是被迭代对象，key是obj的property key或者是数组的index，value就是相应的值啦. (此函数不能够迭代继承的属性.)   
    
                                
    • 
                                
  • java-谷歌面试题-给定一个排序数组，如何构造一个二叉排序树
                                    bylijinnan
二叉排序树
                                    
    
import java.util.LinkedList;

public class CreateBSTfromSortedArray {

	/**
	 * 题目:给定一个排序数组，如何构造一个二叉排序树
	 * 递归
	 */

	public static void main(String[] args) {
		int[] data = { 1, 2, 3, 4, 
    
                                
    • 
                                
  • action执行2次
                                    Chen.H
JavaScriptjspXHTMLcssWebwork
                                    
    xwork 写道   <action name="userTypeAction" 
class="com.ekangcount.website.system.view.action.UserTypeAction"> 
<result name="ssss" type="dispatcher"> 
    
                                
    • 
                                
  • [时空与能量]逆转时空需要消耗大量能源
                                    comsci
能源
                                    
     
 
        无论如何,人类始终都想摆脱时间和空间的限制....但是受到质量与能量关系的限制,我们人类在目前和今后很长一段时间内,都无法获得大量廉价的能源来进行时空跨越..... 
 
        在进行时空穿梭的实验中,消耗超大规模的能源是必然
    
                                
    • 
                                
  • oracle的正则表达式(regular expression)详细介绍
                                    daizj
oracle正则表达式
                                    
        正则表达式是很多编程语言中都有的。可惜oracle8i、oracle9i中一直迟迟不肯加入，好在oracle10g中终于增加了期盼已久的正则表达式功能。你可以在oracle10g中使用正则表达式肆意地匹配你想匹配的任何字符串了。 
正则表达式中常用到的元数据(metacharacter)如下： 
^ 匹配字符串的开头位置。 
$ 匹配支付传的结尾位置。 
* 
    
                                
    • 
                                
  • 报表工具与报表性能的关系
                                    datamachine
报表工具birt报表性能润乾报表
                                    
    在选择报表工具时，性能一直是用户关心的指标，但是，报表工具的性能和整个报表系统的性能有多大关系呢？ 
要回答这个问题，首先要分析一下报表的处理过程包含哪些环节，哪些环节容易出现性能瓶颈，如何优化这些环节。 
  
一、报表处理的一般过程分析 
1、用户选择报表输入参数后，报表引擎会根据报表模板和输入参数来解析报表，并将数据计算和读取请求以SQL的方式发送给数据库。 
  
2、
    
                                
    • 
                                
  • 初一上学期难记忆单词背诵第一课
                                    dcj3sjt126com
wordenglish
                                    
    what 什么  
your 你 
name 名字 
my 我的 
am 是 
one 一 
two 二 
three 三 
four 四 
five 五 
class 班级，课 
  
six 六 
seven 七 
eight 八 
nince 九 
ten 十 
zero 零 
how 怎样 
old 老的 
eleven 十一 
twelve 十二 
thirteen 
    
                                
    • 
                                
  • 我学过和准备学的各种技术
                                    dcj3sjt126com
技术
                                    
    语言VB https://msdn.microsoft.com/zh-cn/library/2x7h1hfk.aspxJava http://docs.oracle.com/javase/8/C# https://msdn.microsoft.com/library/vstudioPHP http://php.net/manual/en/Html 
    
                                
    • 
                                
  • struts2中token防止重复提交表单
                                    蕃薯耀
重复提交表单struts2中token
                                    
    struts2中token防止重复提交表单 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年7月12日 11:52:32 星期日 
ht
    
                                
    • 
                                
  • 线性查找二维数组
                                    hao3100590
二维数组
                                    
    1.算法描述 
  
有序（行有序，列有序，且每行从左至右递增，列从上至下递增）二维数组查找，要求复杂度O(n) 
  
2.使用到的相关知识： 
结构体定义和使用，二维数组传递（http://blog.csdn.net/yzhhmhm/article/details/2045816） 
  
3.使用数组名传递 
这个的不便之处很明显，一旦确定就是不能设置列值 
  
//使
    
                                
    • 
                                
  • spring security 3中推荐使用BCrypt算法加密密码
                                    jackyrong
Spring Security
                                    
    spring security 3中推荐使用BCrypt算法加密密码了，以前使用的是md5， 
Md5PasswordEncoder 和 ShaPasswordEncoder，现在不推荐了，推荐用bcrpt 
Bcrpt中的salt可以是随机的，比如： 
 
 
 

int i = 0;
	while (i < 10) {
		String password = "1234
    
                                
    • 
                                
  • 学习编程并不难,做到以下几点即可!
                                    lampcy
javahtml编程语言
                                    
    不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 
1、确定目标 
学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
    
                                
    • 
                                
  • 架构师之mysql----------------用group+inner join,left join ,right join 查重复数据（替代in)
                                    nannan408
right join
                                    
    1.前言。 
  如题。 
2.代码 
(1)单表查重复数据,根据a分组 
  


SELECT m.a,m.b, INNER   JOIN （select a,b,COUNT(*) AS rank FROM test.`A` A   GROUP BY a HAVING rank>1 )k ON m.a=k.a



 
（2）多表查询 ， 
 使用改为le
    
                                
    • 
                                
  • jQuery选择器小结 VS 节点查找（附css的一些东西）
                                    Everyday都不同
jquerycssname选择器追加元素查找节点
                                    
    最近做前端页面，频繁用到一些jQuery的选择器，所以特意来总结一下： 
  
测试页面： 
<html>
	<head>
		<script src="jquery-1.7.2.min.js"></script>
		<script>
		/*$(function() {
			$(documen
    
                                
    • 
                                
  • 关于EXT
                                    tntxia
ext
                                    
      
ExtJS是一个很不错的Ajax框架，可以用来开发带有华丽外观的富客户端应用，使得我们的b/s应用更加具有活力及生命力。ExtJS是一个用 javascript编写，与后台技术无关的前端ajax框架。因此，可以把ExtJS用在.Net、Java、Php等各种开发语言开发的应用中。 
  
  
  
ExtJs最开始基于YUI技术，由开发人员Jack 
    
                                
    • 
                                
  • 一个MIT计算机博士对数学的思考
                                    xjnine
Math
                                    
     在过去的一年中，我一直在数学的海洋中游荡，research进展不多，对于数学世界的阅历算是有了一些长进。为什么要深入数学的世界？作为计算机的学生，我没有任何企图要成为一个数学家。我学习数学的目的，是要想爬上巨人的肩膀，希望站在更高的高度，能把我自己研究的东西看得更深广一些。说起来，我在刚来这个学校的时候，并没有预料到我将会有一个深入数学的旅程。我的导师最初希望我去做的题目，是对appe
    
                                
    •