亚洲日韩色少妇无码播放明星,最近的中文字幕视频完整,隔壁挨c的她h

為什么說是代碼提煉，而不是詳解或是什么的呢，因為涉及的東西還真是比較多，要一點一點的講，還真是一個很費工夫的事情。本人認為，先學會用得好用得爽了，道理后面就自然而然就通了。源代碼（提取碼：6u5y）

先看一下，這個優雅的實現，到底有多爽，那就要看在主線程中，我們調用接口獲得數據，到底有多簡潔了，如下看MainActivity.java：

package com.dingfang.org.httputildemo;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.dingfang.org.httputildemo.entity.Classfication;
import com.dingfang.org.httputildemo.http.RetrofitUtils;
import com.dingfang.org.httputildemo.http.request.ClassficationGet;
import com.dingfang.org.httputildemo.subscribers.ProgressSubscriber;

import java.util.List;

public class MainActivity extends AppCompatActivity {

    private MainActivity _this;

    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
    }

    private void init() {
        _this = this;
        textView = (TextView) findViewById(R.id.text01);
    }

    public void doHttpRequest(View view) {
        //這個就是我們封裝后的網絡請求獲取數據的部分，不能再簡潔~~~此處，取代了傳統的Handler接收處理數據的功能
        RetrofitUtils.getInstance().doHttp(new ClassficationGet(new ProgressSubscriber<List<Classfication>>(_this) {
            @Override
            public void onNext(List<Classfication> classfications) {
                //get datas and do something here
                Toast.makeText(_this, classfications.get(0).getTypeName(),Toast.LENGTH_SHORT).show();
                textView.setText(classfications.get(0).getTypeName());
            }

        }));
    }
}

activity_main.xml文件：

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.dingfang.org.httputildemo.MainActivity">

    <TextView
        android:id="@+id/text01"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:onClick="doHttpRequest"
        android:text="發送請求"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</android.support.constraint.ConstraintLayout>

看吧，不能再簡單了。這沒有什么好解釋的，那么接下來就看簡潔背后的故事吧！
首當其沖RetrofitUtils，因為上面的MainActivity 中有用到該類。先看代碼RetrofitUtils.java：

package com.dingfang.org.httputildemo.http;

import java.lang.reflect.Field;
import java.util.concurrent.TimeUnit;

import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import retrofit2.converter.scalars.ScalarsConverterFactory;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

/**
 * 基本數據請求工具類
 */
public class RetrofitUtils {
    private static final int DEFAULT_TIMEOUT = 10;
    private RetrofitService retrofitService;
    private static RetrofitUtils INSTANCE;

    private RetrofitUtils(){
        retrofitService = create(RetrofitService.class);
    }

    /**
     * 暴露出去的單利模式
     * @return
     */
    public static RetrofitUtils getInstance(){
        if(INSTANCE == null){
            synchronized (RetrofitUtils.class){
                if(INSTANCE == null){
                    INSTANCE = new RetrofitUtils();
                }
            }
        }
        return INSTANCE;
    }


    /**
     * 創建被觀察者 最終得到轉化后的gson對象  如：User
     * @param service
     * @param <S>
     * @return
     */
    public <S> S create(Class<S> service) {
        Retrofit retrofit = new Retrofit.Builder()
                .client(getOkHttpClient())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .baseUrl(getBaseUrl(service))
                .build();
        return retrofit.create(service);
    }

    /**
     * 創建被觀察者 最終得到字符串對象    如："我時一個快樂的字符串"
     * @param service
     * @param <S>
     * @return
     */
    public <S> S create1(Class<S> service) {
        Retrofit retrofit = new Retrofit.Builder()
                .client(getOkHttpClient())
                .addConverterFactory(ScalarsConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .baseUrl(getBaseUrl(service))
                .build();
        return retrofit.create(service);
    }

    /**
     *通過反射得到該類中的基址字符串對象
     * @param service
     * @param <S>
     * @return
     */
    private <S> String getBaseUrl(Class<S> service) {
        try {
            Field field = service.getField("BASE_URL");// 此處只能解析service類中形如 String BASE_URL = ApiInterface.API;的參數
            return (String) field.get(service);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 這里配置okHttp請求配置
     * @return
     */
    private OkHttpClient getOkHttpClient() {
        //配置超時攔截器
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
        builder.writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
        builder.readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);

        //配置log打印攔截器
//        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
//        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
//        builder.addInterceptor(loggingInterceptor);
        return builder.build();
    }



    /**
     * post、get等請求
     * @param httpResultFunc
     */
    public void doHttp(HttpResultFunc httpResultFunc){
        //通過結果來獲取 Observable、Subscriber
        httpResultFunc.getObservable(retrofitService)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(httpResultFunc)
                .subscribe(httpResultFunc.getSubscriber());
    }
}

這個類的封裝，針對Retrofit的，亮點太多，自己細細品味。這里主要看這一段：

    public void doHttp(HttpResultFunc httpResultFunc){
        //通過結果來獲取 Observable、Subscriber
        httpResultFunc.getObservable(retrofitService)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(httpResultFunc)
                .subscribe(httpResultFunc.getSubscriber());
    }

這里有一個HttpResultFunc 類，我看過好多大神的封裝，覺得這個封裝，是最讓人拍案叫絕的封裝方式，哈哈哈，原諒我自娛自樂一番~~~
下面看一看這個HttpResultFunc.java類：

package com.dingfang.org.httputildemo.http;

import com.dingfang.org.httputildemo.entity.ResponseResult;
import com.dingfang.org.httputildemo.exception.ResultErrorException;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Func1;

/**
 * 所有基本數據請求實體類基類，必須繼承自該類
 */
public abstract class HttpResultFunc<T> implements Func1<ResponseResult<T>,T> {

    @Override
    public T call(ResponseResult<T> tResponseResult) {
        //這里的判斷，要看每個用戶后臺給的返回數據的格式和規范而定
        if(tResponseResult.getStatus()!=1){
            throw  new ResultErrorException(tResponseResult.getReturnMsg());
        }
        return tResponseResult.getResult();
    }

    public abstract Observable getObservable(RetrofitService retrofitService);

    public abstract Subscriber getSubscriber();

}

這個類實際上所有網路請求接口將Rxjava中觀察者和被觀察者結合起來的一個類。
下面可以來看看該類的一個實現類ClassficationGet.java：也就是具體調用接口的位置：

package com.dingfang.org.httputildemo.http.request;

import com.dingfang.org.httputildemo.http.HttpResultFunc;
import com.dingfang.org.httputildemo.http.RetrofitService;

import rx.Observable;
import rx.Subscriber;

/**
 * 用來寫具體些網絡請求的類，請求參數都在這里聲明
 */

public class ClassficationGet extends HttpResultFunc {

    private Subscriber subscriber;

    public ClassficationGet(Subscriber subscriber) {
        this.subscriber = subscriber;
    }

    @Override
    public Observable getObservable(RetrofitService retrofitService) {
        return retrofitService.getClassfication();//調用接口
    }

    @Override
    public Subscriber getSubscriber() {
        return subscriber;
    }
}

上面說了，這個類是將Rxjava中觀察者和被觀察者結合起來的一個類。是不是很眼熟，當然了，這個類是調用接口的地方，那么不就是MainActivity中調用的那個類嗎。
那么就來看一看被觀察者吧RetrofitService.java，這個類實際上市接口聲明的地方，代碼如下：

package com.dingfang.org.httputildemo.http;

import com.dingfang.org.httputildemo.entity.Classfication;
import com.dingfang.org.httputildemo.entity.ResponseResult;

import java.util.List;

import retrofit2.http.GET;
import rx.Observable;

/**
 * 所有接口均寫在該類下,類名不可修改，如需修改需在其他調用文件相應修改
 */
public interface RetrofitService {    

    //接口前綴
    public String BASE_URL = "http://www.ttreader.com/ecp/rest/xxx/";

    //具體請求的接口
    @GET("com.cloud.bizinterface.service.IOrgService.queryCustomTypeByTypeGid(typeGid)")
    Observable<ResponseResult<List<Classfication>>> getClassfication();

}

所有的接口，都可以寫在RetrofitService.java這個類文件中。這里用到了ResponseResult類，這個是一個金典啊，把所有的請求結果，都以統一的格式給封裝了，這個類一般會根據公司內具體的返回字段而確定。我公司的返回字段如下，代碼如下：

package com.dingfang.org.httputildemo.entity;

/**
 * 數據請求結果統一預處理實體類（要求服務器返回數據統一格式）
 * 如數據格式為：
 *
 *    {
 *    "status": 0,
 *    "returnMsg": "成功",
 *    "result": {}
 *    }
 *
 * result字段可以是數組字符串等，根據需求而定。
 * 可以具體需求進行更改該類字段格式
 *
 */
public class ResponseResult<T> {

    private String returnMsg;
    private int status;
    private T result;

    public T getResult() {
        return result;
    }

    public void setResult(T result) {
        this.result = result;
    }


    public String getReturnMsg() {
        return returnMsg;
    }

    public void setReturnMsg(String returnMsg) {
        this.returnMsg = returnMsg;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "ResponseResult{" +
                "returnMsg='" + returnMsg + '\'' +
                ", status=" + status +
                ", result=" + result +
                '}';
    }
}

說完了被觀察者，看面說說觀察者，這里我的觀察者，就是網絡請求的圈圈，它觀察的是網絡請求的數據，在網絡正常的情況下，若是數據沒有到之前就轉圈圈，給用戶一個交互，由于這不是今天分享的內容的主要部分，就不細細分析了，直接看代碼吧：

package com.dingfang.org.httputildemo.subscribers;

import android.content.Context;

import com.dingfang.org.httputildemo.progress.HHProgressAlertDialog;
import com.dingfang.org.httputildemo.progress.ProgressCancelListener;
import com.dingfang.org.httputildemo.utils.ToastUtils;

import java.lang.ref.WeakReference;
import java.net.ConnectException;
import java.net.SocketTimeoutException;

import rx.Subscriber;

/**
 * Created by：hcs on 2016/10/17 16:38
 * e_mail：aaron1539@163.com
 */
public abstract class ProgressSubscriber<T> extends Subscriber<T> implements ProgressCancelListener {

    private HHProgressAlertDialog progressAlertDialog;
    private ToastUtils toast;
    private boolean isShowProgress = true;
    private WeakReference<Context> contextWeakReference;

    /**
     *  默認顯示彈出框，不可以取消
     * @param context
     */
    public ProgressSubscriber(Context context){
        contextWeakReference = new WeakReference<Context>(context);
        init(false);
    }

    /**
     * 可設置彈出框是否顯示取消
     * @param context
     * @param isShowProgress 是否顯示彈出框
     * @param isCancel 是否可以取消
     */
    public ProgressSubscriber(Context context, boolean isShowProgress, boolean isCancel){
        this.isShowProgress = isShowProgress;
        this.contextWeakReference = new WeakReference<Context>(context);
        init(isCancel);
    }

    /**
     * 初始化
     * @param isCancel
     */
    private void init(boolean isCancel) {
        Context context = contextWeakReference.get();
        progressAlertDialog = new HHProgressAlertDialog(context);
        progressAlertDialog.setCancelable(isCancel);
        toast = new ToastUtils(context);
    }

    private void showProgress(){
        if(!isShowProgress){
            return;
        }
        if(progressAlertDialog!=null){
            if(!progressAlertDialog.isShowing()){
                progressAlertDialog.show();
            }
        }
    }

    private void dismissProgress(){
        if(!isShowProgress){
            return;
        }
        if(progressAlertDialog!=null){
            if(progressAlertDialog.isShowing()){
                progressAlertDialog.dismiss();
            }
        }
    }

    @Override
    public void onStart() {
        showProgress();
    }

    @Override
    public void onCompleted() {
        dismissProgress();
    }

    @Override
    public void onError(Throwable e) {
        if (e instanceof SocketTimeoutException) {
            toast.showSingleToast("網絡中斷，請檢查您的網絡狀態");
        } else if (e instanceof ConnectException) {
            toast.showSingleToast("網絡中斷，請檢查您的網絡狀態");
        } else {
            toast.showSingleToast("error:" + e.getMessage());
        }
        dismissProgress();
    }

    @Override
    public void onCancelProgress() {
        if(!this.isUnsubscribed()){
            this.unsubscribe();
        }
    }
}

到此，在MainActivity中出現了的類，都已經列出來了，當然，還有些輔助類，沒有列出來。詳細代碼可以參考源代碼（提取碼：6u5y）。
上面Rxjava的觀察者和被觀察者都出現了，Retrofit網絡請求也貼出來了，今天的內容重點也就分享完了。是不是還不迷糊的。是的，那就下載demo跑起來看源碼吧。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Rxjava + Retrofit網絡請求封裝

Rxjava + Retrofit網絡請求封裝

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Rxjava + Retrofit網絡請求封裝

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频