Android 帶雙向認證的Retrofit基礎使用

參考資料
- 簡單使用get http://blog.csdn.net/qq_23077365/article/details/52164375
- 添加請求頭和上傳圖片 http://blog.csdn.net/linzhenxiang123/article/details/53956435
- 發送請求中添加身份驗證 http://www.cnblogs.com/guanghuiz/p/5476972.html
- SSL雙向驗證 http://blog.csdn.net/u012874222/article/details/50339259
- 如何使用@body發送post http://www.cnblogs.com/fengfenghuifei/p/6038309.html
生成兩個bks文件（如何生成可以參考以下鏈接，講的比較詳細，但是如果只是想知道如何使用，看生成部分就可以了），放入assets文件夾下：
Android HTTPS 自制證書實現雙向認證(OkHttp + Retrofit + Rxjava)

在build.gradle添加如下包：

dependencies {
    compile 'io.reactivex:rxjava:1.2.3'
    compile 'io.reactivex:rxandroid:1.2.1'
    /**
     * Retrofit, adapter-rxjava, converter-gson must be the same version!!!
     * ↑ 就是說版本包得一致纔行噻~
     */
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    }

在java/包名下，新建一個文件夾（我的叫retrofit）。

新建一個UnSafeHostnameVerifier放到retrofit下，內容如下：

public class UnSafeHostnameVerifier implements
        HostnameVerifier {
    @Override
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }
}

新建一個SSLHelper（這個其實所有雙向認證用的都是一樣的，並不是專門針對Retrofit的）放到retrofit下，內容如下：

public class SSLHelper {
private final static String CLIENT_PRI_KEY = "hengtiansoft.com.bks";
private final static String TRUSTSTORE_PUB_KEY = "client-truststore.bks";
private final static String CLIENT_BKS_PASSWORD = "hT118InsIgmA";
private final static String TRUSTSTORE_BKS_PASSWORD = "wso2carbon";
private final static String KEYSTORE_TYPE = "BKS";
private final static String PROTOCOL_TYPE = "TLS";
private final static String CERTIFICATE_STANDARD = "X509";

public static SSLSocketFactory getSSLCertifcation(Context context) {
    SSLSocketFactory sslSocketFactory = null;
    try {
        // 服務器端需要驗證的客戶端證書，其實就是客戶端的keystore
        KeyStore keyStore = KeyStore.getInstance(KEYSTORE_TYPE);
        // 客戶端信任的服務器端證書
        KeyStore trustStore = KeyStore.getInstance(KEYSTORE_TYPE);

        //讀取證書
        InputStream ksIn = context.getAssets().open(CLIENT_PRI_KEY);
        InputStream tsIn = context.getAssets().open(TRUSTSTORE_PUB_KEY);

        //加載證書
        keyStore.load(ksIn, CLIENT_BKS_PASSWORD.toCharArray());
        trustStore.load(tsIn, TRUSTSTORE_BKS_PASSWORD.toCharArray());
        ksIn.close();
        tsIn.close();

        //初始化SSLContext
        SSLContext sslContext = SSLContext.getInstance(PROTOCOL_TYPE);
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(CERTIFICATE_STANDARD);
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(CERTIFICATE_STANDARD);
        trustManagerFactory.init(trustStore);
        keyManagerFactory.init(keyStore, CLIENT_BKS_PASSWORD.toCharArray());
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);

        sslSocketFactory = sslContext.getSocketFactory();

    } catch (KeyStoreException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (CertificateException e) {
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (UnrecoverableKeyException e) {
        e.printStackTrace();
    } catch (KeyManagementException e) {
        e.printStackTrace();
    }
    return sslSocketFactory;
}

public static OkHttpClient genericClient() {
    OkHttpClient httpClient = new OkHttpClient.Builder()
            .addInterceptor(new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    Request request = chain.request()
                            .newBuilder()
                            .addHeader("Authentication-Token", "d90d790cf80d1078750e840a8922c02b-1376208214")
                            .build();
                    return chain.proceed(request);
                }

            })
            .build();
    return httpClient;
 }
}

根據業務邏輯，新建一個BaseResponse在retrofit文件夾下，內容如下：

public class BaseResponse <T> {
    public static String UNKNOWN_ERROR = "未知錯誤";
    private boolean success;
    private String errorCode;

    private T data;

    private String msg;

    public BaseResponse() {

    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
     }
    }

根據業務邏輯，新建一個數據傳輸類（按照接口來寫，在此選取一個Token類），內容如下：

public class Token {
    private String TGT;
    private String token;

    public String getTGT() {
        return TGT;
    }

    public void setTGT(String TGT) {
        this.TGT = TGT;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }
   }

根據業務返回，新建一個CallBack，內容如下：

public abstract class RetrofitCallBack<T extends BaseResponse> implements Callback<T> {
    @Override
    public void onResponse(Call<T> call, Response<T> response) {
        if (response.raw().code() == 200) {//200是服務器有合理響應
            if (response.body() != null) {
                onBizSuccess(response.body());
            } else {

                onBizFail(originResult, response.body(), response.raw().code());

            }
        } else {//失敗響應
            onFailure(call, new RuntimeException("response error,detail = " + response.raw().toString()));
        }
    }

    @Override
    public void onFailure(Call<T> call, Throwable ex) {//網絡問題會走該回調
        if (ex instanceof SocketTimeoutException) {
            //
        } else if (ex instanceof ConnectException) {
            //
        } else if (ex instanceof RuntimeException) {
            //
        }
        onFail(ex);
    }

    public abstract void onBizSuccess(T result);

    public abstract void onBizFail(String originResult, T result, int returnCode);
    public abstract void onFail(Throwable ex);  
}

根據業務模塊區分，新建一個service（我在這裏選取一個AuthService），內容如下：

public interface AuthService {
/**
 * 獲取token
 *
 * @param appKey
 * @param token       
 * @param requestBody
 * @return
 */
@POST("/services/htmf-auth/getToken")
Call<BaseResponse<Token>> getToken(@Header("AppKey") String appKey, @Body RequestBody requestBody);

}

新建一個RetrofitClient類放在retrofit下，內容如下：

public class RetrofitClient {

    public static final String HTTP_CACHE_DIR = "DemoCache";

//ip地址
   public static final String BASE_URL = "https://xxx.xxx.com";

    /**
     * 網絡請求接口包裝類，可細分多個Service
     **/
    public AuthService authService;
    public static final long DEFAULT_TIMEOUT = 7676l;
    private static Context mContext;

    /**
     * 在訪問HttpMethods時創建延遲加載的單例
     **/
    private static class SingletonHolder {
        private static final RetrofitClient INSTANCE = new RetrofitClient(mContext);
    }

    // 獲取單例
    public static RetrofitClient getInstance(Context context) {
        if (context != null) {
            mContext = context;
        }
        return SingletonHolder.INSTANCE;
    }


    private RetrofitClient(Context context) {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();

        builder.sslSocketFactory(SSLHelper.getSSLCertifcation(context));
        builder.hostnameVerifier(new UnSafeHostnameVerifier());
        // 網絡請求的緩存機制，無網絡也能顯示數據
        File cacheFile = new File(context.getCacheDir(), HTTP_CACHE_DIR);
        Cache cache = new Cache(cacheFile, 1024 * 1024 * 50);
        builder.addNetworkInterceptor(new HttpCacheInterceptor());

        // 保持請求是同一個cookie
        CookieManager cookieManager = new CookieManager();
        cookieManager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);

        // 其他設置
        builder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS)
                .readTimeout(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS)
                .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS)
                .retryOnConnectionFailure(true)// 錯誤重連
//                .addInterceptor(addQueryParameterInterceptor)// 公共參數
                .cache(cache);// 緩存目錄
//                .cookieJar(new JavaNetCookieJar(cookieManager));

        OkHttpClient okHttpClient = builder.build();

        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").serializeNulls().create();

        Retrofit retrofit = new Retrofit.Builder()
                .client(okHttpClient)// okhttp的實現
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())// RxJava支持
                .addConverterFactory(GsonConverterFactory.create(gson))// Gson支持
                .baseUrl(BASE_URL)// 請求地址
                .build();
        // 可使用ServiceFactory細分接口服務
        authService = retrofit.create(AuthService.class);
        eventAnalyticService = retrofit.create(EventAnalyticService.class);
    }


    class HttpCacheInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            if (!NetWorkUtil.isNetConnected(mContext)) {
                request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
            }
            Response originalResponse = chain.proceed(request);
            if (NetWorkUtil.isNetConnected(mContext)) {
                // 有網的時候讀接口上的@Headers裏的配置，你可以在這裏進行統一的設置
                String cacheControl = request.cacheControl().toString();
                // int maxAge = 0;
                return originalResponse.newBuilder()
                        .header("Cache-Control", cacheControl)//"public, max-age="+maxAge
                        .removeHeader("Pragma")// 清除頭信息，因爲服務器如果不支持會返回一些干擾信息，不清除下面無法生效

                        .build();
            } else {
                int maxStale = 60 * 60 * 24 * 28;// 2419200
                return originalResponse.newBuilder()
                        .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                        .removeHeader("Pragma")
                        .build();
            }
    }
}

已經可以調用啦~

Map<String, String>  values="";//此處的value值自己添加
String postTokenStr = JSON.toJSONString(values);
RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), postTokenStr);        
RetrofitClient.getInstance(context).authService.getToken("", "", body).enqueue(new RetrofitCallBack<BaseResponse<Token>>() {


            @Override
            public void onBizSuccess(BaseResponse<Token> result) {

            }

            @Override
            public void onBizFail(String originResult, BaseResponse<Token> result, int returnCode) {

            }

            @Override
                public void onFail(Throwable ex) {
            }

        });

Android 帶雙向認證的Retrofit基礎使用

MySQL 核心模塊揭祕 | 18 期 | 鎖在內存里長什麼樣*

使用perf工具生成火焰圖

大齡程序員思考

響應式界面控件DevExtreme * 更強的數據分析和可視化功能

HttpSecurity 是如何組裝過濾器鏈的

數說海南——近6年海南各市縣人口簡單看

長序列中Transformers的高級注意力機制總結

WebStorm 創建 Vue 項目

《最重要的事，只有一件》-[美] 加里·凱勒 / [美]傑伊·帕帕森

Android基礎知識複習（六）

Android 帶雙向認證的Retrofit基礎使用

Android 基礎知識複習（一）

《人月神話》-Frederick P.Brooks,Jr

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結