xUtils-2.6.14在android5.0以下系统https问题

首先自定义 SSLSocketFactory 

package com.lidroid.xutils.util;


import android.os.Build;


import com.lidroid.xutils.http.client.DefaultSSLSocketFactory;


import org.apache.http.conn.ssl.SSLSocketFactory;


import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;


import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;


/**
 * Created by  on 2017/10/25 14:22.
 * 邮箱：sunxiangyuan12@163.com
 */
public    class SSLSocketFactoryEx extends SSLSocketFactory {


    static String protocols[] = null, cipherSuites[] = null;


    SSLContext sslContext = SSLContext.getInstance("TLS");


    static {
        try {
            SSLSocket socket = (SSLSocket) DefaultSSLSocketFactory.getSocketFactory().createSocket();
            if (socket != null) {
                /* set reasonable protocol versions */
                // - enable all supported protocols (enables TLSv1.1 and TLSv1.2 on Android <5.0)
                // - remove all SSL versions (especially SSLv3) because they're insecure now
                List<String> protocols = new LinkedList<>();
                for (String protocol : socket.getSupportedProtocols())
                    if (!protocol.toUpperCase().contains("SSL"))
                        protocols.add(protocol);
                SSLSocketFactoryEx.protocols = protocols.toArray(new String[protocols.size()]);
                /* set up reasonable cipher suites */
                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
                    // choose known secure cipher suites
                    List<String> allowedCiphers = Arrays.asList(
                            // TLS 1.2
                            "TLS_RSA_WITH_AES_256_GCM_SHA384",
                            "TLS_RSA_WITH_AES_128_GCM_SHA256",
                            "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
                            "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
                            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
                            "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
                            "TLS_ECHDE_RSA_WITH_AES_128_GCM_SHA256",
                            // maximum interoperability
                            "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
                            "TLS_RSA_WITH_AES_128_CBC_SHA",
                            // additionally
                            "TLS_RSA_WITH_AES_256_CBC_SHA",
                            "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
                            "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
                            "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
                            "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
                    List<String> availableCiphers = Arrays.asList(socket.getSupportedCipherSuites());
                    // take all allowed ciphers that are available and put them into preferredCiphers
                    HashSet<String> preferredCiphers = new HashSet<>(allowedCiphers);
                    preferredCiphers.retainAll(availableCiphers);
                    /* For maximum security, preferredCiphers should *replace* enabled ciphers (thus disabling
                     * ciphers which are enabled by default, but have become unsecure), but I guess for
                     * the security level of DAVdroid and maximum compatibility, disabling of insecure
                     * ciphers should be a server-side task */
                    // add preferred ciphers to enabled ciphers
                    HashSet<String> enabledCiphers = preferredCiphers;
                    enabledCiphers.addAll(new HashSet<>(Arrays.asList(socket.getEnabledCipherSuites())));
                    SSLSocketFactoryEx.cipherSuites = enabledCiphers.toArray(new String[enabledCiphers.size()]);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    public SSLSocketFactoryEx(KeyStore truststore)


            throws NoSuchAlgorithmException, KeyManagementException,


            KeyStoreException, UnrecoverableKeyException {


        super(truststore);






        TrustManager tm = new X509TrustManager() {






            @Override


            public java.security.cert.X509Certificate[] getAcceptedIssuers() {


                return null;


            }






            @Override


            public void checkClientTrusted(


                    java.security.cert.X509Certificate[] chain, String authType)


                    throws java.security.cert.CertificateException {






            }






            @Override


            public void checkServerTrusted(


                    java.security.cert.X509Certificate[] chain, String authType)


                    throws java.security.cert.CertificateException {






            }


        };






        sslContext.init(null, new TrustManager[] { tm }, null);


    }






    @Override


    public Socket createSocket(Socket socket, String host, int port,


                               boolean autoClose) throws IOException, UnknownHostException {


        Socket ssl = sslContext.getSocketFactory().createSocket(socket, host, port,


                autoClose);
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket)ssl);
        return ssl;


    }






    @Override


    public Socket createSocket() throws IOException {
        Socket ssl = sslContext.getSocketFactory().createSocket();
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket)ssl);
        return ssl;


    }
    private void upgradeTLS(SSLSocket ssl) {
        // Android 5.0+ (API level21) provides reasonable default settings
        // but it still allows SSLv3
        // https://developer.android.com/about/versions/android-5.0-changes.html#ssl
        if (protocols != null) {
            ssl.setEnabledProtocols(protocols);
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP && cipherSuites != null) {
            ssl.setEnabledCipherSuites(cipherSuites);
        }
    }

然后：xutil初始化时添加如下代码

 public static final void init(Context context) {
        if (httpUtils == null) {
            synchronized (MyHttpUtil.class) {
                if(httpUtils == null){
                    cookieStore = new PreferencesCookieStore(context);
// cookieStore = new BasicCookieStore();
                    httpUtils = new HttpUtils();
                    httpUtils.configTimeout(50 * 1000);
                    httpUtils.configHttpRedirectHandler(new HttpUtilDefaultHttpRedirectHandler());
                    httpUtils.configCurrentHttpCacheExpiry(0);
                    httpUtils.configCookieStore(cookieStore);
                    if(Build.VERSION.SDK_INT <Build.VERSION_CODES.LOLLIPOP){
                        try {
                            KeyStore trustStore = KeyStore.getInstance(KeyStore
                                    .getDefaultType());
                            trustStore.load(null, null);
                            SSLSocketFactory sf = new SSLSocketFactoryEx(trustStore);
//                sf.
                            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);  //允许所有主机的验证
                            httpUtils.getHttpClient().getConnectionManager().getSchemeRegistry().unregister("https");
                            httpUtils.configRegisterScheme(new Scheme("https", sf, 443));
//                schReg.register(new Scheme("http", PlainSocketFactory
//
//                                .getSocketFactory(), 80));
//
//                schReg.register(new Scheme("https", sf, 443));
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
//            final SSLSocketFactory sslSocketFactory = DefaultSSLSocketFactory.getSocketFactory();
//            sslSocketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
//            utils.configSSLSocketFactory(sslSocketFactory);
                    }
                }
            }
        }
    }