我們真的需要使用RxJava+Retrofit嗎？

IAM四十二發表於2019-03-04

前言

可以說RxJava+Retrofit是整個2016年Android 開發圈內最受關注的的組合。各大Android論壇上有大量以RxJava+Retrofit+xxx 為標題的文章，此類文章也備受大家的關注。這個組合彷彿已經成為了Android開發的必備元件，專案裡沒使用這個組合好像自己都out了似的。

平心而論，RxJava和Retrofit 相較於以往的各種框架（如 AsyncHttpClient，Volley等 )學習和使用起來會有一些難度；RxJava 強大而又龐大的操作符，Retrofit採用註解風格定義介面，都會讓初學者花費不少功夫，繞不少圈子，踩大量的坑。既然這樣，那麼就會有人懷疑，我們真的需要學習RxJava和Retrofit嗎？

任意一款需要聯網的APP，最典型的套路就是請求後端資料，解析資料進行UI更新；響應使用者操作，再次請求資料，更新UI。這裡我們就從最基礎的網路請求出發，帶著疑問，逐步瞭解一下Retrofit的前生今世，看一看RxJava和Retrofit的價值所在。

Android Http

最基礎的實現方式

初學Android開發時，還在上大學，那會兒還不知有AsyncHttpClient，Volley，OKHttp 這麼方便的框架存在於這個世界上；一個簡單的網路請求通常要寫一大段程式碼。

使用HttpURLConnection實現網路請求

class MyTask extends AsyncTask<String, Void, String> {

        @Override
        protected String doInBackground(String... params) {
            InputStream mInputStream = null;
            HttpURLConnection connection = getHttpUrlConnection(params[0]);
            String result = "";
            try {
                connection.connect();
                int statusCode = connection.getResponseCode();
                String response = connection.getResponseMessage();
                mInputStream = connection.getInputStream();
                InputStreamReader inputStreamReader = new InputStreamReader(mInputStream);
                BufferedReader reader = new BufferedReader(inputStreamReader);
                StringBuffer sb = new StringBuffer();
                String line;
                while ((line = reader.readLine()) != null) {
                    sb.append(line + "
");
                }

                result = "StatusCode: " + statusCode + "
"
                        + "Response" + response + "
"
                        + sb.toString();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return result;
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            tv.setText(s);
        }
    }

    private HttpURLConnection getHttpUrlConnection(String url) {
        HttpURLConnection connection = null;
        try {
            URL mUrl = new URL(url);
            connection = (HttpURLConnection) mUrl.openConnection();
            connection.setConnectTimeout(20000);
            connection.setReadTimeout(40000);
            connection.setRequestMethod("GET");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("Accept", "application/json");
            connection.setRequestProperty("Charset", "utf-8");
            connection.setRequestProperty("Content-Length", "0");

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return connection;
    }複製程式碼

new MyTask().execute(BASE_URL);複製程式碼

這段程式碼的邏輯很簡單，就是將網路請求的結果顯示在一個TextView上。很大一部分的內容都是在執行HttpURLConnection 相關的配置及初始化工作。

記得第一次通過網路請求把資料顯示的Android模擬器（那時候還是窮學生，買不起Android手機）的螢幕上時，雖然只是一大堆別人看不懂的json字串，但是感覺自己就要上天了，現在想想真是。。。。。

即便是這麼長的一段程式碼，還沒有包含網路請求異常的內容，如果加上網路請求失敗處理的邏輯，將使得整個程式碼結構更加臃腫龐大。

網路請求框架的湧現

一款聯網的APP至少會有十幾次的網路請求，更多的就無法估計了。因此，每一次的網路請求不可能像上面那樣寫。所以，我們需要封裝，將一些固定的操作統一處理；當然已經有許多大神比我早想到了這個問題，便出現了許多對網路請求進行封裝的庫。

AsyncHttpClient（底層基於HttpClient）
afinal（FinalHttp，同樣是基於HttpClient封裝）
xUtils (基於afinal)
Volley（Google官方出品）
okHttp
NoHttp (個人開發)

這裡列出的幾個庫當中，個人使用AsyncHttpClient較多，AsyncHttpClient 的確非常好用，但是後來伴隨著Android sdk 23 中HttpClient的廢棄也逐漸被遺忘。
afinal和xUtils 都沒有在實際專案中沒用過，不做評價。

Volley作為Google官方在2013年I/O 大會上推出的庫，相較於AsyncHttpClient 更強大。

下面簡單列舉一個使用Volley進行get請求的demo。

Volley 簡單使用

新增依賴：

compile `com.mcxiaoke.volley:library:1.0.19`複製程式碼

protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mContext = this;
        queue = Volley.newRequestQueue(mContext);
        setContentView(R.layout.activity_http_volley_demo);
        tv = (TextView) findViewById(R.id.editText);

        final StringRequest request = new StringRequest(Request.Method.GET, BASE_URL,
                new ResponseSuccessListener(), new ResponseFailListener());
        findViewById(R.id.volley).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                queue.add(request);
            }
        });

    }

    private class ResponseSuccessListener implements com.android.volley.Response.Listener<String> {

        @Override
        public void onResponse(String response) {
            tv.setText(response);
        }
    }

    private class ResponseFailListener implements Response.ErrorListener {

        @Override
        public void onErrorResponse(VolleyError error) {
            Toast.makeText(mContext, error.toString(), Toast.LENGTH_SHORT).show();
        }
    }複製程式碼

這段程式碼和上面的功能一樣，都是將網路請求的結果顯示在TextView。但是通過Volley對http請求進行一次封裝後，我們不再關注網路請求的具體細節，而是將重點放在了對請求結果的處理上；網路請求無論成功還是失敗，我們都可以很多好的應對。

而且在Volley中，非同步網路請求的回撥方法已然處於UI執行緒中，這樣我們就可以直接在回撥方法中進行UI更新了。

可以說，使用Volley已經可以非常方便的處理Android 網路請求的相關內容了。既然如此，為什麼還會有OKHttp和Retrofit的出現呢?他們的優勢又在哪裡呢？

OKHttp 簡單介紹

okHttp 是由square 推出的一個網路請求庫，包括Retrofit也是由其開發，這裡為square點個贊。

使用之前加入依賴

    compile `com.squareup.okhttp3:okhttp:3.4.1`
    compile `com.squareup.okio:okio:1.11.0`複製程式碼

okHttp 網路請求實現

findViewById(R.id.get).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tv.setText("");
                loading.setVisibility(View.VISIBLE);
                client = new OkHttpClient();
                Request.Builder builder = new Request.Builder()
                        .url(BASE_URL)
                        .method("GET", null);

                request = builder.build();
                Call mCall = client.newCall(request);
                mCall.enqueue(new MyCallback());
            }
        });

private class MyCallback implements Callback {

        @Override
        public void onFailure(Call call, IOException e) {
            Message msg = new Message();
            msg.what = 100;
            msg.obj = e;
            handler.sendMessage(msg);
        }

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            Message msg = new Message();
            msg.what = 200;
            msg.obj = response.body().string();
            handler.sendMessage(msg);
        }
    }

class MyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            loading.setVisibility(View.GONE);
            switch (msg.what) {
                case 100:
                    Object e = msg.obj;
                    Toast.makeText(mContext, e.toString(), Toast.LENGTH_SHORT).show();
                    break;
                case 200:
                    String response = (String) msg.obj;
                    tv.setText(response);
                    break;
                case 300:
                    int percent = msg.arg1;
                    Log.e("llll", "the percent is " + percent);
                    if (percent < 100) {
                        progressDialog.setProgress(percent);
                    } else {
                        progressDialog.dismiss();
                        Glide.with(mContext).load(FILE_PATH).into(imageView);
                    }
                    break;
                default:
                    break;
            }
        }
    }複製程式碼

這裡必須瞭解的是，okHttp的回撥方法，並不處於UI 執行緒中，對網路請求結果如果涉及UI 執行緒的操作，需要使用Handler。這麼看來，okHttp 貌似反而不如Volley了。其實不然，okhttp的封裝套路和Volley，AsyncHttp不是一個級別的，不能和後兩者作比較，okhttp 和HttpClient、HttpUriConneciton 才是一個級別的產物，相較於這兩者，okhttp顯然強大了許多。

所以，OKHttp不僅僅可以用於Android開發，Java開發也是OK的。

Retrofit

A type-safe HTTP client for Android and Java

一個針對Android和Java型別安全的http客戶端

上面這句話，就是Squire對Retrofit的說明，言簡意賅。Retrofit其實是對okhttp 做了進一步的封裝，有了okhttp 的基礎，使用Retrofit會很容易。

下面就來看看，使用Retrofit做網路請求又是一種怎樣的體驗。

這裡為了方便我們使用

api.github.com/

作為網路請求的介面基地址

使用之前加入依賴：

compile `com.squareup.retrofit2:retrofit:2.1.0`複製程式碼

定義介面

public interface GithubService {

    @GET("users/{user}")
    Call<ResponseBody> getUserString(@Path("user") String user);

}複製程式碼

這裡我們使用http中的get 方法獲取users這個介面下，當前user的具體資訊，引數為當前user名。返回內容為Http請求的ResponseBody。

Retrofit 返回ResponseBody

private void SimpleRetrofit() {
        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        Retrofit.Builder builder = new Retrofit.Builder()
                .baseUrl(BASE_URL);
        Retrofit retrofit = builder.client(httpClient.build()).build();
        GithubService simpleService = retrofit.create(GithubService.class);
        Call<ResponseBody> call = simpleService.getUserString(name);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                loading.dismiss();
                try {
                    String result = response.body().string();
                    Gson gson = new Gson();
                    GithubUserBean bean = gson.fromJson(result, GithubUserBean.class);
                    setUserView(bean);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                loading.dismiss();
            }
        });
    }

private void setUserView(GithubUserBean user) {
        if (user != null) {
            viewShell.removeAllViews();
            View view = LayoutInflater.from(mContext).inflate(R.layout.user_item_layout, null);
            TextView title = (TextView) view.findViewById(R.id.title);
            TextView id = (TextView) view.findViewById(R.id.userId);
            TextView creteaTime = (TextView) view.findViewById(R.id.createTime);
            TextView updateTime = (TextView) view.findViewById(R.id.updateTime);
            TextView bio = (TextView) view.findViewById(R.id.bio);
            ImageView avatar = (ImageView) view.findViewById(R.id.avatar);

            title.setText("Name: " + user.getLogin());
            bio.setText("Bio: " + user.getBio());
            id.setText("Id: " + String.valueOf(user.getId()));
            creteaTime.setText("createTime: " + user.getCreated_at());
            updateTime.setText("updateTime: " + user.getUpdated_at());
            Glide.with(mContext).load(user.getAvatar_url()).into(avatar);

            viewShell.addView(view);
        } else {
            Toast.makeText(mContext, "result is null", Toast.LENGTH_SHORT).show();
        }
    }複製程式碼

GitHubUserBean 為網路請求結果json資料所對應的實體類。

通過這段程式碼，我們在最終的回撥方法裡可以友好的處理請求結果，失敗時onFailure方法執行。成功時，onResponse方法執行，我們在這裡用Gson解析返回的資料，並進行UI更新操作（setUserView(bean))，

這裡我們這樣做有些囉嗦，Gson轉換的方式都是類似，唯一不同的只是每次網路請求結果對應的實體類；因此我們可以藉助強大的Retrofit幫助我們完成Gson轉換的步驟。當然，如果在你所在的開發環境中，介面返回的並不是json格式的資料，也沒有問題的。

上圖是Retrofit官網對可轉換型別給出的介紹。有這麼多種，當然瞭如果你們家伺服器返回的資料格式比較神奇，你也可以自定義轉換類。

好了，言歸正傳，這裡還是以Json 格式資料為例。

新增依賴：

compile `com.squareup.retrofit2:converter-gson:2.1.0`複製程式碼

注意這裡converter-gson 的版本號，要和之前Retrofit的版本號保持一致。

我們重新定義介面：

public interface GithubService {
    @GET("users/{user}")
    Call<GithubUserBean> getUser(@Path("user") String user);

}複製程式碼

這裡我們用GithubUserBean取代ResponseBody，直接將其作為返回型別。

Retrofit 返回物件

private void LazyRetrofit() {
        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        Retrofit.Builder builder = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create());
        Retrofit retrofit = builder.client(httpClient.build()).build();
        GithubService service = retrofit.create(GithubService.class);
        Call<GithubUserBean> call = service.getUser(name);
        call.enqueue(new Callback<GithubUserBean>() {
            @Override
            public void onResponse(Call<GithubUserBean> call, Response<GithubUserBean> response) {
                GithubUserBean bean = response.body();
                setUserView(bean);
                loading.dismiss();
            }

            @Override
            public void onFailure(Call<GithubUserBean> call, Throwable t) {
                loading.dismiss();
            }
        });
    }複製程式碼

這裡的實現方式和上面基本相似，只是多了一行

.addConverterFactory(GsonConverterFactory.create());複製程式碼

這樣，我們在onResponse中獲得就是物件，不再需要做額外的轉換工作，可以直接使用。

Retrofit 簡單封裝

這裡我們可以看到，Retrofit使用有著一定的套路，所以我們可以將Retrofit初始化相關得內容做一次簡單的封裝。

public class GenServiceUtil {
    private static final String BASE_URL = "https://api.github.com/";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder = new Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create());

    private static Retrofit retrofit = builder.client(httpClient.build()).build();

    public static <S> S createService(Class<S> serviceClass) {
        return retrofit.create(serviceClass);
    }

}

private void EasyRetrofit() {
        GithubService service = GenServiceUtil.createService(GithubService.class);
        Call<GithubUserBean> call = service.getUser(name);
        call.enqueue(new Callback<GithubUserBean>() {
            @Override
            public void onResponse(Call<GithubUserBean> call, Response<GithubUserBean> response) {
                GithubUserBean bean = response.body();
                loading.dismiss();
                setUserView(bean);
            }

            @Override
            public void onFailure(Call<GithubUserBean> call, Throwable t) {
                loading.dismiss();
            }
        });
    }複製程式碼

我們只需傳入定義好的藉口，會使程式碼簡介許多。看到這裡可以發現，Retrofit的確很厲害，那為什麼又要將他和RxJava結合在一起呢？下面我們就來看看。

RxJava+Retrofit

關於什麼是RxJava，這裡不再贅述，不瞭解的看以看看這裡。這裡我們就看看將RxJava 和我們之前的內容結合在一起會有怎樣的效果。

首先，加入依賴

    compile `io.reactivex:rxjava:1.1.7`
    compile `io.reactivex:rxandroid:1.2.1`複製程式碼

RxJava+Retrofit 實現

private void RxRetrofit() {
        GithubService service = GenServiceUtil.createService(GithubService.class);
        final Call<GithubUserBean> call = service.getUser(name);
        final Observable myObserable = Observable.create(new Observable.OnSubscribe<GithubUserBean>() {
            @Override
            public void call(Subscriber<? super GithubUserBean> subscriber) {
                Response<GithubUserBean> bean = null;
                try {
                    bean = call.execute();
                    subscriber.onNext(bean.body());

                } catch (IOException e) {
                    e.printStackTrace();
                    subscriber.onError(e);
                }

                subscriber.onCompleted();
            }
        });

        myObserable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1<GithubUserBean, GithubUserBean>() {
                    @Override
                    public GithubUserBean call(GithubUserBean o) {
                        if (TextUtils.isEmpty(o.getBio())) {
                            o.setBio("nothing !");
                        }
                        return o;
                    }
                })
                .subscribe(new Subscriber<GithubUserBean>() {
                    @Override
                    public void onCompleted() {
                        loading.dismiss();
                    }

                    @Override
                    public void onError(Throwable e) {
                        loading.dismiss();
                    }

                    @Override
                    public void onNext(GithubUserBean o) {
                        setUserView(o);
                    }
                });

    }複製程式碼

這裡有幾點需要注意：

RxJava 本身最大的特定就是非同步，因此這裡我們Retrofit執行網路請求的時候，使用了execute（同步請求），而不再是enqueue。
RxJava 可以使用subscribeOn和observeOn完美處理Observeable和Subscribe的執行執行緒問題。
這裡使用RxJava中map操作符，對返回內容中的為null或“” 的物件做了簡單的處理。

我們引入RxJava實現了同樣的功能，卻使得程式碼量增加了很多。不禁要問，RxJava的價值到底在哪裡呢？

RxJava + Retrofit 到底好在哪裡

好了，為了說明為題，我們新增一個介面

public interface GithubService {

    @GET("users/{user}")
    Call<GithubUserBean> getUser(@Path("user") String user);

    @GET("users/{user}/followers")Observable<List<UserFollowerBean>> followers(@Path("user") String usr);

}複製程式碼

當然這裡依舊需要新增依賴：

compile `com.squareup.retrofit2:adapter-rxjava:2.1.0`
`複製程式碼

同時在Service的封裝方法中新增

.addCallAdapterFactory(RxJavaCallAdapterFactory.create())複製程式碼

這樣，RxJava就和Retrofit完美的關聯在了一起。

我們在介面中，定義followers()方法直接返回了Observable，因為Observable是RxJava的源頭，而且Retrofit可以很好的支援RxJava，這樣就非常方便了。

    private void RxRetrofitList() {
        GithubService service = GenServiceUtil.createService(GithubService.class);
        Observable<List<UserFollowerBean>> myObserve = service.followers(name);
        myObserve
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<List<UserFollowerBean>>() {
                    @Override
                    public void onCompleted() {
                        loading.dismiss();
                    }

                    @Override
                    public void onError(Throwable e) {
                        loading.dismiss();
                        e.printStackTrace();
                    }

                    @Override
                    public void onNext(List<UserFollowerBean> userFollowerBeen) {
                        setFollowersView(userFollowerBeen);
                    }
                });

    }複製程式碼

在介面中返回的內容就是Observable，因此不用再像之前一樣單獨定義Observable；在onNext 方法中，接收到返回的物件，更新UI。這裡如果我們不使用RxJava,單獨使用Retrofit實現這個過程是沒有任何問題的； RxJava看似沒有價值；但是假設現在出現如下之一的情景

需要對返回的userFollowerBeen 這個list 進行按使用者名稱從小到大的排序
需要對返回的userFollowerBeen 這個list 進行按使用者ID從小到大的排序
如果返回的userFollowerBeen 這個list 中，某一項的頭像地址為空，則不顯示該項

…..

這種情景在實際開發中太常見了，試想如果沒有RxJava；那麼每一次需求的變更都意味著我們需要去修改setFollowersView這個方法，需求一旦變更，就去修改這個方法，這樣會不可避免的產生各種bug。那有沒有辦法不去修改這個方法呢？這個時候，就需要強大的RxJava了。

這裡我們就看看如何在不修改setFollowersView的前提下，實現對使用者名稱從小到大的排序：

    private void RxRetrofitList() {
        GithubService service = GenServiceUtil.createService(GithubService.class);
        Observable<List<UserFollowerBean>> myObserve = service.followers(name);
        myObserve
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1<List<UserFollowerBean>, List<UserFollowerBean>>() {
                    @Override
                    public List<UserFollowerBean> call(List<UserFollowerBean> userFollowerBeen) {
                        for (UserFollowerBean bean : userFollowerBeen) {
                            String name = "";
                            name = bean.getLogin().substring(0, 1).toUpperCase() + bean.getLogin().substring(1, bean.getLogin().length());
                            bean.setLogin(name);
                        }
                        return userFollowerBeen;
                    }
                })
                .map(new Func1<List<UserFollowerBean>, List<UserFollowerBean>>() {
                    @Override
                    public List<UserFollowerBean> call(List<UserFollowerBean> userFollowerBean) {
                        Collections.sort(userFollowerBean, new Comparator<UserFollowerBean>() {
                            @Override
                            public int compare(UserFollowerBean o1, UserFollowerBean o2) {
                                return o1.getLogin().compareTo(o2.getLogin());
                            }
                        });
                        return userFollowerBean;
                    }
                })
                .subscribe(new Subscriber<List<UserFollowerBean>>() {
                    @Override
                    public void onCompleted() {
                        loading.dismiss();
                    }

                    @Override
                    public void onError(Throwable e) {
                        loading.dismiss();
                        e.printStackTrace();
                    }

                    @Override
                    public void onNext(List<UserFollowerBean> userFollowerBeen) {
                        setFollowersView(userFollowerBeen);
                    }
                });

    }複製程式碼

RxJava 鏈式風格的程式碼

在程式碼中我們使用RxJava的map 操作符，對返回資料做了兩次處理，首先將所有使用者名稱的首字母轉換為大寫字母；然後對整個list按照使用者名稱從小到大排序。因為使用者名稱中同時包含以大小寫字母打頭的內容，所以為了方便，我們進行了一次轉換大寫的操作。

同樣是隨著需求變更，修改程式碼；但是你會發現，使用RxJava的方式，會降低出現bug的概率，而且就算是不同的人去改，也會比較方便維護。

看到了吧，這就是RxJava的優點，當然這個例子也只是冰山一角。這裡提到的map操作符只是RxJava龐大操作符集合中的一員，更特別的是，RxJava的操作符還是可以自定義的，這樣讓我們的程式碼有了無限的可能；RxJava的存在不僅僅在於網路請求，可以用在別的方面；RxJava其實是體現了一種思路，所有對資料的操作都在流上完成，將最終的結果返回給觀察者。同時，如果返回的followers 列表有任何異常，RxJava的onError 方法會執行，這就方便我們去處理異常資料了。

總結

通篇通過對Android 網路請求各種實現的總結，可以看到相對於Volley，AsyncHttpClient 等庫，RxJava+Retrofit 的優勢並非特別顯著；在執行效率及功能上並無大的亮點；對Volley進行良好的封裝同樣可以實現類似Retrofit自動轉Gson的功能；RxJava+Retrofit 結合會讓我們寫程式碼的方式更加有條理，雖然程式碼量會增多，但邏輯的清晰才是最重要的不是嗎？所以，RxJava+Retrofit 組合不失為一種好的選擇。

所以，趕緊擁抱RxJava+Retrofit吧！

文中所有原始碼地址github

對於 PHP 框架，我們真的需要使用 LTS 版本嗎？
2022-03-06
PHP框架
JavaScript物件：我們真的需要模擬類嗎？
2019-02-27
JavaScript物件
我們真的需要在車內打遊戲嗎？
2021-04-22
遊戲
我們需要使用CRM系統嗎？
2022-05-27
關於介面設計的思考--我們真的需要這麼多入參嗎
2021-07-04
GPS導航用多了我們真的會變傻嗎？
2019-08-23
我真的懂 this 嗎
2019-04-03
[原創]淺談我們需要灰度釋出嗎？
2019-01-28
Java隨談（六）## 我們真的理解 Java 裡的整型嗎？
2022-06-07
Java
在大資料時代，我們真的沒有隱私嗎？
2019-06-27
大資料
中小企業真的需要CRM嗎？
2023-04-24
你真的需要新款MacBook Pro嗎？
2021-12-29
Mac
真的需要“每天8杯水”嗎？
2021-05-08
我真的會失憶嗎？
2024-09-04
我們應該使用 TLS1.3 嗎
2022-05-20
TLS
我們真的知道測試行業的內卷是什麼嗎？
2020-10-05
行業
我真的還有機會嗎？
2024-06-25
50年過去了，我們還需要《龍與地下城》嗎？
2022-05-30
我們需要選擇網際網路自動技術嗎
2019-07-16
演算法金 | 時間序列預測真的需要深度學習模型嗎？是的，我需要。不，你不需要？
2024-07-08
演算法深度學習模型
智慧推薦，真的會讓我們陷入“資訊繭房”無法自拔嗎？
2019-01-11
我們為什麼需要CDP？
2022-06-14
我們需要怎樣的 Service
2022-01-11
為什麼我們需要 Vuex
2019-02-28
Vue
實驗室真的需要智慧LIMS系統嗎?
2020-12-08
到底為什麼我們需要 Clickhouse?
2022-10-27
我們為什麼需要雲原生？
2021-03-19
我們為什麼需要async/await ?
2019-03-25
AI
我們需要注意的 immutable 操作
2018-03-14
【畢業寄語】阻礙我們進步的真的是加班和沒時間嗎
2019-10-13
人工智慧真的對我們有好處嗎？聽大人物說什麼。
2019-06-28
人工智慧
你的資料庫真的需要遷移到雲嗎？
2022-11-02
資料庫
你真的熟練使用webpack嗎？
2019-07-27
Web
http與https的區別我真的知道嗎
2018-05-10
HTTP
幽默：我們需要一名醫生
2024-06-30
我們需要什麼樣的 ORM 框架
2024-03-22
ORM框架
我們為什麼需要 lock 檔案
2019-01-16
[譯] 為什麼我們需要 Web 3.0
2018-10-07
Web