Okhttp网络请求最佳实践(一）

最新推荐文章于 2024-06-08 14:00:00 发布

YuannaY

最新推荐文章于 2024-06-08 14:00:00 发布

阅读量958

点赞数

分类专栏： Android开发文章标签： Okhttp

本文链接：https://blog.csdn.net/YuannaY/article/details/82846776

版权

Android开发专栏收录该内容

12 篇文章 0 订阅

订阅专栏

首先是实现网络的配置：

先获取网络权限；
再声明两个变量，有关网络操作权限的；
声明一个url地址。

public class constants {
    private static final int WRITE_READ_EXTERNASL_CODE=999;
    private static final String[] WRITE_READ_EXTERNAL_PERMISSION ={Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE};

}
public class Urlconstants {
public static final String USER_LOGIN="http://www.kuaidi100.com/query";//快递查询URL
}

其次是modle层，这里就只用一个空的user层。

public class user {
}

然后进入到Okhttp的框架：

首先是新建一个异常类OkhttpExcetion，服务器返回错误的消息以及错误编号。

public class OkhttpsException extends Exception{
    private static final long sertalVersion=1L;
    /**
     * 返回服务器的数据
     */
    private  int ecode;
    /**
     * 服务器返回错误消息
     */
    private Object emsg;
    public OkhttpsException(int ecode,Object emsg)
    {
        this.ecode=ecode;
        this.emsg=emsg;

    }
    public int getEcode()//返回服务器返回的信息
    {
        return ecode;

    }
    public Object getEmsg()
    {
        return emsg;
    }
}

2.Okhttp的httpsutil;涉及到SSL，https://blog.csdn.net/qq_31694651/article/details/52372341,大家可以看看这位大佬的博客，可以稍稍理解SSL以及相关的Factory操作。

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.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

/**
 * 网络请求
 */
public class HttpsUtils {
    /**
     *SSL安全协议
     */
    public static class SSLParams
    {
        public SSLSocketFactory sslSocketFactory;
        public X509TrustManager trustManager;

    }

    /**
     * 获取证书
     * @param certificate,证书
     * @param bksFile,bks文件格式的文件
     * @param password
     * @return
     */
    public static SSLParams getSslSocketFactory(InputStream[] certificate,InputStream bksFile,String password)
    {
        SSLParams sslParams =new SSLParams();
        try
        {
            TrustManager[] trustManagers = prepareTrustManager(certificate);
            KeyManager[] keyManagers = prepareKeyManager(bksFile,password);

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

            X509TrustManager trustManager=null;

            if(trustManagers!=null)
            {
                trustManager = new MyTrustManager(chooseTrustManager(trustManagers));
            }else
            {
                trustManager=new UnsafeTrustManager();
            }
            /**
            初始化sslContext,
             */
            sslContext.init(keyManagers,new TrustManager[]{trustManager},null);
            sslParams.sslSocketFactory=sslContext.getSocketFactory();
            sslParams.trustManager=trustManager;
            return sslParams;
        }catch(NoSuchAlgorithmException e)
        {
          throw new AssertionError(e);
        }catch(KeyManagementException e)
        {
            throw new AssertionError(e);
        }catch(KeyStoreException e)
        {
            throw new AssertionError(e);
        }
    }

    /**
     * 准备阶段
     * @param bksFile
     * @param password
     * @return
     */
    private static KeyManager[] prepareKeyManager(InputStream bksFile, String password)
    {
     try
     {
         if(bksFile==null||password==null)return null;//输入流为空或者密码为空

         KeyStore clientKeyStore=KeyStore.getInstance("BKS");//为keyStore提供一个bks文件格式的文件
         /**
          The system will return the most preferred implementation of the specified keystore type available in the environment.
           Before a keystore can be accessed, it must be loaded.
          */
         clientKeyStore.load(bksFile,password.toCharArray());
         KeyManagerFactory keyManagerFactory=KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
         keyManagerFactory.init(clientKeyStore,password.toCharArray());

         return keyManagerFactory.getKeyManagers();

     } catch (CertificateException e) {
         e.printStackTrace();
     } catch (NoSuchAlgorithmException e) {
         e.printStackTrace();
     } catch (IOException e) {
         e.printStackTrace();
     }catch (Exception e)
     {
         e.printStackTrace();
    }
    return null;
    }

    /**
     * 访问自签名的网站
     * @param certificates  一个证书是一个实体的数字签名,还包含这个实体的公共钥匙值.
     * @return
     * InputStream就对应于我们证书的输入流。
     * 代码内部，我们：


    构造CertificateFactory对象，通过它的generateCertificate(is)方法得到Certificate。
    然后讲得到的Certificate放入到keyStore中。
    接下来利用keyStore去初始化我们的TrustManagerFactory
    由trustManagerFactory.getTrustManagers获得TrustManager[]初始化我们的SSLContext
    最后，设置我们mOkHttpClient.setSslSocketFactory即可。

    本文来自 鸿洋_ 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/lmj623565791/article/details/48129405?utm_source=copy*/
    /**
     * 信任管理器
     * @param certificates
     * @return
     */
    private static TrustManager[] prepareTrustManager(InputStream... certificates) {
    if(certificates==null||certificates.length<=0) return null;
    try
    {
        CertificateFactory certificateFactory=CertificateFactory.getInstance("X.509");

        /**
         * Typical ways to request a KeyStore object include relying on the default type and providing a specific keystore type.
         *The system will return a keystore implementation for the default type.
         */
        KeyStore keyStore=KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null);

        int index=0;
        for(InputStream certificate :certificates)
        {
            String certificateAlias=Integer.toString(index++);
            /**
             * alias - the alias name
             * cert - the certificate
             *Assigns the given trusted certificate to the given alias.
             */
            keyStore.setCertificateEntry(certificateAlias,certificateFactory.generateCertificate(certificate));
            try
            {
                if(certificate!=null)
                {
                    certificate.close();
                }

            }catch ( Exception e)
            {

            }
        }
        TrustManagerFactory trustManagerFactory=TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(keyStore);// 接下来利用keyStore去初始化我们的TrustManagerFactory

        TrustManager[] trustManagers=trustManagerFactory.getTrustManagers();//由trustManagerFactory.getTrustManagers获得TrustManager[]

        return trustManagers;
    } catch (CertificateException e) {
        e.printStackTrace();
    } catch (KeyStoreException e) {
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
    }
    private static  X509TrustManager chooseTrustManager(TrustManager[] trustManagers)
    {
        for(TrustManager trustManager : trustManagers)
        {
            if(trustManager instanceof X509TrustManager)
            {
                return (X509TrustManager) trustManager;
            }
        }
        return null;
    }
    private static class MyTrustManager implements X509TrustManager{
        private X509TrustManager defaultTrustManager;
        private X509TrustManager localTrustManager;
        public MyTrustManager(X509TrustManager localTrustManager)throws NoSuchAlgorithmException,KeyStoreException
        {
            TrustManagerFactory var4 =TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            var4.init((KeyStore) null);
            defaultTrustManager =chooseTrustManager(var4.getTrustManagers());
            this.localTrustManager=localTrustManager;
        }

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
         try
         {
             defaultTrustManager.checkServerTrusted(chain,authType);
         }catch(CertificateException ce)
         {
             localTrustManager.checkServerTrusted(chain, authType);
         }
        }

        @Override//Return an array of certificate authority certificates which are trusted for authenticating peers.
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }

    private static class UnsafeHostnameManager implements HostnameVerifier
    {


        @Override
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    }
    public static class UnsafeTrustManager implements X509TrustManager
    {

        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {

        }

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

YuannaY

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Okhttp网络请求最佳实践(一）

首先是实现网络的配置：先获取网络权限；再声明两个变量，有关网络操作权限的；声明一个url地址。public class constants { private static final int WRITE_READ_EXTERNASL_CODE=999; private static final String[] WRITE_READ_EXTERNAL_PERM...
复制链接

扫一扫