Young_Allen
Young_Allen

Retrofit2源码试读（二）

1.文章介绍

Retrofit2+Rxjava2+Glide+MVP架构正是火热，以学习角度出发，分模块来熟悉下这种架构的各个模块源码以及实现方式。
什么情况下使用Retrofit2+Rxjava2呢？Retrofit2+Rxjava2的主要优势是它的解耦性，在项目越复杂时体现出的优势越明显。

2.干货

继续上一篇的分析，在本次分析中创建的是ExecutorCallAdapterFactory：

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

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

  @Override public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    // returnType在文章之前分析过 是Call ，getRawType返回是Call
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    //这里根据returnType本文返回为Call ，那么responseType就是DataModel
    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);
      }
    };
  }
  ...
}


传入的参数是Call，以下相当于通过反射获取泛型的参数DataModel：


 static Type getCallResponseType(Type returnType) {
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call or Call");
    }
    return getParameterUpperBound(0, (ParameterizedType) returnType);
  }

  static Type getParameterUpperBound(int index, ParameterizedType type) {
    Type[] types = type.getActualTypeArguments();
    if (index < 0 || index >= types.length) {
      throw new IllegalArgumentException(
          "Index " + index + " not in range [0," + types.length + ") for " + type);
    }
    Type paramType = types[index];
    if (paramType instanceof WildcardType) {
      return ((WildcardType) paramType).getUpperBounds()[0];
    }
    return paramType;
  }



可以看到在Retrofit中，如果不主动添加CallAdapter，那么声明的方法的返回值必须是Call类。这里本应该分析到了adapt，把数据转换成这个Call类型，这个函数在文章后面会用到这里先不分析。
 CallAdapter返回的参数responseType非常重要，就是泛型的实际类型，后面也会用得上。


网络请求适配后，还需要有数据格式的适配：


 //这里就把responseType用上了，记住是返回的实际类型，本文是DataModel
 Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);



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

  public  Converter responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
  }

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

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

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



和CallAdapter类似的处理，在未声明Converter时，默认有一个new BuiltInConverters()和platform.defaultConverterFactories()：


  List defaultConverterFactories() {
    return emptyList();
  }



defaultConverterFactories返回的是一个空的List，那么BuiltInConverters是否是默认使用的呢?


final class BuiltInConverters extends Converter.Factory {
  /** Not volatile because we don't mind multiple threads discovering this. */
  private boolean checkForKotlinUnit = true;

  @Override public @Nullable Converter responseBodyConverter(
      Type type, Annotation[] annotations, Retrofit retrofit) {
    //根据之前的分析 这里是Call泛型的实际类型 本文是DataModel
    if (type == ResponseBody.class) {
      return Utils.isAnnotationPresent(annotations, Streaming.class)
          ? StreamingResponseBodyConverter.INSTANCE
          : BufferingResponseBodyConverter.INSTANCE;
    }
    if (type == Void.class) {
      return VoidResponseBodyConverter.INSTANCE;
    }
    if (checkForKotlinUnit) {
      try {
        if (type == Unit.class) {
          return UnitResponseBodyConverter.INSTANCE;
        }
      } catch (NoClassDefFoundError ignored) {
        checkForKotlinUnit = false;
      }
    }
    return null;
  }
  ...
}



这里可以看到如果不配置Converter时只能对ResponseBody和Void做处理，显然本文的Demo必须要声明Converter能处理自定义的Class类型。
 在本文中通过Gson把json数据映射为对象，按如下配置：


addConverterFactory(GsonConverterFactory.create())



public final class GsonConverterFactory extends Converter.Factory {
  /**
   * Create an instance using a default {@link Gson} instance for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  /**
   * Create an instance using {@code gson} for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
  public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
  }

  private final Gson gson;

  private GsonConverterFactory(Gson gson) {
    this.gson = gson;
  }
  ...
}



GsonConverterFactory就是对Gson的封装处理，数据格式的适配函数如下：


  @Override
  public Converter responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }



  public  TypeAdapter getAdapter(TypeToken type) {
    TypeAdapter cached = typeTokenCache.get(type == null ? NULL_KEY_SURROGATE : type);
    if (cached != null) {
      return (TypeAdapter) cached;
    }

    Map, FutureTypeAdapter> threadCalls = calls.get();
    boolean requiresThreadLocalCleanup = false;
    if (threadCalls == null) {
      threadCalls = new HashMap, FutureTypeAdapter>();
      calls.set(threadCalls);
      requiresThreadLocalCleanup = true;
    }

    // the key and value type parameters always agree
    FutureTypeAdapter ongoingCall = (FutureTypeAdapter) threadCalls.get(type);
    if (ongoingCall != null) {
      return ongoingCall;
    }

    try {
      FutureTypeAdapter call = new FutureTypeAdapter();
      threadCalls.put(type, call);

      for (TypeAdapterFactory factory : factories) {
        TypeAdapter candidate = factory.create(this, type);
        if (candidate != null) {
          call.setDelegate(candidate);
          typeTokenCache.put(type, candidate);
          return candidate;
        }
      }
      throw new IllegalArgumentException("GSON cannot handle " + type);
    } finally {
      threadCalls.remove(type);

      if (requiresThreadLocalCleanup) {
        calls.remove();
      }
    }
  }



从上面的函数可以看到，从factories中去查找匹配的TypeAdapter。返回去看这个函数：


TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));



这里涉及到TypeToken：


  public static TypeToken get(Type type) {
    return new TypeToken(type);
  }

  TypeToken(Type type) {
    //这里传入的参数是Call泛型的实际类型，本文是DataModel
    this.type = $Gson$Types.canonicalize($Gson$Preconditions.checkNotNull(type));
    this.rawType = (Class) $Gson$Types.getRawType(this.type);
    this.hashCode = this.type.hashCode();
  }


  public static Type canonicalize(Type type) {
    // 很显然，本文可以通过这个TypeAdapter来转完成数据适配，这里type在本文中是DataModel
    if (type instanceof Class) {//原始类型
      Class c = (Class) type;
      return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

    } else if (type instanceof ParameterizedType) {//参数化类型
      ParameterizedType p = (ParameterizedType) type;
      return new ParameterizedTypeImpl(p.getOwnerType(),
          p.getRawType(), p.getActualTypeArguments());

    } else if (type instanceof GenericArrayType) {//数组类型 
      GenericArrayType g = (GenericArrayType) type;
      return new GenericArrayTypeImpl(g.getGenericComponentType());

    } else if (type instanceof WildcardType) {//通配符类型
      WildcardType w = (WildcardType) type;
      return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

    } else {
      // type is either serializable as-is or unsupported
      return type;
    }
  }

  public static Class getRawType(Type type) {
    // 很显然，本文直接返回DataModel
    if (type instanceof Class) {
      // type is a normal class.
      return (Class) type;

    } else if (type instanceof ParameterizedType) {
      ParameterizedType parameterizedType = (ParameterizedType) type;

      // I'm not exactly sure why getRawType() returns Type instead of Class.
      // Neal isn't either but suspects some pathological case related
      // to nested classes exists.
      Type rawType = parameterizedType.getRawType();
      checkArgument(rawType instanceof Class);
      return (Class) rawType;

    } else if (type instanceof GenericArrayType) {
      Type componentType = ((GenericArrayType)type).getGenericComponentType();
      return Array.newInstance(getRawType(componentType), 0).getClass();

    } else if (type instanceof TypeVariable) {
      // we could use the variable's bounds, but that won't work if there are multiple.
      // having a raw type that's more general than necessary is okay
      return Object.class;

    } else if (type instanceof WildcardType) {
      return getRawType(((WildcardType) type).getUpperBounds()[0]);

    } else {
      String className = type == null ? "null" : type.getClass().getName();
      throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
          + "GenericArrayType, but <" + type + "> is of type " + className);
    }
  }



在Gson初始化时添加了各种TypeAdapters：


Gson(final Excluder excluder, final FieldNamingStrategy fieldNamingStrategy,
      final Map> instanceCreators, boolean serializeNulls,
      boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe,
      boolean prettyPrinting, boolean lenient, boolean serializeSpecialFloatingPointValues,
      LongSerializationPolicy longSerializationPolicy,
      List typeAdapterFactories) {
    this.constructorConstructor = new ConstructorConstructor(instanceCreators);
    this.excluder = excluder;
    this.fieldNamingStrategy = fieldNamingStrategy;
    this.serializeNulls = serializeNulls;
    this.generateNonExecutableJson = generateNonExecutableGson;
    this.htmlSafe = htmlSafe;
    this.prettyPrinting = prettyPrinting;
    this.lenient = lenient;

    List factories = new ArrayList();

    // built-in type adapters that cannot be overridden
    factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
    factories.add(ObjectTypeAdapter.FACTORY);

    // the excluder must precede all adapters that handle user-defined types
    factories.add(excluder);

    // user's type adapters
    factories.addAll(typeAdapterFactories);

    // type adapters for basic platform types
    factories.add(TypeAdapters.STRING_FACTORY);
    factories.add(TypeAdapters.INTEGER_FACTORY);
    factories.add(TypeAdapters.BOOLEAN_FACTORY);
    factories.add(TypeAdapters.BYTE_FACTORY);
    factories.add(TypeAdapters.SHORT_FACTORY);
    TypeAdapter longAdapter = longAdapter(longSerializationPolicy);
    factories.add(TypeAdapters.newFactory(long.class, Long.class, longAdapter));
    factories.add(TypeAdapters.newFactory(double.class, Double.class,
            doubleAdapter(serializeSpecialFloatingPointValues)));
    factories.add(TypeAdapters.newFactory(float.class, Float.class,
            floatAdapter(serializeSpecialFloatingPointValues)));
    factories.add(TypeAdapters.NUMBER_FACTORY);
    factories.add(TypeAdapters.ATOMIC_INTEGER_FACTORY);
    factories.add(TypeAdapters.ATOMIC_BOOLEAN_FACTORY);
    factories.add(TypeAdapters.newFactory(AtomicLong.class, atomicLongAdapter(longAdapter)));
    factories.add(TypeAdapters.newFactory(AtomicLongArray.class, atomicLongArrayAdapter(longAdapter)));
    factories.add(TypeAdapters.ATOMIC_INTEGER_ARRAY_FACTORY);
    factories.add(TypeAdapters.CHARACTER_FACTORY);
    factories.add(TypeAdapters.STRING_BUILDER_FACTORY);
    factories.add(TypeAdapters.STRING_BUFFER_FACTORY);
    factories.add(TypeAdapters.newFactory(BigDecimal.class, TypeAdapters.BIG_DECIMAL));
    factories.add(TypeAdapters.newFactory(BigInteger.class, TypeAdapters.BIG_INTEGER));
    factories.add(TypeAdapters.URL_FACTORY);
    factories.add(TypeAdapters.URI_FACTORY);
    factories.add(TypeAdapters.UUID_FACTORY);
    factories.add(TypeAdapters.CURRENCY_FACTORY);
    factories.add(TypeAdapters.LOCALE_FACTORY);
    factories.add(TypeAdapters.INET_ADDRESS_FACTORY);
    factories.add(TypeAdapters.BIT_SET_FACTORY);
    factories.add(DateTypeAdapter.FACTORY);
    factories.add(TypeAdapters.CALENDAR_FACTORY);
    factories.add(TimeTypeAdapter.FACTORY);
    factories.add(SqlDateTypeAdapter.FACTORY);
    factories.add(TypeAdapters.TIMESTAMP_FACTORY);
    factories.add(ArrayTypeAdapter.FACTORY);
    factories.add(TypeAdapters.CLASS_FACTORY);

    // type adapters for composite and user-defined types
    factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
    factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
    this.jsonAdapterFactory = new JsonAdapterAnnotationTypeAdapterFactory(constructorConstructor);
    factories.add(jsonAdapterFactory);
    factories.add(TypeAdapters.ENUM_FACTORY);
    factories.add(new ReflectiveTypeAdapterFactory(
        constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));

    this.factories = Collections.unmodifiableList(factories);
  }



查找匹配的TypeAdapters核心代码如下：


for (TypeAdapterFactory factory : factories) {
   TypeAdapter candidate = factory.create(this, type);
   if (candidate != null) {
     call.setDelegate(candidate);
     typeTokenCache.put(type, candidate);
     return candidate;
   }
}



只有在TypeAdapter的create到匹配type时，才会使用该TypeAdapter。注意这里的type是声明泛型的实际类型，按本文的分析就是DataModel。
 对factories举个例子，例如：


   factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);



   public static final TypeAdapterFactory JSON_ELEMENT_FACTORY
      = newTypeHierarchyFactory(JsonElement.class, JSON_ELEMENT);

   /**
   * Returns a factory for all subtypes of {@code typeAdapter}. We do a runtime check to confirm
   * that the deserialized type matches the type requested.
   */
  public static  TypeAdapterFactory newTypeHierarchyFactory(
      final Class clazz, final TypeAdapter typeAdapter) {
    return new TypeAdapterFactory() {
      @SuppressWarnings("unchecked")
      @Override public  TypeAdapter create(Gson gson, TypeToken typeToken) {
        //从TypeToken源码可知，这里返回的就是实际类型，本文的DataModel
        final Class requestedType = typeToken.getRawType();
        if (!clazz.isAssignableFrom(requestedType)) {
          return null;
        }
        return (TypeAdapter) new TypeAdapter() {
          @Override public void write(JsonWriter out, T1 value) throws IOException {
            typeAdapter.write(out, value);
          }

          @Override public T1 read(JsonReader in) throws IOException {
            T1 result = typeAdapter.read(in);
            if (result != null && !requestedType.isInstance(result)) {
              throw new JsonSyntaxException("Expected a " + requestedType.getName()
                  + " but was " + result.getClass().getName());
            }
            return result;
          }
        };
      }
      @Override public String toString() {
        return "Factory[typeHierarchy=" + clazz.getName() + ",adapter=" + typeAdapter + "]";
      }
    };
  }



通过isAssignableFrom接口判断是否可以使用JSON_ELEMENT_FACTORY。很明显这里并不能，那么会使用哪个TypeAdapterFactory呢？继续分析，我们看到最后有一个ReflectiveTypeAdapterFactory：


  factories.add(new ReflectiveTypeAdapterFactory(
        constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));



  public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor,
      FieldNamingStrategy fieldNamingPolicy, Excluder excluder,
      JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory) {
    this.constructorConstructor = constructorConstructor;
    this.fieldNamingPolicy = fieldNamingPolicy;
    this.excluder = excluder;
    this.jsonAdapterFactory = jsonAdapterFactory;
  }

  @Override public  TypeAdapter create(Gson gson, final TypeToken type) {
    Class raw = type.getRawType();

    if (!Object.class.isAssignableFrom(raw)) {
      return null; // it's a primitive!
    }

    ObjectConstructor constructor = constructorConstructor.get(type);
    return new Adapter(constructor, getBoundFields(gson, type, raw));
  }

  private Map getBoundFields(Gson context, TypeToken type, Class raw) {
    Map result = new LinkedHashMap();
    if (raw.isInterface()) {
      return result;
    }

    Type declaredType = type.getType();
    while (raw != Object.class) {
      Field[] fields = raw.getDeclaredFields();
      for (Field field : fields) {
        boolean serialize = excludeField(field, true);
        boolean deserialize = excludeField(field, false);
        if (!serialize && !deserialize) {
          continue;
        }
        field.setAccessible(true);
        Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType());
        List fieldNames = getFieldNames(field);
        BoundField previous = null;
        for (int i = 0, size = fieldNames.size(); i < size; ++i) {
          String name = fieldNames.get(i);
          if (i != 0) serialize = false; // only serialize the default name
          BoundField boundField = createBoundField(context, field, name,
              TypeToken.get(fieldType), serialize, deserialize);
          BoundField replaced = result.put(name, boundField);
          if (previous == null) previous = replaced;
        }
        if (previous != null) {
          throw new IllegalArgumentException(declaredType
              + " declares multiple JSON fields named " + previous.name);
        }
      }
      type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass()));
      raw = type.getRawType();
    }
    return result;
  }



以上代码通过反射动态实现对Class类的映射，然后在read、write方法里面拆、组装数据：


public static final class Adapter extends TypeAdapter {
    private final ObjectConstructor constructor;
    private final Map boundFields;

    Adapter(ObjectConstructor constructor, Map boundFields) {
      this.constructor = constructor;
      this.boundFields = boundFields;
    }

    @Override public T read(JsonReader in) throws IOException {
      if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
      }

      T instance = constructor.construct();

      try {
        in.beginObject();
        while (in.hasNext()) {
          String name = in.nextName();
          BoundField field = boundFields.get(name);
          if (field == null || !field.deserialized) {
            in.skipValue();
          } else {
            field.read(in, instance);
          }
        }
      } catch (IllegalStateException e) {
        throw new JsonSyntaxException(e);
      } catch (IllegalAccessException e) {
        throw new AssertionError(e);
      }
      in.endObject();
      return instance;
    }

    @Override public void write(JsonWriter out, T value) throws IOException {
      if (value == null) {
        out.nullValue();
        return;
      }

      out.beginObject();
      try {
        for (BoundField boundField : boundFields.values()) {
          if (boundField.writeField(value)) {
            out.name(boundField.name);
            boundField.write(out, value);
          }
        }
      } catch (IllegalAccessException e) {
        throw new AssertionError(e);
      }
      out.endObject();
    }
  }



Gson就是这样动态实现了数据适配。


当调用了loadWeatherInfo(***)这个接口后，经过动态代理继而中转到HttpServiceMethod：


  private HttpServiceMethod(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,
      CallAdapter callAdapter,
      Converter responseConverter) {
    this.requestFactory = requestFactory;
    this.callFactory = callFactory;
    this.callAdapter = callAdapter;
    this.responseConverter = responseConverter;
  }

  @Override ReturnT invoke(Object[] args) {
    return callAdapter.adapt(
        new OkHttpCall<>(requestFactory, args, callFactory, responseConverter));
  }



最后我们看到实际上是调用到我们之前配置的callAdapter的adapt接口，之前我还特意标注了一下adapt这个接口是作什么用，刚好这里给出解释了。
 回去再看看adapt函数干什么了：


static final class ExecutorCallbackCall implements Call {
    final Executor callbackExecutor;
    final Call delegate;

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

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

      delegate.enqueue(new Callback() {
        @Override public void onResponse(Call call, final Response response) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

        @Override public void onFailure(Call call, final Throwable t) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

    @Override public boolean isExecuted() {
      return delegate.isExecuted();
    }

    @Override public Response execute() throws IOException {
      return delegate.execute();
    }

    @Override public void cancel() {
      delegate.cancel();
    }

    @Override public boolean isCanceled() {
      return delegate.isCanceled();
    }

    @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
    @Override public Call clone() {
      return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
    }

    @Override public Request request() {
      return delegate.request();
    }
  }



callbackExecutor.execute其实就是Handler.post，在ExecutorCallAdapterFactory的adapt方法里把Call代理给ExecutorCallbackCall了，ExecutorCallbackCall可以理解为Handler+Call的封装装，它的enqueue实际就是OkHttpCall.enqueue后把response通过主线程的Handler.post回调给应用。


至于为什么使用Handler，我自己的理解是：
 1.借用Handler的消息队列来对任务排序
 2.有某方法需要回调到主线程
 至少我目前只想到这两个用途，因为真正异步涉及到的线程调度都在OkHttpCall内部的线程池了。


        Call call = RetrofitUtils.getDeafault(WeatherService.WEATHERSERVICE_URL)
                .create(WeatherService.class)
                .loadWeatherInfo("101190201");
        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                DataModel model = response.body();
                DataModel.WeatherInfoBean bean = model.getWeatherinfo();
                Log.d(TAG, "onResponse:" + bean.getCity());
            }

            @Override
            public void onFailure(Call call, Throwable t) {
                Log.d(TAG, "onFailure:" + t.getMessage());
            }
        });



以上源码中的call实际上是一个ExecutorCallbackCall。
 而call.enqueue实际上就是OkHttpCall.enqueue处理，根据继承多态的原理：


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

    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          throwIfFatal(t);
          failure = creationFailure = t;
        }
      }
    }

    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

    if (canceled) {
      call.cancel();
    }

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

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

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

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



Retrofit2.0默认支持okhttp，可以看到Retrofit的enqueue实际上是依赖okhttp的enqueue实现的。通过okhttp创建了一个Call，并且把实际的网络请求让okhttp的队列去处理，最后把网络请求的结果通过callback返回给调用者。这里也可以感受到写代码不同的是，要么是在函数里面直接执行业务返回数据的同步方式，要么是先注册CallBack然后请求数据通过callback把数据回调回来的异步方式，而Retrofit是虽然调用了某个接口(比如本文的loadWeatherInfo)，但是并没有实际的去执行某个业务(比如从网络上去请求数据)，而是在execute或者enqueue的时候才真正的去执行实际业务(比如真正根据配置去创建一个网络请求)。


  private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }



requestFactory.create(args)就是创建一个Request，但是callFactory是在哪创建的呢？细心的人可能会在文章前面找到：


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

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



如果在Retrofit初始化时没有创建callFactory，就会默认使用OkHttpClient，这种情况的函数流程如下：


  @Override public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false /* for web socket */);
  }



  private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    this.client = client;
    this.originalRequest = originalRequest;
    this.forWebSocket = forWebSocket;
    this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
    this.timeout = new AsyncTimeout() {
      @Override protected void timedOut() {
        cancel();
      }
    };
    this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);
  }

  static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    // Safely publish the Call instance to the EventListener.
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
  }



那么在的OkHttpCall里面的call.enqueue调用在继承多态的特性下就是如下调用：


  @Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    // 很简单的事件回调 可以看出这个是在调用线程
    eventListener.callStart(this);
    // 真正的实现异步处理
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }



揭开异步机制的面纱:


  void enqueue(AsyncCall call) {
    synchronized (this) {
      readyAsyncCalls.add(call);
    }
    promoteAndExecute();
  }

  private boolean promoteAndExecute() {
    assert (!Thread.holdsLock(this));

    List executableCalls = new ArrayList<>();
    boolean isRunning;
    synchronized (this) {
      for (Iterator i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        AsyncCall asyncCall = i.next();

        if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
        if (runningCallsForHost(asyncCall) >= maxRequestsPerHost) continue; // Host max capacity.

        i.remove();
        executableCalls.add(asyncCall);
        runningAsyncCalls.add(asyncCall);
      }
      isRunning = runningCallsCount() > 0;
    }

    for (int i = 0, size = executableCalls.size(); i < size; i++) {
      AsyncCall asyncCall = executableCalls.get(i);
      asyncCall.executeOn(executorService());
    }

    return isRunning;
  }



Dispatcher默认的线程池：


  public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
  }



在Dispatcher内部先统计了正在执行的异步任务，来确保执行效率，然后把任务放在了线程池里执行。


    void executeOn(ExecutorService executorService) {
      assert (!Thread.holdsLock(client.dispatcher()));
      boolean success = false;
      try {
        executorService.execute(this);
        success = true;
      } catch (RejectedExecutionException e) {
        InterruptedIOException ioException = new InterruptedIOException("executor rejected");
        ioException.initCause(e);
        eventListener.callFailed(RealCall.this, ioException);
        responseCallback.onFailure(RealCall.this, ioException);
      } finally {
        if (!success) {
          client.dispatcher().finished(this); // This call is no longer running!
        }
      }
    }



AsyncCall继承于NamedRunnable：


  final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      this.responseCallback = responseCallback;
    }
    ...
    @Override protected void execute() {
      boolean signalledCallback = false;
      timeout.enter();
      try {
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
          responseCallback.onResponse(RealCall.this, response);
        }
      } catch (IOException e) {
        e = timeoutExit(e);
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
}



public abstract class NamedRunnable implements Runnable {
  protected final String name;

  public NamedRunnable(String format, Object... args) {
    this.name = Util.format(format, args);
  }

  @Override public final void run() {
    String oldName = Thread.currentThread().getName();
    Thread.currentThread().setName(name);
    try {
      execute();
    } finally {
      Thread.currentThread().setName(oldName);
    }
  }

  protected abstract void execute();
}



可以看到实际处理是调用execute，根据Java的继承多态特性，会调用到AsyncCall的execute，这里已经能看到数据的请求了，来看一下如何实现的：


  Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }



在这里添加了interceptors并且创建了一个RealInterceptorChain：


  @Override public Response proceed(Request request) throws IOException {
    return proceed(request, streamAllocation, httpCodec, connection);
  }

  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    if (index >= interceptors.size()) throw new AssertionError();

    calls++;

    // If we already have a stream, confirm that the incoming request will use it.
    if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must retain the same host and port");
    }

    // If we already have a stream, confirm that this is the only call to chain.proceed().
    if (this.httpCodec != null && calls > 1) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must call proceed() exactly once");
    }
    
    // Call the next interceptor in the chain.
    // index首次是0，然后index + 1实现链式调用
    RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
        connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
    // 这里在之前添加过client.interceptors()、BridgeInterceptor等
    Interceptor interceptor = interceptors.get(index);
    // 通过各种interceptor对数据做处理
    Response response = interceptor.intercept(next);

    // Confirm that the next interceptor made its required call to chain.proceed().
    if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
      throw new IllegalStateException("network interceptor " + interceptor
          + " must call proceed() exactly once");
    }

    // Confirm that the intercepted response isn't null.
    if (response == null) {
      throw new NullPointerException("interceptor " + interceptor + " returned null");
    }

    if (response.body() == null) {
      throw new IllegalStateException(
          "interceptor " + interceptor + " returned a response with no body");
    }

    return response;
  }



注意client.interceptors()是在最开始就处理的，比如声明的Log信息拦截器：


        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        OkHttpClient okHttpClient = builder.build();
        if (BuildConfig.DEBUG) {
            HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
            builder.addInterceptor(loggingInterceptor);
        }



通过一系列的interceptor，最终我们需要获取到网络请求到的数据，在最后一个interceptor CallServerInterceptor里：


 @Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    HttpCodec httpCodec = realChain.httpStream();
    StreamAllocation streamAllocation = realChain.streamAllocation();
    RealConnection connection = (RealConnection) realChain.connection();
    Request request = realChain.request();

    long sentRequestMillis = System.currentTimeMillis();

    realChain.eventListener().requestHeadersStart(realChain.call());
    httpCodec.writeRequestHeaders(request);
    realChain.eventListener().requestHeadersEnd(realChain.call(), request);

    Response.Builder responseBuilder = null;
    if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
      // If there's a "Expect: 100-continue" header on the request, wait for a "HTTP/1.1 100
      // Continue" response before transmitting the request body. If we don't get that, return
      // what we did get (such as a 4xx response) without ever transmitting the request body.
      if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
        httpCodec.flushRequest();
        realChain.eventListener().responseHeadersStart(realChain.call());
        responseBuilder = httpCodec.readResponseHeaders(true);
      }

      if (responseBuilder == null) {
        // Write the request body if the "Expect: 100-continue" expectation was met.
        realChain.eventListener().requestBodyStart(realChain.call());
        long contentLength = request.body().contentLength();
        CountingSink requestBodyOut =
            new CountingSink(httpCodec.createRequestBody(request, contentLength));
        BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);

        request.body().writeTo(bufferedRequestBody);
        bufferedRequestBody.close();
        realChain.eventListener()
            .requestBodyEnd(realChain.call(), requestBodyOut.successfulCount);
      } else if (!connection.isMultiplexed()) {
        // If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
        // from being reused. Otherwise we're still obligated to transmit the request body to
        // leave the connection in a consistent state.
        streamAllocation.noNewStreams();
      }
    }

    httpCodec.finishRequest();

    if (responseBuilder == null) {
      realChain.eventListener().responseHeadersStart(realChain.call());
      responseBuilder = httpCodec.readResponseHeaders(false);
    }

    Response response = responseBuilder
        .request(request)
        .handshake(streamAllocation.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();

    int code = response.code();
    if (code == 100) {
      // server sent a 100-continue even though we did not request one.
      // try again to read the actual response
      responseBuilder = httpCodec.readResponseHeaders(false);

      response = responseBuilder
              .request(request)
              .handshake(streamAllocation.connection().handshake())
              .sentRequestAtMillis(sentRequestMillis)
              .receivedResponseAtMillis(System.currentTimeMillis())
              .build();

      code = response.code();
    }

    realChain.eventListener()
            .responseHeadersEnd(realChain.call(), response);

    if (forWebSocket && code == 101) {
      // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
      response = response.newBuilder()
          .body(Util.EMPTY_RESPONSE)
          .build();
    } else {
      response = response.newBuilder()
          .body(httpCodec.openResponseBody(response))
          .build();
    }

    if ("close".equalsIgnoreCase(response.request().header("Connection"))
        || "close".equalsIgnoreCase(response.header("Connection"))) {
      streamAllocation.noNewStreams();
    }

    if ((code == 204 || code == 205) && response.body().contentLength() > 0) {
      throw new ProtocolException(
          "HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
    }

    return response;
  }



获得的数据response就交给了new okhttp3.Callback来处理：


      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
        Response response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          throwIfFatal(e);
          callFailure(e);
          return;
        }

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



既然可以从网络上获取数据了，也就是说网络的适配介绍差不多了，那么从网络上获取的数据还需要转换为应用需要的数据，是如何处理的呢？接着往下分析：


  Response parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();

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

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

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

    ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
    try {
      //很重要 这里使用了配置的Converter来转换数据
      T body = responseConverter.convert(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }



从代码中可以看到，正常情况下Retrofit把从网络上获取的数据通过配置的Converter来转换成应用层需要的格式，还记得responseConverter是什么吗，回到文章里面去找找吧，对于本文的分析就是GsonResponseBodyConverter：


  @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      // 这里的adapter从哪来？读者是否还记得
      T result = adapter.read(jsonReader);
      if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
        throw new JsonIOException("JSON document was not fully consumed.");
      }
      return result;
    } finally {
      value.close();
    }
  }



本文的前部分就介绍过TypeAdapter，其中ReflectiveTypeAdapterFactory是本文使用到的Adapter，它的read是通过反射来实现类型的动态映射：


@Override public T read(JsonReader in) throws IOException {
      if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
      }

      T instance = constructor.construct();

      try {
        in.beginObject();
        while (in.hasNext()) {
          String name = in.nextName();
          BoundField field = boundFields.get(name);
          if (field == null || !field.deserialized) {
            in.skipValue();
          } else {
            field.read(in, instance);
          }
        }
      } catch (IllegalStateException e) {
        throw new JsonSyntaxException(e);
      } catch (IllegalAccessException e) {
        throw new AssertionError(e);
      }
      in.endObject();
      return instance;
    }



处理完毕后的类型T就是Call泛型的实际类型，在本文中就是DataModel，数据处理成功后再通过应用层的回调把实例对象返回到应用：


try {
  //这个response是Response，泛型T已经转换为实际类型
  callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
  t.printStackTrace();
}



回调到应用层就是如下形式，以下源码中的new Callback与上文的callback一致：


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



中间经过了一层ExecutorCallbackCall的调度，最终还是调度到应用层的Callback：


        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                DataModel model = response.body();
                DataModel.WeatherInfoBean bean = model.getWeatherinfo();
                Log.d(TAG, "onResponse:" + bean.getCity());
            }

            @Override
            public void onFailure(Call call, Throwable t) {
                Log.d(TAG, "onFailure:" + t.getMessage());
            }
        });



3.结束语


比较简陋的把Retrofit的源码摸了一遍，了解了其中部分实现机制，发现确实解耦的比较好，目前只是初试Retrofit源码，有个框架上的认识而已，通过积累会完善这个系列。
 Rxjava的分析会是下一步的计划，反正都是难啃的骨头，一起加油！文章的分析流程不确保完全正确，有分析的不对的地方欢迎指正。
























你可能感兴趣的:(Retrofit2源码试读（二）)






    

  • 誓言心语
晓阳阳

    一、你过得太闲，才有时间执着在无意义的事情上，才有时间无病呻吟所谓痛苦。你看那些忙碌的人，他们的时间都花在努力上。二、所有的动力都来自内心的沸腾。如果你做不到一件事，无论是搞好关系，还是寻找爱人，还是减肥，都是因为你还没有真正想做。三、人性本就薄凉，用你的时候有多热情，不用你的时候就有多冷淡。四、水的清澈，并非因为它不含杂质，而是在于懂得沉淀；心的通透，不是因为没有杂念，而是在于明白取舍。五、不是
    

    • 

  • 正则表达式
他@
正则表达式php数据库

    一：正则表达式grep-a不要忽略二进制数据。-A除了显示符合范本样式的那一行之外，并显示该行之后的内容。-b在显示符合范本样式的那一行之外，并显示该行之前的内容。-c计算符合范本样式的列数。-C或-除了显示符合范本样式的那一列之外，并显示该列之前后的内容。-d当指定要查找的是目录而非文件时，必须使用这项参数，否则grep命令将回报信息并停止动作。-e指定字符串作为查找文件内容的范本样式。-E将范
    

    • 

  • Java高级编程—I/O流（包括字节输入流、字节输出流、字符输出流、字符输入流、缓冲流、序列化流、反序列化流等，详解 附有代码＋案例）
蔚一
Java知识java开发语言算法intellij-idea

    文章目录二十七.I/O流27.1概述27.2分类27.3字节输出流27.3.1数据写入本地文件27.3.2换行、续写27.4字节输入流27.4.1读取数据到程序27.4.2循环读取27.4.3拷贝数据27.4.4一次读取多个27.6字符输入流27.6.1FileReader的使用27.7字符输出流27.8.缓冲流27.8.1字节缓冲流27.8.1.1拷贝文件(一)27.8.1.2拷贝文件(二)27
    

    • 

  • C语言---函数
爱吃焦糖布丁
linuxubuntuc语言c++

    函数：什么是函数：C语言中函数就是具有某项功能的代码段，它是C语言管理代码的最小单位（英言是function），早期被翻译成函数，就一直沿用了，现在新的编程语言都翻译成方法，与数学中的函数无关。函数把具有某些功能的若干行代码封装在函数中方便管理代码且方便重复调用，函数会被编译器翻译成二进制指令存储在代码段中，函数名就是函数在代码中的首地址，韩式即是一段数据，也是一种数据类型。C语言中没有输入、输出
    

    • 

  • 经营好自己，你想要的自会来到你的身边！
林亦凡

    土拨鼠之日朋友上个月推荐一部电影，叫《土拨鼠之日》，趁周末上午在家观看了一下，通过影片回观自己的生活蛮有感触的。土拨鼠之日这部电影讲的是一位气象播报员康纳（男主）和他的同事瑞塔（女主）还有摄影师（灯泡）三人，在土拨鼠日，赶去一个小镇上报到这个节日，但是在报道完之后天下大雪，主角一行人被迫回到小镇。之后世界跟他开了玩笑当主角第二天醒来之后，他发现时间回到了土拨鼠日，开始康纳还不相信，但是当一件件他当
    

    • 

  • 日記一则
汪添辉

    星期五天气多云2018.04.06人与人之间的尊重都是相互的。今天晚上，我们在操场和两个大二的学弟一起打篮球。每当他们进球的时候，我会喊一声“好球”，随声附和一个掌声，并投给对方一个鼓励的眼神。他们会心一笑！当我抢到球并且投篮进的时候，他们同样会喊一声“好球”，给我一个不错的掌声，也会给我一个积极的眼神。这个时候，人是充分自信和满足的。尊重是相互的。特别是这种积极的尊重，多数时候都是被对方所需要的
    

    • 

  • 玉枕残梦馨--41.不辞而别（二）
素手宁心

    外边月色初升的时候，一丝光亮从顶端的洞口处照入里面，形成一道光柱，把洞内照的一片朦胧。梅莹瑾看着一旁的玉玲珑早已沉睡，自己怎么也睡不着，脑海中的那些个为什么一直在萦绕，撒哈林一直那么神秘，还有朱五娘，都是有故事的人，自从来到古代，就没怎么轻松过，太多的人和事，谜团一样缠绕着她的脑海中，久久挥之不去。脑海中还回想着朱五娘以前给她说过的话，说起她的丈夫，她的家乡，还有老乞丐说起的事情，一幕幕在脑海中回
    

    • 

  • 打卡第十四天
seida

    读书笔记解码生命著者：[美]J.克雷格·文特尔知识分子的争名夺利当同一时间有很多人都在研究同一个课题，发表论文早的那个就会得到所有的荣誉，而第二名就什么都没有。所以文特尔常常会想要第一时间发表论文，即使在与私人企业合作的时候也是这样，他坚持数据分享，而这在私人企业这种追求利益最大化的目标显然不一致了。他的确是大牛，在中国，能发表一篇自然或者科学，那就是学校捧着的顶级专家了，他那发着玩的像是自己家的
    

    • 

  • Leveldb源码分析--9
sparkliang
Leveldb分布式系统

    6SSTable之36.5读取sstable文件6.5.1类层次Sstable文件的读取逻辑在类Table中，其中涉及到的类还是比较多的，如图6.5-1所示。图6.5-1Table类导出的函数只有3个，先从这三个导出函数开始分析。其中涉及到的类（包括上图中为画出的）都会一一遇到，然后再一一拆解。本节分析sstable的打开逻辑，后面再分析key的查找与数据遍历。6.5.2Table::Open()
    

    • 

  • 高考放假后，我们可以做些什么呢？
简与虚实

    2022年的高考即将落下帷幕，小编预祝各位考生金榜题名！那么，高考结束之后，我们可以做些什么事呢？一、总结学习、生活的经验。即将进入大学的我们都会离开父母，与来自世界各地的同学们一起生活。此时，总结小至高上学累积的知识和生活经验尤为重要。我们可以尝试总结，在独立的生活环境中，自己会什么？还需要学些什么？以此在大学生活中，能够不依赖父母，独立生活，这也是我们步入成年阶段的第一课。二、去自己想去的地方
    

    • 

  • 露营车的故事
可爱多一丶

    露营车的故事一、活动背景《3-6岁儿童学习与发展指南》中提出：幼儿的学习是以直接经验为基础，在游戏和日常生活中进行的。要珍视游戏盒生活的独特价值。本次游戏观察是针对于中班幼儿积木区的活动，由于之前已经拥有搭建坦克、超市类型主题的基础，在以上基础上，罗艺萱与伙伴开始了创新搭建。二、游戏过程实录这是罗艺萱一组幼儿搭建的露营车，分别由长方体进行的围建，在两侧分别有四个轮子，有储存菜的储存罐、菜板、菜刀、
    

    • 

  • 大项目SDK跨Linux平台编译成功经验总结
正义之兔
Linuxlinuxubuntugnu

    在工作中，我们可能会遇到一些项目的SDK（源码）是在很古老的Linux环境下开发的，因为历史的原因，这个项目一直没有进行开发环境的移植。而如果要继续在这个古老的Linux下开发，要么重新购买服务器硬件（费钱），要么在自己的电脑上装这个系统（慢，费时）。解决方案当然是把它移植到装有现代Linux环境的服务器下（资源合理利用）。本人在三周的时间内，把一个带有Linux嵌入式操作系统的电信终端SDK从原
    

    • 

  • Java中的System.getenv()和System.getProperty()
星辰鸿溟
JavaHadoopYarnHadoopHDFS

    System.getenv()和System.getProperty()是Java种常用的两种读取环境配置信息的方法，它们都是java.lang.System类的方法，用途有相似之处，但我们在实际使用中，需要更加注意二者的区别。1.System.getenv()System.getenv()读取的是当前系统环境的环境变量。要深入理解环境变量的本质，需要对系统父子进程关系有更加清晰的认识。一般来说，
    

    • 

  • 4.8-4.21小结
张小龙灬

    第一个目标，瘦十斤，每周2.5斤【完成】慢慢发觉水煮菜也挺好吃的，心静，水煮黄瓜鸡蛋玉米地瓜，挺好！第二个目标，4月现金流15000，一天500！【完成】10000！第三个目标，坚持6点起床，一天跑步，一天思考未来！【完成】第四个目标，樊登读书继续，保证两天听懂一本书！增加知识储备！【完成】书听的越多，跟别人的谈资越充足真好！第五个目标，教是更好的学，思考如何更好的教奇弟剪头发！长中短女发男发！【
    

    • 

  • 千与千寻的随想（二）
故园鹤唳啊

    读书，写文章，玩游戏，是一月以来的常事。也只能在家中做出自己的一点贡献，不添乱。生活节奏慢下来，若不是老父病重住院，其实我挺享受这段居家的时光。从少年到中年，惯爱游历的我很少在父母身旁，所以格外珍惜。修身齐家治国平天下，如今只好在家修身，哈哈。现实中，为了自己的一已私欲，贪得无厌，黑心无良，竭泽而渔，杀鸡取卵，暴殄众生，丑陋至极，必将为人类招来忧患。就像宫崎骏《千与千寻》中的一对夫妇，因为欲望不节
    

    • 

  • 性格优柔寡断会出现问题
云中来

    优柔寡断者的第一种表现是，在重大的变故和灾难面前，最易畏首畏尾，狐疑不决而酿成悲剧。这种情况指的是在生死攸关的严重危机时刻，本应该临危不乱，果断决策，反击避祸，这才是明智之举。可优柔寡断者往往走向了事物的反面。灾难突然降临，自己变得手忙脚乱，六神无主，需仔细想想，权衡利弊，拿不定主意，这些弱者的表现往往把事物摧向了最坏的一面。优柔寡断者的第二种表现是，在机遇面前犹豫彷徨，丧失机会。这种情况指的是在
    

    • 

  • 日精进灬打卡
木子灬睿睿

    姓名：李睿公司：海南美兰美购城实业有限公司组别：第420期谦虚四组【日精进打卡第161天】【知～学习】《六项精进》大纲3遍共243遍《大学》1遍共149遍课外阅读书籍每周读28页，今日完成4页【经典名句分享】样样如意、得心应手，人就容易故步自封，把自己限制住了。要做有挑战的事，人才能成长。不要给自己限制，人生的路就可以无限。【行～实践】一、修身：（对自己个人）今日行走一万三千步。二、齐家：（对家庭
    

    • 

  • 数据容器对比总结
myheartgo-on
Python开发语言python青少年编程

    一、特点对比列表（list）元组（tuple）字符串（str）集合（set）字典（dict）元素数量支持多个支持多个支持多个支持多个支持多个元素类型任意类型任意类型仅字符任意类型键值对下标索引支持支持支持不支持不支持重复元素支持支持支持不支持不支持可修改性支持不支持不支持支持支持数据有序是是是否否二、应用场景对比数据容器应用场景列表（list）一批数据，可修改、可重复的存储场景元组（tuple）一
    

    • 

  • 我们终将战胜时间（小说）
木依岸

    我们终将战胜时间（小说）木依岸（一）雅歌说这是把照妖镜，今天我给你，你好好看看你的朋友圈，哪些是朋友，哪些是陌生人。我有些兴奋，就如站在显微镜前看着细菌。当然更多的是阅读量。三千对我来说是很刺激的挑战。不知为何，最近我发的链接点击量越来越少，不只是我自己，很多诗人不错的公众号阅读量就在一百至二百间徘徊。这次无疑是个挑战。它触摸了我追求刺激的神经。（二）“这首诗虽然写于2015年，距今四年啦。好的东
    

    • 

  • 2022-01-22
76c2bdc2a4a7

    2022.1.22昨天晚上9点半的时候，我去门口公园踏着雪，走了半个小时6千多步，我去的时候公园里没有一个人，我在跑道上慢慢的走着，也没有感觉到冷，一边想着心事。原因是女儿最近见了一个男孩，当时他们双方也没意见，男孩就来我家拜访，我也提前一天把家里收拾的很干净，并且买了新鲜的百合花和手工制作的仿真太阳花，由于我家本来就有两株高大的常绿植物，再配这两样花，瞬间清新淡雅的花香充满了房间，我很满意。第二
    

    • 

  • 鸿蒙轻内核M核源码分析系列二十 Newlib C
OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyosc语言移动开发鸿蒙内核鸿蒙开发openharmony开发语言

    LiteOS-M内核LibC实现有2种，可以根据需求进行二选一，分别是musllibC和newlibc。本文先学习下NewlibC的实现代码。文中所涉及的源码，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。使用MuslC库的时候，内核提供了基于LOS_XXX适配实现pthread、mqeue、fs、semaphore、time等模块
    

    • 

  • 鸿蒙轻内核M核源码分析系列十七（2） 异常钩子函数的注册操作
OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyos移动开发openharmony鸿蒙开发鸿蒙内核HarmonyOS嵌入式硬件

    本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。鸿蒙轻内核异常钩子模块代码主要在components\exchook目录下。异常钩子函数的注册、解注册、异常钩子类型定义在utils\los_debug.h|.c。1、异常钩子函数节点结构体和异常钩子函数节点数组在文件
    

    • 

  • 鸿蒙轻内核M核源码分析系列十五 CPU使用率CPUP
OpenHarmony_小贾
OpenHarmony鸿蒙开发HarmonyOSharmonyos鸿蒙内核移动开发数据结构OpenHarmony性能优化嵌入式硬件

    CPUP（CentralProcessingUnitPercentage，CPU占用率）分为系统CPU占用率和任务CPU占用率。用户通过系统级的CPU占用率，判断当前系统负载是否超出设计规格。通过系统中各个任务的CPU占用情况，判断各个任务的CPU占用率是否符合设计的预期。系统CPU占用率是指周期时间内系统的CPU占用率，用于表示系统一段时间内的闲忙程度，也表示CPU的负载情况。系统CPU占用率的
    

    • 

  • 鸿蒙轻内核M核源码分析系列十六 MPU内存保护单元
OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyos嵌入式硬件鸿蒙嵌入式鸿蒙开发OpenHarmony鸿蒙内核移动开发

    本文主要分析鸿蒙轻内核MPU模块的的源码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。鸿蒙轻内核支持的ARMCortex-M芯片架构都支持MPU的，代码都是一样的，以kernel\arch\arm\cortex-m4\gcc\los_mpu.c为例进行讲解。1、
    

    • 

  • 鸿蒙轻内核M核源码分析系列十三 消息队列Queue
OpenHarmony_小贾
鸿蒙开发HarmonyOSOpenHarmony移动开发鸿蒙内核HarmonyOSopenharmony鸿蒙开发消息队列嵌入式硬件

    队列（Queue）是一种常用于任务间通信的数据结构。任务能够从队列里面读取消息，当队列中的消息为空时，挂起读取任务；当队列中有新消息时，挂起的读取任务被唤醒并处理新消息。任务也能够往队列里写入消息，当队列已经写满消息时，挂起写入任务；当队列中有空闲消息节点时，挂起的写入任务被唤醒并写入消息。如果将读队列和写队列的超时时间设置为0，则不会挂起任务，接口会直接返回，这就是非阻塞模式。消息队列提供了异步
    

    • 

  • 听书稿 day27 学习日记
恰逢秋风起

    【你的昵称】清卿【最核心的一个问题】听书稿的思维导图如何构建【谈谈你的感想】大多数书都是围绕一个关键问题来写的，我们写听书稿的时候也要围绕这个关键问题来构建文章的大纲。常见的书籍有以下四类，分别有比较成功的听书稿案例。第一类是传授方法类书籍，这类书籍包括两种：一种是直接传授方法，通常采用并列结构写作，在传授方法的同时也可以适当讲述原因和道理。第二种是原理和方法一起讲，这类书籍一般采用“先说原因，后
    

    • 

  • 摄影知识：恒定光圈和浮动光圈还傻傻分不清？
摄影你不知道

    在选择变焦镜头时，我们会在镜头上找到一个恒定的光圈和一个浮动的光圈。他们是什么意思？有什么区别？如何选择？一、定义要理解恒定光圈和浮动光圈，首先要了解光圈，简单地说：光圈=焦距/绝对光圈。如果变焦镜头调整为50mm，则孔径为F8，表示绝对孔径为6.25mm；当孔径调整为F4时，绝对孔径为12.5mm；当孔径调整为F2时，绝对孔径为25mm。因此，光圈值越小，透镜的光圈就越大，称为大光圈。二、恒定光
    

    • 

  • 番茄猴儿养成记（43）
番茄妈

    大宝要我带茶叶回来让他提神，心痛呀！现在看他自个给自个加码，每天都做额外的练习册，其实现在只是小初二，不用这么拼吧？！给小宝买了双新凉鞋，他喜欢得不行，一醒来就要穿上。我与爸爸逗他，让他用手指指来选鞋子穿，他用脚指着新鞋子，真是可爱的不行。
    

    • 

  • 高低贵贱之分
康永盛

    低估值投资方法想要成功，必须同时具备两个前提：第一，市场犯错了；第二，市场会纠正这个错误——而这比你想象的难多了。首先，市场长期而言很少犯错；其次，就算犯错，你也无法证明；再次，就算你能证明，市场有可能就是迟迟不纠正；最后，就算纠正了，可能你早就放弃了。本系列的上一篇《什么样的企业可以长期保持高估值？》，我说的是高估值公司的投资机会。有人评论：“高估值一旦逻辑被证伪，杀估值是很厉害的”。这句话不错
    

    • 

  • 训练营第11天
喜阳阳教育婚恋身心健康

    孩子们在专注的观看《我是演说家》第一段的演讲内容让我们孩子明白要面对的就是现在的考试制度。中考、高考是给我们绝大多数孩子一个改变命运的相对公平的机会。所以，我们要依靠培养的学习能力来面对现在的考试制度。第二段薛笑的演讲内容让我们的孩子深深体会到我们要从现在开始努力，国家的荣辱就是我们每个人的荣辱。第三段：无负今日。很喜欢一段话：我们等的都是明天，而我们负的都是今天。未来不只规划出来的，未来是一步步
    

    • 

  • Enum用法
不懂事的小屁孩
enum

    以前的时候知道enum，但是真心不怎么用，在实际开发中，经常会用到以下代码:
protected final static String XJ = "XJ";
protected final static String YHK = "YHK";
protected final static String PQ = "PQ";

    

    • 

  • 【Spark九十七】RDD API之aggregateByKey
bit1129
spark

    1. aggregateByKey的运行机制
 
/**
* Aggregate the values of each key, using given combine functions and a neutral "zero value".
* This function can return a different result type
    

    • 

  • hive创建表是报错： Specified key was too long; max key length is 767 bytes
daizj
hive

    今天在hive客户端创建表时报错，具体操作如下
 
hive> create table test2(id string);
FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:javax.jdo.JDODataSto
    

    • 

  • Map 与 JavaBean之间的转换
周凡杨
java自省转换反射

    
最近项目里需要一个工具类，它的功能是传入一个Map后可以返回一个JavaBean对象。很喜欢写这样的Java服务，首先我想到的是要通过Java 的反射去实现匿名类的方法调用，这样才可以把Map里的值set 到JavaBean里。其实这里用Java的自省会更方便，下面两个方法就是一个通过反射，一个通过自省来实现本功能。
1：JavaBean类
1 &nb
    

    • 

  • java连接ftp下载
g21121
java

    有的时候需要用到java连接ftp服务器下载，上传一些操作，下面写了一个小例子。
/** ftp服务器地址 */
private String ftpHost;
/** ftp服务器用户名 */
private String ftpName;
/** ftp服务器密码 */
private String ftpPass;
/** ftp根目录 */
private String f
    

    • 

  • web报表工具FineReport使用中遇到的常见报错及解决办法（二）
老A不折腾
finereportweb报表java报表总结

     
抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。
 
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。
 
1、没有返回数据集：
在存储过程中的操作语句之前加上set nocount on 或者在数据集exec调用存储过程的前面加上这句。当S
    

    • 

  • linux 系统cpu 内存等信息查看
墙头上一根草
cpu内存liunx

    1 查看CPU
　　1.1 查看CPU个数
　　# cat /proc/cpuinfo | grep "physical id" | uniq | wc -l
　　2
　　**uniq命令：删除重复行;wc –l命令：统计行数**
　　1.2 查看CPU核数
　　# cat /proc/cpuinfo | grep "cpu cores" | u
    

    • 

  • Spring中的AOP
aijuans
springAOP

     
Spring中的AOP
Written by Tony Jiang @ 2012-1-18 （转）何为AOP
AOP，面向切面编程。
在不改动代码的前提下，灵活的在现有代码的执行顺序前后，添加进新规机能。
来一个简单的Sample:
目标类：
[java] 
view plain
copy
print
?
package&nb
    

    • 

  • placeholder(HTML 5) IE 兼容插件
alxw4616
JavaScriptjquery jQuery插件

    placeholder 这个属性被越来越频繁的使用.
但为做HTML 5 特性IE没能实现这东西.
以下的jQuery插件就是用来在IE上实现该属性的.
/**
* [placeholder(HTML 5) IE 实现.IE9以下通过测试.]
* v 1.0 by oTwo 2014年7月31日 11:45:29
*/
$.fn.placeholder = function
    

    • 

  • Object类,值域,泛型等总结(适合有基础的人看)
百合不是茶
泛型的继承和通配符变量的值域Object类转换

    java的作用域在编程的时候经常会遇到,而我经常会搞不清楚这个
问题,所以在家的这几天回忆一下过去不知道的每个小知识点
 
变量的值域;
 
package 基础;
/**
* 作用域的范围
*
* @author Administrator
*
*/
public class zuoyongyu {
public static vo
    

    • 

  • JDK1.5 Condition接口
bijian1013
javathreadConditionjava多线程

    Condition 将 Object 监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
条件（也称为条件队列或条件变量）为线程提供了一
    

    • 

  • 开源中国OSC源创会记录
bijian1013
hadoopsparkMemSQL

    一.Strata+Hadoop World（SHW）大会
        是全世界最大的大数据大会之一。SHW大会为各种技术提供了深度交流的机会，还会看到最领先的大数据技术、最广泛的应用场景、最有趣的用例教学以及最全面的大数据行业和趋势探讨。       
 
二.Hadoop
  &nbs
    

    • 

  • 【Java范型七】范型消除
bit1129
java

    范型是Java1.5引入的语言特性，它是编译时的一个语法现象，也就是说，对于一个类，不管是范型类还是非范型类，编译得到的字节码是一样的，差别仅在于通过范型这种语法来进行编译时的类型检查，在运行时是没有范型或者类型参数这个说法的。
范型跟反射刚好相反，反射是一种运行时行为，所以编译时不能访问的变量或者方法(比如private)，在运行时通过反射是可以访问的，也就是说，可见性也是一种编译时的行为，在
    

    • 

  • 【Spark九十四】spark-sql工具的使用
bit1129
spark

    spark-sql是Spark bin目录下的一个可执行脚本，它的目的是通过这个脚本执行Hive的命令，即原来通过
hive>输入的指令可以通过spark-sql>输入的指令来完成。
spark-sql可以使用内置的Hive metadata-store，也可以使用已经独立安装的Hive的metadata store
 
关于Hive build into Spark
    

    • 

  • js做的各种倒计时
ronin47
js 倒计时

    
第一种：精确到秒的javascript倒计时代码  
  
HTML代码:  
<form name="form1">  
<div align="center" align="middle"
    

    • 

  • java-37.有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接
bylijinnan
java

    
public class MaxCatenate {
/*
* Q.37 有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接，
* 问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。
*/
public static void main(String[] args){
    

    • 

  • mongoDB安装
开窍的石头
mongodb安装 基本操作

    mongoDB的安装
  
      1:mongoDB下载   https://www.mongodb.org/downloads  
      2:下载mongoDB下载后解压
    
    

    • 

  • [开源项目]引擎的关键意义
comsci
开源项目

    
     一个系统，最核心的东西就是引擎。。。。。
      而要设计和制造出引擎，最关键的是要坚持。。。。。。
      现在最先进的引擎技术，也是从莱特兄弟那里出现的，但是中间一直没有断过研发的
   
    

    • 

  • 软件度量的一些方法
cuiyadll
方法

    软件度量的一些方法http://cuiyingfeng.blog.51cto.com/43841/6775/在前面我们已介绍了组成软件度量的几个方面。在这里我们将先给出关于这几个方面的一个纲要介绍。在后面我们还会作进一步具体的阐述。当我们不从高层次的概念级来看软件度量及其目标的时候，我们很容易把这些活动看成是不同而且毫不相干的。我们现在希望表明他们是怎样恰如其分地嵌入我们的框架的。也就是我们度量的
    

    • 

  • XSD中的targetNameSpace解释
darrenzhu
xmlnamespacexsdtargetnamespace

    参考链接:
http://blog.csdn.net/colin1014/article/details/357694
xsd文件中定义了一个targetNameSpace后，其内部定义的元素，属性，类型等都属于该targetNameSpace,其自身或外部xsd文件使用这些元素，属性等都必须从定义的targetNameSpace中找：
例如：以下xsd文件，就出现了该错误，即便是在一
    

    • 

  • 什么是RAID0、RAID1、RAID0+1、RAID5，等磁盘阵列模式?
dcj3sjt126com
raid

    RAID 1又称为Mirror或Mirroring，它的宗旨是最大限度的保证用户数据的可用性和可修复性。 RAID 1的操作方式是把用户写入硬盘的数据百分之百地自动复制到另外一个硬盘上。由于对存储的数据进行百分之百的备份，在所有RAID级别中，RAID 1提供最高的数据安全保障。同样，由于数据的百分之百备份，备份数据占了总存储空间的一半，因而，Mirror的磁盘空间利用率低，存储成本高。
Mir
    

    • 

  • yii2 restful web服务快速入门
dcj3sjt126com
PHPyii2

    快速入门
Yii 提供了一整套用来简化实现 RESTful 风格的 Web Service 服务的 API。 特别是，Yii 支持以下关于 RESTful 风格的 API：
支持 Active Record 类的通用API的快速原型
涉及的响应格式（在默认情况下支持 JSON 和 XML)
支持可选输出字段的定制对象序列化
适当的格式的数据采集和验证错误 
    

    • 

  • MongoDB查询(3)——内嵌文档查询（七）
eksliang
MongoDB查询内嵌文档MongoDB查询内嵌数组

    MongoDB查询内嵌文档
转载请出自出处：http://eksliang.iteye.com/blog/2177301 一、概述
       有两种方法可以查询内嵌文档：查询整个文档；针对键值对进行查询。这两种方式是不同的，下面我通过例子进行分别说明。
  二、查询整个文档
例如:有如下文档
db.emp.insert({
&qu
    

    • 

  • android4.4从系统图库无法加载图片的问题
gundumw100
android

    典型的使用场景就是要设置一个头像，头像需要从系统图库或者拍照获得，在android4.4之前，我用的代码没问题，但是今天使用android4.4的时候突然发现不灵了。baidu了一圈，终于解决了。
下面是解决方案：
private String[] items = new String[] { "图库","拍照" };
/* 头像名称 */
    

    • 

  • 网页特效大全 jQuery等
ini
JavaScriptjquerycsshtml5ini

    HTML5和CSS3知识和特效
asp.net ajax jquery实例
分享一个下雪的特效
jQuery倾斜的动画导航菜单
选美大赛示例 你会选谁
jQuery实现HTML5时钟
功能强大的滚动播放插件JQ-Slide
万圣节快乐！！！
向上弹出菜单jQuery插件
htm5视差动画
jquery将列表倒转顺序
推荐一个jQuery分页插件
jquery animate
    

    • 

  • swift objc_setAssociatedObject block(version1.2 xcode6.4)
啸笑天
version

     
import UIKit
class LSObjectWrapper: NSObject {
let value: ((barButton: UIButton?) -> Void)?
init(value: (barButton: UIButton?) -> Void) {
self.value = value

    

    • 

  • Aegis 默认的 Xfire 绑定方式，将 XML 映射为 POJO
MagicMa_007
javaPOJOxmlAegisxfire

          Aegis 是一个默认的 Xfire 绑定方式，它将 XML 映射为 POJO, 支持代码先行的开发.你开发服 务类与 POJO,它为你生成 XML schema/wsdl
XML 和 注解映射概览
      默认情况下，你的 POJO 类被是基于他们的名字与命名空间被序列化。如果
    

    • 

  • js get max value in (json) Array
qiaolevip
每天进步一点点学习永无止境max纵观千象

    // Max value in Array
var arr = [1,2,3,5,3,2];Math.max.apply(null, arr); // 5
// Max value in Jaon Array
var arr = [{"x":"8/11/2009","y":0.026572007},{"x"
    

    • 

  • XMLhttpRequest 请求 XML,JSON ,POJO 数据
Luob.
POJOjsonAjaxxmlXMLhttpREquest

    在使用XMlhttpRequest对象发送请求和响应之前，必须首先使用javaScript对象创建一个XMLHttpRquest对象。
var xmlhttp；
function getXMLHttpRequest(){
if(window.ActiveXObject){
xmlhttp:new ActiveXObject("Microsoft.XMLHTTP
    

    • 

  • jquery
wuai
jquery

    以下防止文档在完全加载之前运行Jquery代码，否则会出现试图隐藏一个不存在的元素、获得未完全加载的图像的大小 等等
$(document).ready(function(){
jquery代码;
});
<script type="text/javascript" src="c:/scripts/jquery-1.4.2.min.js&quo
    

    •