Android retrofit2 https 使用示例

Bertha 。 2022-02-17 09:08 451阅读 0赞

最近笔者公司有需要用到https协议的方式来做项目,所以记录一下，希望以后能回顾一下

什么是https协议，在这里我也不详细说明，你可以去[了解一下][Link 1]

1.我们先分析一下，如果我们需要用到https，有哪些地方需要做处理  
1）Retrofit 请求服务数据  
Retrofit 中的证书锁定同样是借助OkHttpClient实现的：通过为OkHttpClient添加CertificatePinner即可。CertificatePinner对象以构建器的方式创建，可以通过其add()方法来锁定多个证书。

public class OkHttpClientManager { 
        public static void setCertificates( InputStream... certificates) { 
            try { 
                CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
                KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
                keyStore.load(null);
                int index = 0;
                for (InputStream certificate : certificates) { 
                    String certificateAlias = Integer.toString(index++);
                    keyStore.setCertificateEntry(certificateAlias, certificateFactory.generateCertificate(certificate));
    
                    try { 
                        if (certificate != null)
                            certificate.close();
                    } catch (IOException e) { 
                    }
                }
    
    // SSLContext sslContext = SSLContext.getInstance("TLS");
    //
    // TrustManagerFactory trustManagerFactory =
    // TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
    //
    // trustManagerFactory.init(keyStore);
    // sslContext.init
    // (
    // null,
    // trustManagerFactory.getTrustManagers(),
    // new SecureRandom()
    // );
    // mOkHttpClient.sslSocketFactory(sslContext.getSocketFactory());
    //
    //
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        //获取这个SSLSocketFactory
        public static SSLSocketFactory getSSLSocketFactory() { 
            try { 
                SSLContext sslContext = SSLContext.getInstance("SSL");
                sslContext.init(null, getTrustManager(), new SecureRandom());
                return sslContext.getSocketFactory();
            } catch (Exception e) { 
                throw new RuntimeException(e);
            }
        }
    
        //获取TrustManager
        private static TrustManager[] getTrustManager() { 
            TrustManager[] trustAllCerts = new TrustManager[]{ 
                    new X509TrustManager() { 
    
                        @Override
                        public X509Certificate[] getAcceptedIssuers() { 
                            return new X509Certificate[]{ };
                        }
    
                        @Override
                        public void checkClientTrusted(X509Certificate[] chain,
                                                       String authType) throws CertificateException { 
                        }
    
                        @Override
                        public void checkServerTrusted(X509Certificate[] chain,
                                                       String authType) throws CertificateException { 
                        }
                    }
            };
            return trustAllCerts;
        }
    
        //获取HostnameVerifier
        public static HostnameVerifier getHostnameVerifier() { 
            HostnameVerifier hostnameVerifier = new HostnameVerifier() { 
                @Override
                public boolean verify(String hostname, SSLSession session) { 
                    return true;
                }
            };
            return hostnameVerifier;
        }
    }

【Application】

@Override
        public void onCreate() {
            super.onCreate();
            try {
                OkHttpClientManager.setCertificates(getAssets().open("AlphaSSLRootCA.cer"), getAssets().open("mediadRootCA.cer"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

【在请求服务前调用认证证书】

public static OkHttpClient defaultOkHttpClient() { 
            OkHttpClient.Builder mOkHttpClient = new OkHttpClient.Builder();
           mOkHttpClient.sslSocketFactory(OkHttpClientManager.getSSLSocketFactory());//添加证书
            mOkHttpClient.writeTimeout(30 * 1000, TimeUnit.MILLISECONDS);
            mOkHttpClient.readTimeout(10 * 1000, TimeUnit.MILLISECONDS);
            mOkHttpClient.connectTimeout(10 * 1000, TimeUnit.MILLISECONDS);
    
            //设置缓存路径
            File httpCacheDirectory = new File(app.getCacheDir(), "okhttpCache");
            //设置缓存 10M
            Cache cache = new Cache(httpCacheDirectory, 10 * 1024 * 1024);
            mOkHttpClient.cache(cache);
            //设置拦截器
            mOkHttpClient.addInterceptor(LoggingInterceptor);
            mOkHttpClient.addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR);
            mOkHttpClient.addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR);
            return mOkHttpClient.build();
        }

2）Glide 图片加载  
Glide 使用的自己的网络请求来加载的图片，想要用glide访问https图片，就必须替换掉glide原始加载图片的方法，使其同样做到信任所有证书。

首先重新GlideModule，ModelLoader，DataFetcher

【DataFetcher】

public class OkHttpStreamFetcher implements DataFetcher<InputStream> { 
        private final OkHttpClient client;
        private final GlideUrl url;
        private InputStream stream;
        private ResponseBody responseBody;
    
        public OkHttpStreamFetcher(OkHttpClient client, GlideUrl url) { 
            this.client = client;
            this.url = url;
        }
    
        @Override
        public InputStream loadData(Priority priority) throws Exception { 
            Request.Builder requestBuilder = new Request.Builder()
                    .url(url.toStringUrl());
    
            for (Map.Entry<String, String> headerEntry : url.getHeaders().entrySet()) { 
                String key = headerEntry.getKey();
                requestBuilder.addHeader(key, headerEntry.getValue());
            }
    
            Request request = requestBuilder.build();
    
            Response response = client.newCall(request).execute();
            responseBody = response.body();
            if (!response.isSuccessful()) { 
                throw new IOException("Request failed with code: " + response.code());
            }
    
            long contentLength = responseBody.contentLength();
            stream = ContentLengthInputStream.obtain(responseBody.byteStream(), contentLength);
            return stream;
        }
    
        @Override
        public void cleanup() { 
            if (stream != null) { 
                try { 
                    stream.close();
                } catch (IOException e) { 
                }
            }
            if (responseBody != null) { 
                responseBody.close();
            }
        }
    
        @Override
        public String getId() { 
            return url.getCacheKey();
        }
    
        @Override
        public void cancel() { 
        }
    }

【ModelLoader】

public class OkHttpUrlLoader implements ModelLoader<GlideUrl, InputStream> { 
    
        public static class Factory implements ModelLoaderFactory<GlideUrl, InputStream> { 
            private static volatile OkHttpClient internalClient;
            private OkHttpClient client;
    
            private static OkHttpClient getInternalClient() { 
                if (internalClient == null) { 
                    synchronized (Factory.class) { 
                        if (internalClient == null) { 
                            internalClient = new OkHttpClient();
                        }
                    }
                }
                return internalClient;
            }
    
            public Factory() { 
                this(getInternalClient());
            }
    
            public Factory(OkHttpClient client) { 
                this.client = client;
            }
    
            @Override
            public ModelLoader<GlideUrl, InputStream> build(Context context, GenericLoaderFactory factories) { 
                return new OkHttpUrlLoader(client);
            }
    
            @Override
            public void teardown() { 
            }
        }
    
        private final OkHttpClient client;
    
        public OkHttpUrlLoader(OkHttpClient client) { 
            this.client = client;
        }
    
        @Override
        public DataFetcher<InputStream> getResourceFetcher(GlideUrl model, int width, int height) { 
            return new OkHttpStreamFetcher(client, model);
        }
    }

【GlideModule】

public class OkHttpGlideModule implements GlideModule { 
        @Override
        public void applyOptions(Context context, GlideBuilder builder) { 
            // Do nothing.
        }
    
        @Override
        public void registerComponents(Context context, Glide glide) { 
            OkHttpClient mHttpClient = new OkHttpClient().newBuilder()
                    .sslSocketFactory(OkHttpClientManager.getSSLSocketFactory())
                    .hostnameVerifier(OkHttpClientManager.getHostnameVerifier())
                    .build();
            glide.register(GlideUrl.class, InputStream.class, new OkHttpUrlLoader.Factory(mHttpClient));
        }
    }

【AndroidManifes.xml】

3）WebView 数字证书  
WebView组件加载网页发生证书认证错误时，会调用WebViewClient类的onReceivedSslError方法，在这个方法里，可以点击源码看到SslErrorHandler中有两个主要的方法（我这里使用了[Tencent X5][] 浏览器）  
cancel( )  
停止加载问题页面

proceed( )  
忽略SSL证书错误，继续加载页面(不推荐）

既然用到了https，我们大部分时候都是为了网络安全问题  
所以，可以定义一个类来验证证书安全

//获取webz证书
        private static OkHttpClient.Builder setWebCertificates(OkHttpClient.Builder client) { 
            try { 
                SSLSocketFactory sslSocketFactory = OkHttpClientManager.getSSLSocketFactory();
                X509TrustManager trustManager = Platform.get().trustManager(sslSocketFactory);
                client.sslSocketFactory(sslSocketFactory, trustManager);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return client;
        }
        
    // 验证证书
        public static void webCertificateOfVerification(final SslErrorHandler handler, String url) { 
            OkHttpClient.Builder builder = OkHttpClientManager.setWebCertificates(new OkHttpClient.Builder());
            Request request = new Request.Builder().url(url)
                    .build();
            builder.build().newCall(request).enqueue(new Callback() { 
                @Override
                public void onFailure(Call call, IOException e) { 
                    Log.e("验证失败", e.getMessage());
                    handler.cancel();
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException { 
                    Log.e("验证成功", response.body().string());
                    handler.proceed();
                }
            });
        }

onReceivedSslError中的代码

private WebViewClient client = new WebViewClient() { 
            /** * 防止加载网页时调起系统浏览器 */
            public boolean shouldOverrideUrlLoading(WebView view, String url) { 
                view.loadUrl(url);
                return true;
            }
    
            /** * 处理ssl * @param webView * @param sslErrorHandler * @param sslError */
            @Override
            public void onReceivedSslError(WebView webView, SslErrorHandler sslErrorHandler, SslError sslError) { 
                OkHttpClientManager.webCertificateOfVerification(sslErrorHandler, webView.getUrl());
            }
        };

本文结合大神的文章以及自己的理解，有问题欢迎指出，共同学习

[Link 1]: https://blog.csdn.net/iispring/article/details/51615631
[Tencent X5]: https://x5.tencent.com/