Volley访问HTTPS

Volley  获取请求队列的静态方法

外部可以实现支持https的 HttpStack 

如果不为空 就用我们自定义的httpstack构造 Network 

如果为null 就用默认的 当版本小于9 用HttpClient 

大于9的 用HttpUrlConnection 链接

<span style="font-size:18px;"> public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        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) {
                stack = new HurlStack();
            } else {
                // Prior to Gingerbread, HttpUrlConnection was unreliable.
                // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }

        Network network = new BasicNetwork(stack);

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

        return queue;
    }</span>

下面是从demo拿来修改一些

<span style="font-size:18px;">public class EasySSLSocketFactory implements LayeredSocketFactory {

    private SSLContext sslcontext = null;
    private boolean isConnectingYourServer = true;
    private static Context mContext;
    
  
    public EasySSLSocketFactory(boolean isConnectingToGoinoutServer,Context context) {</span>

<span style="font-size:18px;">       
    	this.isConnectingYourServer = isConnectingToGoinoutServer;
    	this.mContext=context;
    	
    }

    private static SSLContext createEasySSLContext() throws IOException {
        try {
        	
           
        	InputStream clientStream = mContext.getResources().openRawResource(R.raw.client);
        	char[] password = "123456".toCharArray();
	        
	        KeyStore keyStore = KeyStore.getInstance("PKCS12");
	        keyStore.load(clientStream, password);
           
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, password);

	        KeyStore trustStore  = KeyStore.getInstance("BKS");
	        CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
//	        trustStore.load(null);
	        InputStream instream = null;
	        instream = mContext.getResources().openRawResource(R.raw.success);
//	        trustStore.setCertificateEntry("dd", certificateFactory.generateCertificate(instream));
	        try {
	            trustStore.load(instream, "123456".toCharArray());
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            try { instream.close(); } catch (Exception ignore) {}
	        }            

            String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
            TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
         
            tmf.init(trustStore);

            SSLContext context = SSLContext.getInstance("TLS");
         context.init(keyManagerFactory.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());

            return context;
        } catch (Exception e) {
        	e.printStackTrace();
            throw new IOException(e.getMessage());
        }
    }

    private static SSLContext createIgnoreSSLContext() throws IOException {
        try {
        	SSLContext context = SSLContext.getInstance("TLS");
        	context.init(null, new TrustManager[]{new IgnoreCertTrustManager()}, null);
        	return context;
        } catch (Exception e) {
        	e.printStackTrace();
        	throw new IOException(e.getMessage());
        }
    }

    private SSLContext getSSLContext() throws IOException {
        if (this.sslcontext == null) {
        	if(isConnectingYourServer) {
        		this.sslcontext = createEasySSLContext();
        	} else {
        		//Ignore the Certificate Authority check if not connecting to your server.
        		this.sslcontext = createIgnoreSSLContext();
        	}
        }
        
        return this.sslcontext;
    }

    public Socket connectSocket(Socket sock, String host, int port,
                                InetAddress localAddress, int localPort, HttpParams params)
            throws IOException, UnknownHostException, ConnectTimeoutException {
        int connTimeout = HttpConnectionParams.getConnectionTimeout(params);
        int soTimeout = HttpConnectionParams.getSoTimeout(params);

        InetSocketAddress remoteAddress = new InetSocketAddress(host, port);
        SSLSocket sslsock = (SSLSocket) ((sock != null) ? sock : createSocket());

        if ((localAddress != null) || (localPort > 0)) {
            // we need to bind explicitly
            if (localPort < 0) {
                localPort = 0; // indicates "any"
            }
            InetSocketAddress isa = new InetSocketAddress(localAddress,
                    localPort);
            sslsock.bind(isa);
        }

        sslsock.connect(remoteAddress, connTimeout);
        sslsock.setSoTimeout(soTimeout);
        return sslsock;

    }

    public Socket createSocket() throws IOException {
        return getSSLContext().getSocketFactory().createSocket();
    }

    public boolean isSecure(Socket socket) throws IllegalArgumentException {
        return true;
    }

    public Socket createSocket(Socket socket, String host, int port,
                               boolean autoClose) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
    }

    public boolean equals(Object obj) {
        return ((obj != null) && obj.getClass().equals(
                EasySSLSocketFactory.class));
    }

    public int hashCode() {
        return EasySSLSocketFactory.class.hashCode();
    }


}</span>

isConnectingYourServer true 证书验证

false 忽略证书验证 

<span style="font-size:18px;"> private SSLContext getSSLContext() throws IOException {
        if (this.sslcontext == null) {
        	if(isConnectingYourServer) {
        		this.sslcontext = createEasySSLContext();
        	} else {
        		//Ignore the Certificate Authority check if not connecting to your server.
        		this.sslcontext = createIgnoreSSLContext();
        	}
        }
        
        return this.sslcontext;</span>

<span style="font-size:18px;">public class IgnoreCertTrustManager implements X509TrustManager {


    @Override
    public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
    }

    @Override
    public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
    }

    @Override
    public X509Certificate[] getAcceptedIssuers() {
        return null;
    }
}
</span>

自定义HttpStack

<span style="font-size:18px;">public class SslHttpStack implements HttpStack {
    
	private boolean mIsConnectingToYourServer = false;    
    private final static String HEADER_CONTENT_TYPE = "Content-Type";
    private Context mContext;

    public SslHttpStack(boolean isYourServer,Context context) {
    	mIsConnectingToYourServer = isYourServer;
    	mContext=context;
    }
    
    private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {
        for (String key : headers.keySet()) {
            httpRequest.setHeader(key, headers.get(key));
        }
    }

    @SuppressWarnings("unused")
    private static List<NameValuePair> getPostParameterPairs(Map<String, String> postParams) {
        List<NameValuePair> result = new ArrayList<NameValuePair>(postParams.size());
        for (String key : postParams.keySet()) {
            result.add(new BasicNameValuePair(key, postParams.get(key)));
        }
        return result;
    }

    @Override
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {
        HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);
        addHeaders(httpRequest, additionalHeaders);
        addHeaders(httpRequest, request.getHeaders());
        onPrepareRequest(httpRequest);
        HttpParams httpParams = httpRequest.getParams();
        
        int timeoutMs = request.getTimeoutMs();
    
        HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
        HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
     
        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("http", new PlainSocketFactory(), 80));
        registry.register(new Scheme("https", new EasySSLSocketFactory(mIsConnectingToYourServer,mContext), 443));
     
        ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(httpParams, registry);
        HttpClient httpClient = new DefaultHttpClient(manager, httpParams); 

        return httpClient.execute(httpRequest);
    }

    /**
     * Creates the appropriate subclass of HttpUriRequest for passed in request.
     */
    @SuppressWarnings("deprecation")
    /* protected */ static HttpUriRequest createHttpRequest(Request<?> request,
            Map<String, String> additionalHeaders) throws AuthFailureError {
        switch (request.getMethod()) {
            case Method.DEPRECATED_GET_OR_POST: {
                // This is the deprecated way that needs to be handled for backwards compatibility.
                // If the request's post body is null, then the assumption is that the request is
                // GET.  Otherwise, it is assumed that the request is a POST.
                byte[] postBody = request.getPostBody();
                if (postBody != null) {
                    HttpPost postRequest = new HttpPost(request.getUrl());
                    postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());
                    HttpEntity entity;
                    entity = new ByteArrayEntity(postBody);
                    postRequest.setEntity(entity);
                    return postRequest;
                } else {
                    return new HttpGet(request.getUrl());
                }
            }
            case Method.GET:
                return new HttpGet(request.getUrl());
            case Method.DELETE:
                return new HttpDelete(request.getUrl());
            case Method.POST: {
                HttpPost postRequest = new HttpPost(request.getUrl());
                postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setMultiPartBody(postRequest,request);
                setEntityIfNonEmptyBody(postRequest, request);
                return postRequest;
            }
            case Method.PUT: {
                HttpPut putRequest = new HttpPut(request.getUrl());
                putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setMultiPartBody(putRequest,request);
                setEntityIfNonEmptyBody(putRequest, request);
                return putRequest;
            }
            // Added in source code of Volley libray.
//            case Method.PATCH: {
//            	HttpPatch patchRequest = new HttpPatch(request.getUrl());
//            	patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
//                setEntityIfNonEmptyBody(patchRequest, request);
//                return patchRequest;
//            }
            default:
                throw new IllegalStateException("Unknown request method.");
        }
    }

    private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,
            Request<?> request) throws AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            HttpEntity entity = new ByteArrayEntity(body);
            httpRequest.setEntity(entity);
        }
    }

    private static void setMultiPartBody(HttpEntityEnclosingRequestBase httpRequest,
            Request<?> request) throws AuthFailureError {
    	
    	// Return if Request is not MultiPartRequest
    	if(request instanceof MultiPartRequest == false) {
    		return;
    	}
        
    	MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);  
 
        Map<String,File> fileUpload = ((MultiPartRequest)request).getFileUploads();
        for (Map.Entry<String, File> entry : fileUpload.entrySet()) {
        	System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        	multipartEntity.addPart(((String)entry.getKey()), new FileBody((File)entry.getValue()));
        }

        Map<String,String> stringUpload = ((MultiPartRequest)request).getStringUploads();
        for (Map.Entry<String, String> entry : stringUpload.entrySet()) {
        	System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        	try {
        	multipartEntity.addPart(((String)entry.getKey()), new StringBody((String)entry.getValue()));
        	} catch (Exception e) {
        		e.printStackTrace();
        	}
        }
        
        httpRequest.setEntity(multipartEntity);
    }

    /**
     * Called before the request is executed using the underlying HttpClient.
     *
     * <p>Overwrite in subclasses to augment the request.</p>
     */
    protected void onPrepareRequest(HttpUriRequest request) throws IOException {
        // Nothing.
    }
}</span>

最后测试

<span style="font-size:18px;">	RequestQueue requestQueue= Volley.newRequestQueue(context, new SslHttpStack(true, context));
	StringRequest s= new StringRequest(Request.Method.GET, "https://localhost:8443/123.html", new Listener<String>() {

		@Override
		public void onResponse(String arg0) {
			Log.e("success", arg0);
			
		}
	}, new Response.ErrorListener() {

		@Override
		public void onErrorResponse(VolleyError arg0) {
			Log.e("erro", arg0.toString());
			
		}
	});
	 
	 requestQueue.add(s);
		
		
	} </span>