【0104】【項目實戰】-【Android通用框架設計與完整電商APP開發】-【3】【高性能傻瓜式網絡請求框架設計（Retrofit+RxJava+Glide）】

1.網絡框架接口創建

1.1 使用的是第三方的框架

【第三方框架】Retrofit，封裝一個通用的框架，可以使用rxJava和rxAndroid進行封裝，比較難，這里不做講解；

1.2 restful 請求

【參考文章】http://www.ruanyifeng.com/blog/2014/05/restful_api

1.3網絡請求的具體實現類

【網絡請求的具體實現類】

【添加依賴】添加依賴可以使用兩種方式：【1】直接復制粘貼；【2】projectStucter尋找添加；

    //網絡請求依賴
    compile 'com.squareup.okio:okio:1.13.0'
    compile 'com.squareup.okhttp3:okhttp:3.8.1'
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    compile 'com.squareup.retrofit2:converter-scalars:2.3.0' //以string 直接轉化來的，最直接的

 

【框架的搭建需要考慮的問題】明白需要使用什么模式，來什么要什么的是建造者模式是最好的。

 

【源碼】com.flj.latte.net.RestService接口的封裝

package com.flj.latte.net;

import java.util.WeakHashMap;

import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.DELETE;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.PUT;
import retrofit2.http.Part;
import retrofit2.http.QueryMap;
import retrofit2.http.Streaming;
import retrofit2.http.Url;

/**
 * Created by 傅令傑 on 2017/4/2
 */
public interface RestService {

    @GET  //不傳遞任何的路由信息
    Call<String> get(@Url String url, @QueryMap WeakHashMap<String, Object> params);   //QueryMap是以鍵值對的形式進行存儲的；

    /**
     *
     * @param url
     * @param params
     * @return
     * FieldMap：請求體中包含的內容；
     */
    @FormUrlEncoded
    @POST //不傳遞任何的路由信息
    Call<String> post(@Url String url, @FieldMap WeakHashMap<String, Object> params);

    @POST
    Call<String> postRaw(@Url String url, @Body RequestBody body);

    @FormUrlEncoded
    @PUT
    Call<String> put(@Url String url, @FieldMap WeakHashMap<String, Object> params);

    @PUT
    Call<String> putRaw(@Url String url, @Body RequestBody body);

    @DELETE
    Call<String> delete(@Url String url, @QueryMap WeakHashMap<String, Object> params);

    @Streaming //避免一次性將所有的文件下載下來，導致內存的溢出；但是在寫的時候，仍然需要將文件放在單獨的線程，否則在主線程操作任然會報錯。
    @GET
    Call<ResponseBody> download(@Url String url, @QueryMap WeakHashMap<String, Object> params);

    @Multipart
    @POST
    Call<String> upload(@Url String url, @Part MultipartBody.Part file);
}

  【封裝枚舉類】

【傳入ip地址】

【RetrofitHolder創建成功】構建OkHttp請求

1.5 【restService的創建】

1.6 創建get方法

2.Restful請求的處理-框架

【說明】首先要考慮網絡請求的參數（url傳入的值、文件、回調、及loder加載圈）

【說明】使用建造者模式，將建造者類和宿主類分開；

2.1【新建建造者類】

2.2【restClient類的參數的定義】

【restClient類的參數的定義】restClient類在每次Builder的時候會生成全新的實例，而里面的參數一次更改完畢，不允許二次更改；

 

2.3 【回調類】

【回調類】在網路請求之后，會存在網絡請求之后的回調，比如：請求失敗、請求異常、請求成功等；

[新建CallBack包，書寫需要調用的接口]

 

2.4 完善RestClient

【完善com.flj.latte.net.RestClient】以Builder的形式構造出來了；

2.5 RestClientBuilder 對數據的設置

【說明】主要完成的數據的傳遞

 

 

2.6 RestClient的調用

2.7 RestClientBuilder的改進

 2.7.1【改進1】【mParams】參數每次都會構建，比較繁瑣；

 

【優化1】

【優化方法2】

【client修改】

2.8 requset請求

【新建callBack類】新建類並實現實現接口， 復寫方法；

【部分源碼】com.flj.latte.net.callback.RequestCallbacks

package com.flj.latte.net.callback;

import android.os.Handler;

import com.flj.latte.app.ConfigKeys;
import com.flj.latte.app.Latte;
import com.flj.latte.net.RestCreator;
import com.flj.latte.ui.loader.LatteLoader;
import com.flj.latte.ui.loader.LoaderStyle;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public final class RequestCallbacks implements Callback<String> {

    private final IRequest REQUEST;
    private final ISuccess SUCCESS;
    private final IFailure FAILURE;
    private final IError ERROR;
    private final LoaderStyle LOADER_STYLE;
    private static final Handler HANDLER = Latte.getHandler();

    public RequestCallbacks(IRequest request, ISuccess success, IFailure failure, IError error, LoaderStyle style) {
        this.REQUEST = request;
        this.SUCCESS = success;
        this.FAILURE = failure;
        this.ERROR = error;
        this.LOADER_STYLE = style;
    }

    @Override
    public void onResponse(Call<String> call, Response<String> response) {
        if (response.isSuccessful()) {
            if (call.isExecuted()) {
                if (SUCCESS != null) {
                    SUCCESS.onSuccess(response.body());
                }
            }
        } else {
            if (ERROR != null) {
                ERROR.onError(response.code(), response.message());
            }
        }

        onRequestFinish();
    }

    @Override
    public void onFailure(Call<String> call, Throwable t) {
        if (FAILURE != null) {
            FAILURE.onFailure();
        }
        if (REQUEST != null) {
            REQUEST.onRequestEnd();
        }

        onRequestFinish();
    }

 【完善RestClient】 

 

2.9 使用方法

【測試】

【增加權限】

【測試】

【效果】通過get請求返回了數據

3. oading框架集成與完善AVLoadingIndicatorView

3.1 第三方框架的效果

【地址】https://github.com/81813780/AVLoadingIndicatorView

【說明】在該地址中已經存在怎樣使用的步驟；

3.2 集成封裝獲取某種類型的View

【添加依賴】

【說明】各種的效果的獲取使用過的是反射的技術，但是反復使用反射會影響設備的性能；因此做了一個機制的封裝；

【原理】以一種緩存的方式創建loader，不需要每次使用loader的時候進行反射，這樣性能會有很大幅度的提高。

3.3 不同的style的枚舉的封裝

【對不同的類型進行封裝】com.flj.latte.ui.loader.LoaderStyle

package com.flj.latte.ui.loader;


@SuppressWarnings("unused")
public enum LoaderStyle {
    BallPulseIndicator,
    BallGridPulseIndicator,
    BallClipRotateIndicator,
    BallClipRotatePulseIndicator,
    SquareSpinIndicator,
    BallClipRotateMultipleIndicator,
    BallPulseRiseIndicator,
    BallRotateIndicator,
    CubeTransitionIndicator,
    BallZigZagIndicator,
    BallZigZagDeflectIndicator,
    BallTrianglePathIndicator,
    BallScaleIndicator,
    LineScaleIndicator,
    LineScalePartyIndicator,
    BallScaleMultipleIndicator,
    BallPulseSyncIndicator,
    BallBeatIndicator,
    LineScalePulseOutIndicator,
    LineScalePulseOutRapidIndicator,
    BallScaleRippleIndicator,
    BallScaleRippleMultipleIndicator,
    BallSpinFadeLoaderIndicator,
    LineSpinFadeLoaderIndicator,
    TriangleSkewSpinIndicator,
    PacmanIndicator,
    BallGridBeatIndicator,
    SemiCircleSpinIndicator,
    CustomIndicator
}

3.4 對傳入的樣式/參數封裝

【樣式的封裝】需要封裝是否需要透明度、顏色等值的傳入；

【傳入樣式參數並作為根布局】

3.5 工具類-填充參數的設置

【工具類】新建工具類的權限一般 放為：public static；

3.6 繼續完善類

【設置縮放比例】為了適應 不同的設備的屏幕的不同的大小，需要對加載的loader進行縮放

【創建集合，統一管理不同類型的loader】【學習思想】在不需要loaders的時候，只要遍歷集合，一一的關閉loaders即可；

【提供默認的loaders樣式】

【關閉和顯示對話框的loader】

【說明】此處使用的dialog.cancle(),因為在關閉dialog之后會調用onCancle()方法，可以響應在關閉對話框之后的一些動作；

              dialog.dismiss()：直接關閉對話框，沒有響應；

3.7 網絡請求中加入loader

【client】

【builder】

 

【說明】handler聲明的時候加關鍵字static；可以避免內存泄露；

【測試】

 【增加失敗時候關閉loader】

4.網絡框架優化與完善

4.1【支持原始數據的post請求】

4.2【支持原始數據的putRaw】

4.3【增加UPLOAD上傳方法】

【會存在文件的傳遞】

5.文件下載功能設計與實現

【說明】比較復雜；

【增加參數】

 

【新建downloadhandler】新建下載處理類；

【使用異步的下載方法】

【file工具類】沒有講解，課下編寫的

package com.flj.latte.util.file;

import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.res.AssetManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Typeface;
import android.media.MediaScannerConnection;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.webkit.MimeTypeMap;
import android.widget.TextView;

import com.flj.latte.app.Latte;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;


public final class FileUtil {

    //格式化的模板
    private static final String TIME_FORMAT = "_yyyyMMdd_HHmmss";

    private static final String SDCARD_DIR =
            Environment.getExternalStorageDirectory().getPath();

    //默認本地上傳圖片目錄
    public static final String UPLOAD_PHOTO_DIR =
            Environment.getExternalStorageDirectory().getPath() + "/a_upload_photos/";

    //網頁緩存地址
    public static final String WEB_CACHE_DIR =
            Environment.getExternalStorageDirectory().getPath() + "/app_web_cache/";

    //系統相機目錄
    public static final String CAMERA_PHOTO_DIR =
            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getPath() + "/Camera/";

    private static String getTimeFormatName(String timeFormatHeader) {
        final Date date = new Date(System.currentTimeMillis());
        //必須要加上單引號
        final SimpleDateFormat dateFormat = new SimpleDateFormat("'" + timeFormatHeader + "'" + TIME_FORMAT, Locale.getDefault());
        return dateFormat.format(date);
    }

    /**
     * @param timeFormatHeader 格式化的頭(除去時間部分)
     * @param extension        后綴名
     * @return 返回時間格式化后的文件名
     */
    public static String getFileNameByTime(String timeFormatHeader, String extension) {
        return getTimeFormatName(timeFormatHeader) + "." + extension;
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
    private static File createDir(String sdcardDirName) {
        //拼接成SD卡中完整的dir
        final String dir = SDCARD_DIR + "/" + sdcardDirName + "/";
        final File fileDir = new File(dir);
        if (!fileDir.exists()) {
            fileDir.mkdirs();
        }
        return fileDir;
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
    public static File createFile(String sdcardDirName, String fileName) {
        return new File(createDir(sdcardDirName), fileName);
    }

    private static File createFileByTime(String sdcardDirName, String timeFormatHeader, String extension) {
        final String fileName = getFileNameByTime(timeFormatHeader, extension);
        return createFile(sdcardDirName, fileName);
    }

    //獲取文件的MIME
    public static String getMimeType(String filePath) {
        final String extension = getExtension(filePath);
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }

    //獲取文件的后綴名
    public static String getExtension(String filePath) {
        String suffix = "";
        final File file = new File(filePath);
        final String name = file.getName();
        final int idx = name.lastIndexOf('.');
        if (idx > 0) {
            suffix = name.substring(idx + 1);
        }
        return suffix;
    }

    /**
     * 保存Bitmap到SD卡中
     *
     * @param dir      目錄名,只需要寫自己的相對目錄名即可
     * @param compress 壓縮比例 100是不壓縮,值約小壓縮率越高
     * @return 返回該文件
     */
    public static File saveBitmap(Bitmap mBitmap, String dir, int compress) {

        final String sdStatus = Environment.getExternalStorageState();
        // 檢測sd是否可用
        if (!sdStatus.equals(Environment.MEDIA_MOUNTED)) {
            return null;
        }
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        File fileName = createFileByTime(dir, "DOWN_LOAD", "jpg");
        try {
            fos = new FileOutputStream(fileName);
            bos = new BufferedOutputStream(fos);
            mBitmap.compress(Bitmap.CompressFormat.JPEG, compress, bos);// 把數據寫入文件
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {

                if (bos != null) {
                    bos.flush();
                }
                if (bos != null) {
                    bos.close();
                }
                //關閉流
                if (fos != null) {
                    fos.flush();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        refreshDCIM();

        return fileName;
    }

    public static File writeToDisk(InputStream is, String dir, String name) {
        final File file = FileUtil.createFile(dir, name);
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;

        try {
            bis = new BufferedInputStream(is);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);

            byte data[] = new byte[1024 * 4];

            int count;
            while ((count = bis.read(data)) != -1) {
                bos.write(data, 0, count);
            }

            bos.flush();
            fos.flush();


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos != null) {
                    bos.close();
                }
                if (fos != null) {
                    fos.close();
                }
                if (bis != null) {
                    bis.close();
                }
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return file;
    }

    public static File writeToDisk(InputStream is, String dir, String prefix, String extension) {
        final File file = FileUtil.createFileByTime(dir, prefix, extension);
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;

        try {
            bis = new BufferedInputStream(is);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);

            byte data[] = new byte[1024 * 4];

            int count;
            while ((count = bis.read(data)) != -1) {
                bos.write(data, 0, count);
            }

            bos.flush();
            fos.flush();


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos != null) {
                    bos.close();
                }
                if (fos != null) {
                    fos.close();
                }
                if (bis != null) {
                    bis.close();
                }
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return file;
    }

    /**
     * 通知系統刷新系統相冊，使照片展現出來
     */
    private static void refreshDCIM() {
        if (Build.VERSION.SDK_INT >= 19) {
            //兼容android4.4版本，只掃描存放照片的目錄
            MediaScannerConnection.scanFile(Latte.getApplicationContext(),
                    new String[]{Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getPath()},
                    null, null);
        } else {
            //掃描整個SD卡來更新系統圖庫，當文件很多時用戶體驗不佳，且不適合4.4以上版本
            Latte.getApplicationContext().sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED, Uri.parse("file://" +
                    Environment.getExternalStorageDirectory())));
        }
    }

    /**
     * 讀取raw目錄中的文件,並返回為字符串
     */
    public static String getRawFile(int id) {
        final InputStream is = Latte.getApplicationContext().getResources().openRawResource(id);
        final BufferedInputStream bis = new BufferedInputStream(is);
        final InputStreamReader isr = new InputStreamReader(bis);
        final BufferedReader br = new BufferedReader(isr);
        final StringBuilder stringBuilder = new StringBuilder();
        String str;
        try {
            while ((str = br.readLine()) != null) {
                stringBuilder.append(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                isr.close();
                bis.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return stringBuilder.toString();
    }


    public static void setIconFont(String path, TextView textView) {
        final Typeface typeface = Typeface.createFromAsset(Latte.getApplicationContext().getAssets(), path);
        textView.setTypeface(typeface);
    }

    /**
     * 讀取assets目錄下的文件,並返回字符串
     */
    public static String getAssetsFile(String name) {
        InputStream is = null;
        BufferedInputStream bis = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        StringBuilder stringBuilder = null;
        final AssetManager assetManager = Latte.getApplicationContext().getAssets();
        try {
            is = assetManager.open(name);
            bis = new BufferedInputStream(is);
            isr = new InputStreamReader(bis);
            br = new BufferedReader(isr);
            stringBuilder = new StringBuilder();
            String str;
            while ((str = br.readLine()) != null) {
                stringBuilder.append(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (isr != null) {
                    isr.close();
                }
                if (bis != null) {
                    bis.close();
                }
                if (is != null) {
                    is.close();
                }
                assetManager.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (stringBuilder != null) {
            return stringBuilder.toString();
        } else {
            return null;
        }
    }

    public static String getRealFilePath(final Context context, final Uri uri) {
        if (null == uri) return null;
        final String scheme = uri.getScheme();
        String data = null;
        if (scheme == null)
            data = uri.getPath();
        else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
            data = uri.getPath();
        } else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
            final Cursor cursor = context.getContentResolver().query(uri, new String[]{MediaStore.Images.ImageColumns.DATA}, null, null, null);
            if (null != cursor) {
                if (cursor.moveToFirst()) {
                    final int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
                    if (index > -1) {
                        data = cursor.getString(index);
                    }
                }
                cursor.close();
            }
        }
        return data;
    }
}

 【保存文件類的封裝】

 

【繼續封裝com.flj.latte.net.download.DownloadHandler】

【調用的方法】在后面的使用文件下載然后更新應用程序；

【提交代碼】

 

6.攔截器功能設計與實現之攔截器的初始化

【說明】沒有搭建服務器，然后使用okhttp庫中的攔截功能，將接收到請求之后做出響應，返回json文件；

6.1【配置文件中的攔截器的配置】

 

6.2 將配置文件中的interceptors請求配置到okhttp

【接收請求】

7.攔截器功能設計與實現之模擬請求

【說明】模擬服務器：獲取傳入的參數，

【get方法】則：從url獲取參數；

【post方法】：從請求體中獲取參數；

7.1 基類封裝

 

7.3 調試類封裝

 

package com.flj.latte.net.interceptors;

import android.support.annotation.NonNull;
import android.support.annotation.RawRes;

import com.flj.latte.util.file.FileUtil;

import java.io.IOException;

import okhttp3.MediaType;
import okhttp3.Protocol;
import okhttp3.Response;
import okhttp3.ResponseBody;


public class DebugInterceptor extends BaseInterceptor {

    private final String DEBUG_URL;
    private final int DEBUG_RAW_ID;

    public DebugInterceptor(String debugUrl, int rawId) {
        this.DEBUG_URL = debugUrl;
        this.DEBUG_RAW_ID = rawId;
    }

    private Response getResponse(Chain chain, String json) {
        return new Response.Builder()
                .code(200)
                .addHeader("Content-Type", "application/json")
                .body(ResponseBody.create(MediaType.parse("application/json"), json))
                .message("OK")
                .request(chain.request())
                .protocol(Protocol.HTTP_1_1)
                .build();
    }

    //debug的封裝，根據rawId查詢獲取json；
    private Response debugResponse(Chain chain, @RawRes int rawId) {
        final String json = FileUtil.getRawFile(rawId); //根據rawId取出原始文件；
        return getResponse(chain, json);//返回Response請求的響應；
    }

    /**
     * 說明：此時存在的json文件是存在在單個應用程序的res/raw文件夾下的json；
     * @param chain
     * @return
     * @throws IOException
     */
    @Override
    public Response intercept(@NonNull Chain chain) throws IOException {
        final String url = chain.request().url().toString(); //得到攔截的url；
        if (url.contains(DEBUG_URL)) { //攔截的url包含了DEBUG_URL，返回存在的json文件；
            return debugResponse(chain, DEBUG_RAW_ID);
        }
        return chain.proceed(chain.request()); //否則原樣返回數據；
    }
}

 7.4 使用

【效果】就可以不適用服務器的數據，直接可以在本地進行json數據的加載和測試；