Glide入门教程——17.Glide Module 案例: 接受自签名HTTPS证书

Glide Module 案例: 接受自签名HTTPS证书

原文：Glide Module Example: Self-Signed HTTPS Network Stack
作者：Norman Peitek
翻译：Dexter0218

在上一篇Glide的文章中，你已经学了GlideModule的基础知识。他们提供了一个简单的方法去访问Glide核心部分的功能。你可以很快地通过实现和定义GlideModule改变Glide的行为。我们已经通过实现applyOptions()方法改变解析格式，去提升图片质量。文本，我们要使用其他的方法，registerComponents()，去改变Glide的网络栈，让它能从自签名HTTPS服务器接收连接和图片。

文／签到钱就到（简书作者）
原文链接：http://www.jianshu.com/p/b78b219ff367

著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。

用GlideModule定制Glide

在看下面的之前，请确保你看完并理解了前面文章关于GlideModules部分。我们不会在本文中再次回顾基础，而是直接跳到问题。所以确保你打好GlideModule的基础。

你已经知道GlideModule提供了两个方法改变行为。上篇文章，我们学习了第一个方法applyOption()。本文我们使用另一个方法registerComponents()去设置一个不同的网络栈。默认地，Glide内部使用标准的HTTPUrlConnection去下载图片。Glide也提供两个集成库。这三个方法优点是在安全设置上都是相当严格的。唯一的不足之处是当你从一个使用HTTPS，还是self-signed的服务器下载图片时，Glide并不会下载或者显示图片，因为self-signed认证会被认为存在安全问题。

不安全的 OkHttpClient

这样，你会需要去实现能够接受self-signed认证的网络栈。幸运地，我们已经实现并用过一个“不安全的”OkHttpClient。由于它提供给了一个需要集成的常规OkHttpClient,我们只需要拷贝并粘贴这个类：

public class UnsafeOkHttpClient {  
    public static OkHttpClient getUnsafeOkHttpClient() {
        try {
            // Create a trust manager that does not validate certificate chains
            final TrustManager[] trustAllCerts = new TrustManager[]{
                    new X509TrustManager() {
                        @Override
                        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                        }

                        @Override
                        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                        }

                        @Override
                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                            return null;
                        }
                    }
            };

            // Install the all-trusting trust manager
            final SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());

            // Create an ssl socket factory with our all-trusting manager
            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            OkHttpClient okHttpClient = new OkHttpClient();
            okHttpClient.setSslSocketFactory(sslSocketFactory);
            okHttpClient.setProtocols(Arrays.asList(Protocol.HTTP_1_1));
            okHttpClient.setHostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });

            return okHttpClient;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

创建的OkHttpClient关闭了所有的SSL认证检查。

集成到 Glide

Glide的OkHTTP集成库做的都是一样的工作，所以我们可以跟随他们的步骤。首先，我们需要在GlideModule里声明我们的定制。你应该想到，我们需要在registerComponents()方法里做适配。我们可以调用.register()方法去交换Glide基础构成。Glide使用一个ModelLoader去链接到数据模型创建一个具体的数据类型。我们的例子中，我们需要创建一个ModelLoader，它连接到一个URL，通过GlideUrl类响应并转化为输入流。Glide需要能够创建我们的新ModelLoader的实例，所以我们在.register()方法中传入一个工厂：

public class UnsafeOkHttpGlideModule implements GlideModule {  
        @Override
        public void applyOptions(Context context, GlideBuilder builder) {

        }

        @Override
        public void registerComponents(Context context, Glide glide) {
            glide.register(GlideUrl.class, InputStream.class, new OkHttpUrlLoader.Factory());
        }
    }

方法里的前两个参数是模型类和链接资源类。最后一个参数是ModelLoaderFactory。最终，我们不能直接设置一个UnsafeOkHttpClient实例，我们需要创建一个ModelLoaderFactory，使用UnsafeOkHttpClient去提供URL和输入流之间的链接。

再次，OkHttp集成库给了我们一个很棒的模版：

public class OkHttpUrlLoader implements ModelLoader<GlideUrl, InputStream> {

    /**
     * The default factory for {@link OkHttpUrlLoader}s.
     */
    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 = UnsafeOkHttpClient.getUnsafeOkHttpClient();
                    }
                }
            }
            return internalClient;
        }

        /**
         * Constructor for a new Factory that runs requests using a static singleton client.
         */
        public Factory() {
            this(getInternalClient());
        }

        /**
         * Constructor for a new Factory that runs requests using given client.
         */
        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() {
            // Do nothing, this instance doesn't own the client.
        }
    }

    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);
    }
}

在这个类里，你可以看到ModelLoaderFactory是如何被构造的。对我们来说，最重要的一行是internalClient对象的创建：internalClient = UnsafeOkHttpClient.getUnsafeOkHttpClient();。

不幸地是，我们仍然要使用我们不安全的OkHttpClient去链接Url到一个有效的输入流。这样，我们需要另外一个类去取到URL对应的输入流的响应：

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) {
                // Ignored
            }
        }
        if (responseBody != null) {
            try {
                responseBody.close();
            } catch (IOException e) {
                // Ignored.
            }
        }
    }

    @Override
    public String getId() {
        return url.getCacheKey();
    }

    @Override
    public void cancel() {
        // TODO: call cancel on the client when this method is called on a background thread. See #257
    }
}

你没必要明白类里面的所有细节。相反，你应当对于Glide系统如何替换内部工厂部分有个概述。

展望

本文中，你已经看了另一个改变Glide工作方式使用案例。我们已经实现了一个“不安全”的网络栈，并且用GlideModule的registerComponents()集成它到Glide内。但那也仅是Glide可修改内容的冰山一角。

下篇文章，我们会学习另一个使用GlideModule去改变Glide缓存方式的案例。

文／签到钱就到（简书作者）
原文链接：http://www.jianshu.com/p/b78b219ff367
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。