Android 使Volley完美支持自定义证书的Https

其实在最早的版本里，Volley甚至是不支持https协议的，只能跑http，当然你也可以自己修改他的源码让他支持，如今volley的代码经过一些改进以后，

已经可以完美支持https协议了，无论是在2.3版本以上还是在2.3版本以下，大家可以尝试用volley去访问github 是成功的，但是你如果用volley去访问

12306这种类似的 用自定义证书的网站 就很容易失败。那我下面就把volley 代码稍作修改，让volley也可以完美支持自定义证书的https请求。

当然代码只是展示功能使用，你们可以用更优雅的方式 ----实现一个HttpStack，然后直接传你自定义好的stack即可。我这里图简便就写了个最简单

的演示代码。其实难倒是也不难，主要还是要考虑2.3版本以上和以下的两种情况。

第一步，把你的自定义证书 拷贝到res/raw/下。

第二步，稍微修改下volley的源码

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.volley.toolbox;

 import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.net.http.AndroidHttpClient;
 import android.os.Build;
 import android.util.Log;

 import com.android.volley.Network;
 import com.android.volley.RequestQueue;

 import org.apache.http.client.HttpClient;
 import org.apache.http.conn.scheme.PlainSocketFactory;
 import org.apache.http.conn.scheme.Scheme;
 import org.apache.http.conn.scheme.SchemeRegistry;
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
 import org.apache.http.params.BasicHttpParams;
 import org.apache.http.params.HttpParams;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.security.KeyManagementException;
 import java.security.KeyStore;
 import java.security.KeyStoreException;
 import java.security.NoSuchAlgorithmException;
 import java.security.UnrecoverableKeyException;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;

 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.TrustManagerFactory;

 public class Volley {

     /**
      * Default on-disk cache directory.
      */
     private static final String DEFAULT_CACHE_DIR = "volley";

     private Context mContext;

     /**
      * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
      *
      * @param context A {@link Context} to use for creating the cache dir.
      * @param stack   An {@link HttpStack} to use for the network, or null for default.
      * @return A started {@link RequestQueue} instance.
      */
     public static RequestQueue newRequestQueue(Context context, HttpStack stack, boolean selfSignedCertificate, int rawId) {
         File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);

         String userAgent = "volley/0";
         try {
             String packageName = context.getPackageName();
             PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
             userAgent = packageName + "/" + info.versionCode;
         } catch (NameNotFoundException e) {
         }

         if (stack == null) {
             if (Build.VERSION.SDK_INT >= 9) {
                 if (selfSignedCertificate) {
                     stack = new HurlStack(null, buildSSLSocketFactory(context, rawId));
                 } else {
                     stack = new HurlStack();
                 }
             } else {
                 // Prior to Gingerbread, HttpUrlConnection was unreliable.
                 // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
                 if (selfSignedCertificate)
                     stack = new HttpClientStack(getHttpClient(context, rawId));
                 else {
                     stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
                 }
             }
         }

         Network network = new BasicNetwork(stack);

         RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
         queue.start();

         return queue;
     }

     /**
      * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
      *
      * @param context A {@link Context} to use for creating the cache dir.
      * @return A started {@link RequestQueue} instance.
      */
     public static RequestQueue newRequestQueue(Context context) {
         return newRequestQueue(context, null, false, 0);
     }

     private static SSLSocketFactory buildSSLSocketFactory(Context context, int certRawResId) {
         KeyStore keyStore = null;
         try {
             keyStore = buildKeyStore(context, certRawResId);
         } catch (KeyStoreException e) {
             e.printStackTrace();
         } catch (CertificateException e) {
             e.printStackTrace();
         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }

         String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
         TrustManagerFactory tmf = null;
         try {
             tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
             tmf.init(keyStore);

         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         } catch (KeyStoreException e) {
             e.printStackTrace();
         }

         SSLContext sslContext = null;
         try {
             sslContext = SSLContext.getInstance("TLS");
         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         }
         try {
             sslContext.init(null, tmf.getTrustManagers(), null);
         } catch (KeyManagementException e) {
             e.printStackTrace();
         }

         return sslContext.getSocketFactory();

     }

     private static HttpClient getHttpClient(Context context, int certRawResId) {
         KeyStore keyStore = null;
         try {
             keyStore = buildKeyStore(context, certRawResId);
         } catch (KeyStoreException e) {
             e.printStackTrace();
         } catch (CertificateException e) {
             e.printStackTrace();
         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         if (keyStore != null) {
         }
         org.apache.http.conn.ssl.SSLSocketFactory sslSocketFactory = null;
         try {
             sslSocketFactory = new org.apache.http.conn.ssl.SSLSocketFactory(keyStore);
         } catch (NoSuchAlgorithmException e) {
             e.printStackTrace();
         } catch (KeyManagementException e) {
             e.printStackTrace();
         } catch (KeyStoreException e) {
             e.printStackTrace();
         } catch (UnrecoverableKeyException e) {
             e.printStackTrace();
         }

         HttpParams params = new BasicHttpParams();

         SchemeRegistry schemeRegistry = new SchemeRegistry();
         schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
         schemeRegistry.register(new Scheme("https", sslSocketFactory, 443));

         ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);

         return new DefaultHttpClient(cm, params);
     }

     private static KeyStore buildKeyStore(Context context, int certRawResId) throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException {
         String keyStoreType = KeyStore.getDefaultType();
         KeyStore keyStore = KeyStore.getInstance(keyStoreType);
         keyStore.load(null, null);

         Certificate cert = readCert(context, certRawResId);
         keyStore.setCertificateEntry("ca", cert);

         return keyStore;
     }

     private static Certificate readCert(Context context, int certResourceID) {
         InputStream inputStream = context.getResources().openRawResource(certResourceID);
         Certificate ca = null;

         CertificateFactory cf = null;
         try {
             cf = CertificateFactory.getInstance("X.509");
             ca = cf.generateCertificate(inputStream);

         } catch (CertificateException e) {
             e.printStackTrace();
         }
         return ca;
     }
 }

第三步就是调用方式稍微做下修改：

其实主要就是你如果想使用自定义的证书https的时候 第三个参数记得传true，并且把证书也传进去，

当然写的优雅的话还是最好自己写个httpstack，然后volley的源码可以不用改，只需要在使用的时候

传自己的stack即可