2. 程式人生 > >網路庫Retrofit2原理簡析

網路庫Retrofit2原理簡析

阿新 • • 發佈：2018-11-22

之前我們分析過了Okhttp這個優秀的網路請求庫，但是在實際的使用時，還是會覺得有很多的不方便，你會發現它跟HttpUrlConnection，或者HttpClient一樣，是一個比較底層的網路請求庫，處理的是底層的網路請求和響應的問題。而我們在業務中要處理上層的邏輯，比如響應內容解析，方便的API實現等，這都需要我們對它進行重新封裝，以適合我們特定的業務邏輯。那有沒有比較簡潔，方便，優雅的封裝方式來封裝Okhttp的使用呢，Square早以為我們考慮了這個問題，於是配套Okhttp，推出了Retrofit作為上層的網路請求庫。Retrofit是Okhttp高效化封裝之後的產物，雖然它之前也是可以定義使用其他底層網路庫的（在Retrofit2之後去除了這個擴充套件）。在後面漸漸形成了Retrofit+Okhttp+RxJava網路請求三劍客的趨勢。

Retrofit優點


那麼Retrofit的優點是什麼？（哈哈，沒有優點，我憑什麼使用它）

  1. 有容乃大，可擴充套件性強，底層網路請求集成了Okhttp，非同步處理可整合RxJava，內容解析可整合Gson，Jackson等。
  2. 全面支援Restful請求，並且通過註解的方式，支援鏈式呼叫，使用簡潔方便。
  3. 精妙的原始碼設計模式，內部層次分工明確，解耦性強。

一句話概括就是它以優秀的設計思想讓我們能以輕鬆簡潔的方式進行網路資料的請求。

Retrofit使用方式


接下來我們用一個簡單的例子來看看它是如何處理的。

1.定義Bean類，代表請求資料的型別。
public class ZhihuDaily{
    @SerializedName("date")
    private String date;
    @SerializedName("top_stories")
    private ArrayList<ZhihuDailyItem> mZhihuDailyItems;
    @SerializedName("stories")
    private ArrayList<ZhihuDailyItem> stories;

    //get,set方法省略
    ...
}

public class
 
 ZhihuDailyItem{
    @SerializedName("images")
    private String[] images;
    @SerializedName("type")
    private int type;
    @SerializedName("id")
    private String id;
    @SerializedName("title")
    private String title;
    private String date;

    //get,set方法省略
    ...
}
2.定義一個API請求介面，裡面包括要訪問的Restful api請求。
public interface RequestApi {

    @GET("/api/4/news/latest")
    Observable<ZhihuDaily> getLastDaily();

    @GET("/api/4/news/before/{date}")
    Observable<ZhihuDaily> getTheDaily(@Path("date") String date);

    @GET("/api/4/news/{id}")
    Call<ZhihuStory> getStory(@Path("id") String id);

    @GET("http://lab.zuimeia.com/wallpaper/category/1/?page_size=1")
    Observable<ImageResponse> getImage();
}

就是先定義一個介面，然後將開發文件中的一個REST API對應的寫一個方法，在方法上加上註解，在方法引數上加上註解，返回值返回Call或者Observable，泛型型別為該資料解析之後的bean型別。這樣一個請求介面就完成了。

3.獲取Retrofit客戶端物件。
//建立OkHttpClient物件，並對其進行配置
OkHttpClient client = new OkHttpClient.Builder()
            .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
            .addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
            .cache(cache)
            .build();

//建立Retrofit物件，並對其進行配置
Retrofit retrofit = new Retrofit.Builder()
                        .baseUrl(BASE_URL)
                        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                        .client(client)
                        .addConverterFactory(GsonConverterFactory.create())
                        .build().create(ZhihuApi.class);

建立一個Retrofit物件，對其進行初始化配置，這裡可以對OkHttpClient物件進行配置，比如新增日誌攔截，快取設定，超時設定等，對Retrofit物件可以對CallAdapterFactory呼叫介面卡和ConverterFactory響應資料解析器進行配置。

4.建立請求介面物件，呼叫響應的API方法。
RequestApi apiService = retrofit.create(RequestApi.class);
    apiService.getLastDaily()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<Joke>() {
          @Override public void call(Joke joke) {

            callBack.onSuccess(joke);
          }
        }, new Action1<Throwable>() {
          @Override public void call(Throwable throwable) {
            callBack.onFailure(throwable);
          }
        });

這是配合RxJava的使用方式，呼叫了getLastDaily方法請求資料，指定了請求在其他執行緒執行，響應回到主執行緒，成功響應到callBack.onSuccess(joke); 網路請求錯誤到callBack.onFailure(throwable);

在層次上來看，其實就是獲取一個配置好的Retrofit客戶端，然後根據配置好的RequestApi介面建立RequestApi物件，呼叫其中的某個API方法，然後採用RxJava的方式就可以完成一次網路資料的請求和解析處理了。我們再對其進行適合封裝，會發現使用起來超級方便。

Retrofit整體架構

那麼Retrofit內部是如何實現的，整體流程是怎麼樣的呢？在這裡引用一張圖讓大家有Retrofit結構一個大體的瞭解。

Retrofit類分析

Retrofit使用建造者模式來建立物件，這樣可以方便在建立Retrofit之前就對其進行一次性相應的配置。既然是採用建造者模式，裡面必定是涉及一系列屬性的設定，我們直接看看它的屬性和內部Build構造方法。

public final class Retrofit {
  //用於記錄請求RequestApi中某個請求方法對應的處理方式
  private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();
  //okhttp的請求呼叫Factory
  private final okhttp3.Call.Factory callFactory;
  //封裝的基礎請求url，具體的請求就是將引數附加在其上得到具體的api地址
  private final HttpUrl baseUrl;
  //響應資料解析器列表
  private final List<Converter.Factory> converterFactories;
  //請求呼叫轉換器列表
  private final List<CallAdapter.Factory> adapterFactories;
  //用於響應後的回撥執行，預設是將響應post到主執行緒處理
  private final Executor callbackExecutor;
  //是否需要立即生成請求方法對應的處理物件，如果是，在create建立介面時就會生成一系列的ServiceMethod物件
  private final boolean validateEagerly;

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

      //沒有指定OkHttpClient，則使用預設建立的OkHttpClient物件，它是實際處理底層網路請求的
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      //android平臺，預設callbackExecutor是ExecutorCallAdapterFactory，也就是將響應post到主執行緒處理
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      //呼叫轉換器列表
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      //響應資料解析器列表
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

      //生成Retrofit物件
      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
  }

}

Retrofit建立介面物件

接下來我們分析Retrofit是如何根據定義的介面建立響應的可執行物件的。

public final class Retrofit {
  public <T> T create(final Class<T> service) {
    //驗證是否介面，不是的話拋異常
    Utils.validateServiceInterface(service);
    //判斷是否需要提前載入service中所有的method對應的ServiceMethod
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }

    //使用動態代理的方式建立一個實現介面的物件
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
        new InvocationHandler() {
          //獲取平臺，這裡是android平臺AndroidPlatform
          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);
            }
            //預設AndroidPlatform返回false，不執行
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }

            //最終執行這裡
            //載入呼叫方法對應的處理方式ServiceMethod
            ServiceMethod serviceMethod = loadServiceMethod(method);
            //建立一個原始的OkHttpCall，它內部直接使用Okhttp進行網路請求操作
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            //這裡將OkHttpCall封裝轉換成另一種型別的物件，比如說Observable
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

  //提前載入service中所有的method對應的ServiceMethod
  private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        loadServiceMethod(method);
      }
    }
  }

  //載入service中的method對應的ServiceMethod
  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }
}

可以看到，Retrofit是使用動態代理的方式建立了一個實現service介面的物件，當外部呼叫service介面方法，會呼叫invoke方法，然後載入當前方法對應的處理方式ServiceMethod，和建立原始的OkHttpCall，用於內部使用Okhttp去執行真正的網路請求，然後再將OkHttpCall物件封裝轉換成另一種型別的物件。

ServiceMethod的建立

接下來我們分析ServiceMethod做了什麼。它同樣使用了建造者模式進行物件建立，主要用於解析對應的介面方法。

final class ServiceMethod<T> {
  static final class Builder<T> {
    final Retrofit retrofit;
    //對應方法
    final Method method;
    //方法上的註解
    final Annotation[] methodAnnotations;
    //方法引數上的註解
    final Annotation[][] parameterAnnotationsArray;
    //方法引數型別
    final Type[] parameterTypes;
    //返回的響應型別
    Type responseType;

    //判斷是否找到了對應的註解
    boolean gotField;
    boolean gotPart;
    boolean gotBody;
    boolean gotPath;
    boolean gotQuery;
    boolean gotUrl;
    //http請求方法，Get,Post等
    String httpMethod;
    //是否有請求體
    boolean hasBody;
    boolean isFormEncoded;
    boolean isMultipart;
    //方法上註解的相對地址url
    String relativeUrl;
    Headers headers;
    MediaType contentType;
    Set<String> relativeUrlParamNames;
    //引數解析器，對諸如@GET("/api/4/news/{id}")進行解析，得到最終的url地址
    ParameterHandler<?>[] parameterHandlers;
    //響應內容轉換器，將ResponseBody轉換為其他型別
    Converter<ResponseBody, T> responseConverter;
    //請求呼叫轉換器
    CallAdapter<?> callAdapter;
  }

  //構建ServiceMethod物件
  public ServiceMethod build() {
      //建立CallAdapter
      callAdapter = createCallAdapter();
      //callAdapter的泛型型別，如某個Bean
      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.");
      }

      //建立最終ServiceMethod物件
      return new ServiceMethod<>(this);
  }

}

可以看到建立一個ServiceMethod物件需要依次建立CallAdapter請求呼叫轉換器，建立ResponseConverter響應資料轉換器，解析方法註解，方法引數註解，最後得到ServiceMethod物件。而CallAdapter和ResponseConverter的建立過程是通過查詢Retrofit中的adapterFactories和converterFactories列表，根據方法的返回型別和引數型別查詢是否有相應的Factory符合，如果有符合的Factory，即就可以得到最終的CallAdapter和ResponseConverter。

final class ServiceMethod<T> {
  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);
      }
  }
}

public final class Retrofit {
  public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }

  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);
      //Factory獲取的CallAdapter不為空，說明找到合適的CallAdapter了
      if (adapter != null) {
        return adapter;
      }
    }

    ...
  }
}

預設CallAdapter的轉換過程

預設Converter.Factory的列表中有一個ExecutorCallAdapterFactory，它的get方法返回一個CallAdapter物件，這個CallAdapter物件會將原始的OkHttpCall轉換為ExecutorCallbackCall，這個ExecutorCallbackCall就是我們介面方法中返回值定義的Call介面，它封裝了原始OkHttpCall用於網路請求和MainThreadExecutor用於響應資料時的執行緒切換。如

@GET("/api/4/news/{id}")
Call<ZhihuStory> getStory(@Path("id") String id);

//這個call就是ExecutorCallbackCall物件
Call<ZhihuStory> call = apiService.getStory("100");
call.enqueue(new Callback<Joke>() {
  @Override public void onResponse(Call<Joke> call, Response<Joke> response) {

  }

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

  }
});

當call呼叫它的enqueue方法時，就會呼叫它內部的OkHttpCall的enqueue方法，進而執行執行Okhttp的enqueue方法開始非同步網路請求，響應返回時，用MainThreadExecutor物件將響應過程切換到主執行緒（預設Okhttp的響應方法是在其他執行緒中，MainThreadExecutor內部使用Handler將響應回撥post到主執行緒處理）。

RxjavaCallAdapter的轉換過程

如果添加了Rxjava的支援，那麼在Converter.Factory列表中會有一個RxjavaCallAdapterFactory，它的get方法最終會返回一個SimpleCallAdapter物件（如果介面方法返回型別的泛型是我們定義的Bean類的話），這個SimpleCallAdapter物件會將原始的OkHttpCall轉換為一個Observable物件。有了這個Observable物件就可以很方便的作執行緒切換和後續的其他處理了。介面方法返回型別的泛型是Response或Result，那麼RxjavaCallAdapterFactory的get方法會返回ResponseCallAdapter或ResultCallAdapter。

public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
  static final class SimpleCallAdapter implements CallAdapter<Observable<?>> {
    private final Type responseType;
    private final Scheduler scheduler;

    SimpleCallAdapter(Type responseType, Scheduler scheduler) {
      this.responseType = responseType;
      this.scheduler = scheduler;
    }

    @Override public Type responseType() {
      return responseType;
    }

    @Override public <R> Observable<R> adapt(Call<R> call) {
      //這裡將OkHttpCall物件轉換為Observable物件
      //CallOnSubscribe用於觸發請求呼叫操作
      Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) //
          .lift(OperatorMapResponseToBodyOrError.<R>instance());
      if (scheduler != null) {
        return observable.subscribeOn(scheduler);
      }
      return observable;
    }
  }
}

然後它在CallOnSubscribe中觸發請求的呼叫。

public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
  static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {
    private final Call<T> originalCall;

    CallOnSubscribe(Call<T> originalCall) {
      this.originalCall = originalCall;
    }

    @Override public void call(final Subscriber<? super Response<T>> subscriber) {
      //這裡觸發請求呼叫
      // Since Call is a one-shot type, clone it for each new subscriber.
      Call<T> call = originalCall.clone();

      // Wrap the call in a helper which handles both unsubscription and backpressure.
      RequestArbiter<T> requestArbiter = new RequestArbiter<>(call, subscriber);
      subscriber.add(requestArbiter);
      subscriber.setProducer(requestArbiter);
    }
  }

  static final class RequestArbiter<T> extends AtomicBoolean implements Subscription, Producer {
    private final Call<T> call;
    private final Subscriber<? super Response<T>> subscriber;

    RequestArbiter(Call<T> call, Subscriber<? super Response<T>> subscriber) {
      this.call = call;
      this.subscriber = subscriber;
    }

    @Override public void request(long n) {
      if (n < 0) throw new IllegalArgumentException("n < 0: " + n);
      if (n == 0) return; // Nothing to do when requesting 0.
      if (!compareAndSet(false, true)) return; // Request was already triggered.

      //這裡呼叫OkHttpCall的execute方法進行網路請求
      try {
        Response<T> response = call.execute();
        if (!subscriber.isUnsubscribed()) {
          subscriber.onNext(response);
        }
      } catch (Throwable t) {
        Exceptions.throwIfFatal(t);
        if (!subscriber.isUnsubscribed()) {
          subscriber.onError(t);
        }
        return;
      }

      if (!subscriber.isUnsubscribed()) {
        subscriber.onCompleted();
      }
    }

    @Override public void unsubscribe() {
      call.cancel();
    }

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

這樣完成的RxJava式的轉換請求流程就走通了。

CallAdapter的轉換過程

那麼響應資料是在哪裡轉換成我們定義的型別的呢？它是在OkhttpCall中進行響應資料解析轉換的，不論是它的enqueue還是excute方法，響應結果都會交給parseResponse處理。

final class OkHttpCall<T> implements Call<T> {
  Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    //響應體
    ResponseBody rawBody = rawResponse.body();

    //用原始響應體封裝一個新的響應體，是能夠進行型別轉換
    // Remove the body's source (the only stateful object) so we can pass the response along.
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();

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

    if (code == 204 || code == 205) {
      //響應碼為無內容，沒有資料時，成功，但返回空
      return Response.success(null, rawResponse);
    }

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      //這裡呼叫serviceMethod去將響應體資料轉換為指定型別
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }
}

可以看到在enqueue或者excute方法執行得到響應資料後會到parseResponse將響應體資料轉換為指定型別，是呼叫當前serviceMethod的toResponse方法進行轉換，裡面會呼叫responseConverter進行convert轉換，如果我們在Retrofit配置時添加了GsonConverterFactory支援，那麼就會使用GsonConverterFactory中的GsonResponseBodyConverter進行型別轉換，而GsonResponseBodyConverter內部是使用gson進行型別轉換。

final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public T convert(ResponseBody value) throws IOException {
    //使用gson對ResponseBody轉換為指定型別
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      return adapter.read(jsonReader);
    } finally {
      value.close();
    }
  }
}

這樣響應資料型別的轉換就走通了。

總結

Retrofit原始碼涉及了不少涉及模式，結構清晰，我想它最大的特點就是讓我們以最簡便的方式實現了我們的網路請求業務，同時高度的擴充套件性使能充分利用其它庫的優點為其服務。Okhttp為其處理底層網路請求（還包括快取處理，日誌攔截等），RxJava為其提供更加廣闊的呼叫處理方式，Gson等其他解析為響應資料解析提供了保證等等。所以借用農夫三拳的話說，“我們不生產水 我們只是大自然的搬運工”，哈哈，Retrofit，一個安靜的整合管理者（美男子）。

Retrofit閱讀推薦

相關推薦

網路庫Retrofit2原理簡析

之前我們分析過了Okhttp這個優秀的網路請求庫，但是在實際的使用時，還是會覺得有很多的不方便，你會發現它跟HttpUrlConnection，或者HttpClient一樣，是一個比較底層的網路請求庫，處理的是底層的網路請求和響應的問題。而我們在業務中要處理上層的邏輯，比如響應內容解析，

libco hook原理簡析

mysq 協程 調用 blog type 全部 同名 自己的 動態 我們先看一下libco協程庫的特性描述 libco的特性 無需侵入業務邏輯，把多進程、多線程服務改造成協程服務，並發能力得到百倍提升; 支持CGI框架，輕松構建web服務(New);

JavaScript深拷貝實現原理簡析

不出 附加 als 實現 code == 除了 目標 ring Why: 引用類型拷貝為了不出現數據共享問題，需要使用深拷貝。 So: 1.內部原理： 1 function inCopy(obj1,obj2) { 2 var obj1 = obj1

NLP之jieba分詞原理簡析

一、jieba介紹 jieba庫是一個簡單實用的中文自然語言處理分詞庫。 jieba分詞屬於概率語言模型分詞。概率語言模型分詞的任務是：在全切分所得的所有結果中求某個切分方案S，使得P(S)最大。 jieba支援三種分詞模式： 全模式，把句子中所有的可以成詞的詞語都掃描出來,

Vue的資料依賴實現原理簡析

先讓我們從最簡單的一個例項Vue入手: const app = new Vue({ // options 傳入一個選項obj.這個obj即對於這個vue例項的初始化 }) 通過查閱文件，我們可以知道這個options可以接受: 選項/資料

Java堆和棧分配原理簡析以及靜態和非靜態關係簡述

1.棧：函式中定義的基本型別變數以及物件的引用變數都是存在於棧中，當定義了一個變數後，就會在棧中為其分配記憶體空間，當這個變數的作用域結束後，就會釋放此變數的記憶體空間，以便另作他用。棧的優勢是，存取速度比堆要快，僅次於直接位於CPU中的暫存器。但存在棧中的資料

讓react用起來更得心應手——（react-router原理簡析）

讓react用起來更得心應手系列文章： 前端路由和後臺路由 在剛入行的時候一直明白什麼單頁面應用是什麼，說白了就是混淆了前臺路由和後臺路由，現在來縷縷它們: 前臺路由:頁面的顯示由前臺js控制，在url的路徑中輸入雜湊值是不會往後臺傳送請求的，所以前臺可以通過將雜湊和頁

暈！常見視訊介面轉接器的原理簡析

https://www.bilibili.com/read/cv277138 數碼 3-9 546閱讀24點贊4評論 Mizuiro-Aqua/ETAC/E/Com 建議閱讀這篇文章，瞭解一下各種視訊介面的傳輸原理。 [ETAC/SS]HDMI?DP?視訊介面該選哪個？談常見視訊介面

Android熱補丁技術—dexposed原理簡析(阿里Hao)

本文由嵌入式企鵝圈原創團隊成員、阿里資深工程師Hao分享。上篇文章《Android無線開發的幾種常用技術》我們介紹了幾種android移動應用開發中的常用技術，其中的熱補丁正在被越來越多的開發團隊所使用

muduo庫整體架構簡析

muduo是一個高質量的Reactor網路庫，採用one loop per thread + thread pool架構實現，程式碼簡潔，邏輯清晰，是學習網路程式設計的很好的典範。 　　muduo的程式碼分為兩部分，base和net，base部分實現一些基礎功能，例如l

Android的IPC機制（七）—— Socket的原理簡析與使用

綜述 　　在前面的幾篇文章中，我們介紹了許多在Android中有關程序間通訊的方式，但都是在一個裝置上進行的程序間通訊，而這時候我們兩個應用在不同的裝置上的時候，在這個時候我們就不能通過前方介紹的那些方法來解決了。但是我們通過網路進行通訊來處理這個問題。今天就

OkHttp3使用解析：實現下載進度的監聽及其原理簡析

前言 本篇文章主要介紹如何利用OkHttp3實現下載進度的監聽。其實下載進度的監聽，在OkHttp3的官方原始碼中已經有了相應的實現（傳送門），我們可以參考它們的實現方法，並談談它們的實現原理，以便我們更好地理解。 引入依賴 筆者在寫下這篇文章的時候，

Thrift原理簡析(JAVA)

 Apache Thrift是一個跨語言的服務框架,本質上為RPC，同時具有序列化、反序列化機制；當我們開發的service需要開放出去的時候,就會遇到跨語言呼叫的問題,JAVA語言開發了一個UserService用來提供獲取使用者資訊的服務,如果服務消費端有PHP/Py

Laravel 模板引擎（Blade）原理簡析

轉自 http://0x1.im/blog/laravel/laravel-blade-engine.html?utm_source=tuicool&amp;utm_medium=referral 上次提到過，模板引擎一般是要做三件事情： 變數值的輸出（ec

番外 01：Spring IoC 實現原理簡析，Java的反射機制，通過類名建立物件

轉載請註明來源 賴賴的部落格 前景概要 在 01 走進Spring，Context、Bean和IoC 中，我們看到了強大的Spring通過ApplicationContext實現了bean工廠（也就是物件工廠），那究竟是怎麼實現的呢，本次給大家寫一個小D

Mockjs原理簡析

前言 有一個前後端分離的專案用到過Mockjs，後端提供了資料格式，前端通過模擬介面的返回資料，進行頁面的渲染，有一段時間，百思不得其解，這個外掛是怎麼把ajax請求給攔下來的，網上搜索了一番，資料甚

搜尋引擎收錄、抓取、排序頁面的原理簡析

豈論是百度仍是谷歌,豈論是360照常搜狗,都有自身對應的蜘蛛,每一個徵採引擎,都有本身稀罕的演算法,固然,最關健的照常看baidu與google了,部落發明,通常環境下,只有百度徵採上您的某個關健詞有排名,那末國際其它的幾個搜尋引擎,基本都市有排名,無非,網站頁面的收錄、抓取是有所一致的.關於一個SEOr

Thrift原理簡析

Apache Thrift是一個跨語言的服務框架,本質上為RPC，同時具有序列化、反序列化機制；當我們開發的service需要開放出去的時候,就會遇到跨語言呼叫的問題,JAVA語言開發了一個UserService用來提供獲取使用者資訊的服務,如果服務消費端有PH

ARP攻擊原理簡析及防禦措施

0x1  簡介 網路欺騙攻擊作為一種非常專業化的攻擊手段，給網路安全管理者，帶來嚴峻的考驗。網路安全的戰場已經從網際網路蔓延到使用者內部的網路，特別是區域網。目前利用ARP欺騙的木馬病毒在區域網中廣泛傳播，導致網路隨機掉線甚至整體癱瘓，通訊被竊聽，資訊被篡改等嚴重後果。 0x2  ARP協議概述

GSoap工作原理簡析

前言 因為工作原因，接觸GSoap已有大半年時間，春節閒來無事，簡單寫一下半年來對GSoap的理解。 服務端 int main() { #ifdef WITH_OPENSSL //1、初始化OpenSSL(系統會自動初始化SSL，故可跳過