网络请求框架——OkGo解读（三）——request

最新推荐文章于 2024-04-11 06:57:55 发布
最新推荐文章于 2024-04-11 06:57:55 发布
阅读量7.2k 收藏 2
点赞数 9
分类专栏： Android网络请求框架——OkGo解读 文章标签： OkGo OkGo详读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiFangzheng/article/details/52997964
版权

所有请求的基类，其中泛型R主要用于属性设置方法后，返回对应的子类型，以便于实现链式调用

public abstract class BaseRequest<R extends BaseRequest> {

    protected String url;
    protected String baseUrl;
    protected Object tag;
    protected long readTimeOut;
    protected long writeTimeOut;
    protected long connectTimeout;
    protected int retryCount;
    protected CacheMode cacheMode;
    protected String cacheKey;
    protected long cacheTime = CacheEntity.CACHE_NEVER_EXPIRE;      //默认缓存的超时时间
    private HttpsUtils.SSLParams sslParams;
    protected HostnameVerifier hostnameVerifier;
    protected HttpParams params = new HttpParams();                 //添加的param
    protected HttpHeaders headers = new HttpHeaders();              //添加的header
    protected List<Interceptor> interceptors = new ArrayList<>();   //额外的拦截器
    protected List<Cookie> userCookies = new ArrayList<>();         //用户手动添加的Cookie

    private AbsCallback mCallback;
    private Converter mConverter;
    private HttpUrl httpUrl;
    private Request mRequest;

    public BaseRequest(String url) {
        this.url = url;
        baseUrl = url;
        httpUrl = HttpUrl.parse(url);
        OkGo go = OkGo.getInstance();
        //默认添加 Accept-Language
        String acceptLanguage = HttpHeaders.getAcceptLanguage();
        if (!TextUtils.isEmpty(acceptLanguage)) headers(HttpHeaders.HEAD_KEY_ACCEPT_LANGUAGE, acceptLanguage);
        //默认添加 User-Agent
        String userAgent = HttpHeaders.getUserAgent();
        if (!TextUtils.isEmpty(userAgent)) headers(HttpHeaders.HEAD_KEY_USER_AGENT, userAgent);
        //添加公共请求参数
        if (go.getCommonParams() != null) params.put(go.getCommonParams());
        if (go.getCommonHeaders() != null) headers.put(go.getCommonHeaders());
        //添加缓存模式
        if (go.getCacheMode() != null) cacheMode = go.getCacheMode();
        cacheTime = go.getCacheTime();
        //超时重试次数
        retryCount = go.getRetryCount();
    }

    @SuppressWarnings("unchecked")
    public R url(String url) {
        this.url = url;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R tag(Object tag) {
        this.tag = tag;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R readTimeOut(long readTimeOut) {
        this.readTimeOut = readTimeOut;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R writeTimeOut(long writeTimeOut) {
        this.writeTimeOut = writeTimeOut;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R connTimeOut(long connTimeOut) {
        this.connectTimeout = connTimeOut;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R cacheMode(CacheMode cacheMode) {
        this.cacheMode = cacheMode;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R cacheKey(String cacheKey) {
        this.cacheKey = cacheKey;
        return (R) this;
    }

    /** 传入 -1 表示永久有效,默认值即为 -1 */
    @SuppressWarnings("unchecked")
    public R cacheTime(long cacheTime) {
        if (cacheTime <= -1) cacheTime = CacheEntity.CACHE_NEVER_EXPIRE;
        this.cacheTime = cacheTime;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R setCertificates(InputStream... certificates) {
        sslParams = HttpsUtils.getSslSocketFactory(null, null, certificates);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R setCertificates(InputStream bksFile, String password, InputStream... certificates) {
        sslParams = HttpsUtils.getSslSocketFactory(bksFile, password, certificates);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R setHostnameVerifier(HostnameVerifier hostnameVerifier) {
        this.hostnameVerifier = hostnameVerifier;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R headers(HttpHeaders headers) {
        this.headers.put(headers);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R headers(String key, String value) {
        headers.put(key, value);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R removeHeader(String key) {
        headers.remove(key);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R removeAllHeaders() {
        headers.clear();
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(HttpParams params) {
        this.params.put(params);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(Map<String, String> params, boolean... isReplace) {
        this.params.put(params, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, String value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, int value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, float value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, double value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, long value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, char value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R params(String key, boolean value, boolean... isReplace) {
        params.put(key, value, isReplace);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R addUrlParams(String key, List<String> values) {
        params.putUrlParams(key, values);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R removeParam(String key) {
        params.remove(key);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R removeAllParams() {
        params.clear();
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R addCookie(String name, String value) {
        Cookie.Builder builder = new Cookie.Builder();
        Cookie cookie = builder.name(name).value(value).domain(httpUrl.host()).build();
        userCookies.add(cookie);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R addCookie(Cookie cookie) {
        userCookies.add(cookie);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R addCookies(List<Cookie> cookies) {
        userCookies.addAll(cookies);
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R setCallback(AbsCallback callback) {
        this.mCallback = callback;
        return (R) this;
    }

    @SuppressWarnings("unchecked")
    public R addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
        return (R) this;
    }

    /** 默认返回第一个参数 */
    public String getUrlParam(String key) {
        List<String> values = params.urlParamsMap.get(key);
        if (values != null && values.size() > 0) return values.get(0);
        return null;
    }

    /** 默认返回第一个参数 */
    public HttpParams.FileWrapper getFileParam(String key) {
        List<HttpParams.FileWrapper> values = params.fileParamsMap.get(key);
        if (values != null && values.size() > 0) return values.get(0);
        return null;
    }

    public HttpParams getParams() {
        return params;
    }

    public HttpHeaders getHeaders() {
        return headers;
    }

    public String getUrl() {
        return url;
    }

    public String getBaseUrl() {
        return baseUrl;
    }

    public Object getTag() {
        return tag;
    }

    public CacheMode getCacheMode() {
        return cacheMode;
    }

    public void setCacheMode(CacheMode cacheMode) {
        this.cacheMode = cacheMode;
    }

    public String getCacheKey() {
        return cacheKey;
    }

    public void setCacheKey(String cacheKey) {
        this.cacheKey = cacheKey;
    }

    public long getCacheTime() {
        return cacheTime;
    }

    public int getRetryCount() {
        return retryCount;
    }

    public Request getRequest() {
        return mRequest;
    }

    public AbsCallback getCallback() {
        return mCallback;
    }

    public Converter getConverter() {
        return mConverter;
    }

    /**
     * 返回当前的请求方法
     * GET,POST,HEAD,PUT,DELETE,OPTIONS
     */
    public String getMethod() {
        return mRequest.method();
    }

    /** 根据不同的请求方式和参数，生成不同的RequestBody */
    public abstract RequestBody generateRequestBody();

    /** 对请求body进行包装，用于回调上传进度 */
    public RequestBody wrapRequestBody(RequestBody requestBody) {
        ProgressRequestBody progressRequestBody = new ProgressRequestBody(requestBody);
        progressRequestBody.setListener(new ProgressRequestBody.Listener() {
            @Override
            public void onRequestProgress(final long bytesWritten, final long contentLength, final long networkSpeed) {
                OkGo.getInstance().getDelivery().post(new Runnable() {
                    @Override
                    public void run() {
                        if (mCallback != null) mCallback.upProgress(bytesWritten, contentLength, bytesWritten * 1.0f / contentLength, networkSpeed);
                    }
                });
            }
        });
        return progressRequestBody;
    }

    /** 根据不同的请求方式，将RequestBody转换成Request对象 */
    public abstract Request generateRequest(RequestBody requestBody);

    /** 根据当前的请求参数，生成对应的 Call 任务 */
    public okhttp3.Call generateCall(Request request) {
        mRequest = request;
        if (readTimeOut <= 0 && writeTimeOut <= 0 && connectTimeout <= 0 && sslParams == null && userCookies.size() == 0) {
            return OkGo.getInstance().getOkHttpClient().newCall(request);
        } else {
            OkHttpClient.Builder newClientBuilder = OkGo.getInstance().getOkHttpClient().newBuilder();
            if (readTimeOut > 0) newClientBuilder.readTimeout(readTimeOut, TimeUnit.MILLISECONDS);
            if (writeTimeOut > 0) newClientBuilder.writeTimeout(writeTimeOut, TimeUnit.MILLISECONDS);
            if (connectTimeout > 0) newClientBuilder.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS);
            if (hostnameVerifier != null) newClientBuilder.hostnameVerifier(hostnameVerifier);
            if (sslParams != null) newClientBuilder.sslSocketFactory(sslParams.sSLSocketFactory, sslParams.trustManager);
            if (userCookies.size() > 0) OkGo.getInstance().getCookieJar().addCookies(userCookies);
            if (interceptors.size() > 0) {
                for (Interceptor interceptor : interceptors) {
                    newClientBuilder.addInterceptor(interceptor);
                }
            }
            return newClientBuilder.build().newCall(request);
        }
    }

    /** 获取同步call对象 */
    public okhttp3.Call getCall() {
        //构建请求体，返回call对象
        RequestBody requestBody = generateRequestBody();
        mRequest = generateRequest(wrapRequestBody(requestBody));
        return generateCall(mRequest);
    }

    /** Rx支持,获取同步call对象 */
    public <T> Call<T> getCall(Converter<T> converter) {
        mConverter = converter;
        return DefaultCallAdapter.<T>create().adapt(new CacheCall<T>(this));
    }

    /** Rx支持,获取同步call对象 */
    public <T, E> E getCall(Converter<T> converter, CallAdapter<E> adapter) {
        mConverter = converter;
        return adapter.adapt(getCall(converter));
    }

    /** 普通调用，阻塞方法，同步请求执行 */
    public Response execute() throws IOException {
        return getCall().execute();
    }

    /** 非阻塞方法，异步请求，但是回调在子线程中执行 */
    @SuppressWarnings("unchecked")
    public <T> void execute(AbsCallback<T> callback) {
        mCallback = callback;
        mConverter = callback;
        new CacheCall<T>(this).execute(callback);
    }
}


HttpsUtils：    

public abstract class SSLSocketFactory extends SocketFactory {
    public SSLSocketFactory() {
        throw new RuntimeException("Stub!");
    }
	// 第一次调用此方法时，将检查安全属性 "ssl.SocketFactory.provider"。
	// 如果它不为 null，则加载并实例化使用该名称的类。
	// 如果成功并且该对象是 SSLSocketFactory 的实例，则它成为默认的 SSL 套接字工厂。
    public static synchronized SocketFactory getDefault() {
        throw new RuntimeException("Stub!");
    }
	
	// 返回默认情况下启用的密码套件的列表。
	// 除非启用了不同的列表，否则 SSL 连接上的联络将使用这些密码套件中的一个。
        // 这些默认值的最低服务质量是要求保护机密性和服务器验证（也就是说没有匿名的密码套件）。
    public abstract String[] getDefaultCipherSuites();
	
	// 返回可以在 SSL 连接上启用的密码套件的名称。
	// 通常，因为此列表可能包含不能满足这些默认值的服务质量要求的密码套件，所以默认情况下只能实际启用它们的子集。
	//这种密码套件在专门的应用程序中才能有用。
    public abstract String[] getSupportedCipherSuites();
	// 返回在连接到指定主机的给定端口的现有套接字上分层的套接字。
	// 通过代理使用 SSL 或者协商在已有的套接字上使用 SSL 时可以使用此构造方法。
	// 主机和端口号指的是逻辑同位体目标。使用为此工厂建立的套接字选项来配置此套接字。
    public abstract Socket createSocket(Socket var1, String var2, int var3, boolean var4) throws IOException;
}


 此接口的实例管理使用哪一个 X509 证书来验证远端的安全套接字。决定是根据信任的证书授权、证书撤消列表、在线状态检查或其他方式做出的。 

public interface X509TrustManager extends TrustManager {
 //  给出同位体提供的部分或完整的证书链，构建到可信任的根的证书路径，并且返回是否可以确认和信任将其用于基于验证类型的客户端 SSL 验证。
    void checkClientTrusted(X509Certificate[] var1, String var2) throws CertificateException;
  //  给出同位体提供的部分或完整的证书链，构建到可信任的根的证书路径，并且返回是否可以确认和信任将其用于基于验证类型的服务器 SSL 验证。
    void checkServerTrusted(X509Certificate[] var1, String var2) throws CertificateException;
  //  返回受验证同位体信任的认证中心的数组。
    X509Certificate[] getAcceptedIssuers();
}


/** Https相关的工具类 */
public class HttpsUtils {

    public static class SSLParams {
        public SSLSocketFactory sSLSocketFactory;
        public X509TrustManager trustManager;
    }

    public static SSLParams getSslSocketFactory(InputStream bksFile, String password, InputStream[] certificates) {
        SSLParams sslParams = new SSLParams();
        try {
            KeyManager[] keyManagers = prepareKeyManager(bksFile, password);
            TrustManager[] trustManagers = prepareTrustManager(certificates);
            SSLContext sslContext = SSLContext.getInstance("TLS");
            X509TrustManager trustManager;
            if (trustManagers != null) {
                trustManager = new MyTrustManager(chooseTrustManager(trustManagers));
            } else {
                trustManager = new UnSafeTrustManager();
            }
            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);
        }
    }

    private static TrustManager[] prepareTrustManager(InputStream... certificates) {
        if (certificates == null || certificates.length <= 0) return null;
        try {
            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null);
            int index = 0;
            for (InputStream certificate : certificates) {
                String certificateAlias = Integer.toString(index++);
                keyStore.setCertificateEntry(certificateAlias, certificateFactory.generateCertificate(certificate));
                try {
                    if (certificate != null) certificate.close();
                } catch (IOException e) {
                    OkLogger.e(e);
                }
            }
            TrustManagerFactory trustManagerFactory;
            trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keyStore);
            return trustManagerFactory.getTrustManagers();
        } catch (NoSuchAlgorithmException e) {
            OkLogger.e(e);
        } catch (CertificateException e) {
            OkLogger.e(e);
        } catch (KeyStoreException e) {
            OkLogger.e(e);
        } catch (Exception e) {
            OkLogger.e(e);
        }
        return null;
    }

    private static KeyManager[] prepareKeyManager(InputStream bksFile, String password) {
        try {
            if (bksFile == null || password == null) return null;
            KeyStore clientKeyStore = KeyStore.getInstance("BKS");
            clientKeyStore.load(bksFile, password.toCharArray());
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(clientKeyStore, password.toCharArray());
            return keyManagerFactory.getKeyManagers();
        } catch (KeyStoreException e) {
            OkLogger.e(e);
        } catch (NoSuchAlgorithmException e) {
            OkLogger.e(e);
        } catch (UnrecoverableKeyException e) {
            OkLogger.e(e);
        } catch (CertificateException e) {
            OkLogger.e(e);
        } catch (IOException e) {
            OkLogger.e(e);
        } catch (Exception e) {
            OkLogger.e(e);
        }
        return null;
    }

    private static X509TrustManager chooseTrustManager(TrustManager[] trustManagers) {
        for (TrustManager trustManager : trustManagers) {
            if (trustManager instanceof X509TrustManager) {
                return (X509TrustManager) trustManager;
            }
        }
        return null;
    }

    private 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[]{};
        }
    }

    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
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }
}



/**
 * ================================================
 * 作    者：jeasonlzy（廖子尧）Github地址：https://github.com/jeasonlzy0216
 * 版    本：1.0
 * 创建日期：16/8/9
 * 描    述：表示当前请求是否具有请求体
 * 修订历史：
 * ================================================
 */
public interface HasBody<R> {
    R requestBody(RequestBody requestBody);

    R params(String key, File file);

    R addFileParams(String key, List<File> files);

    R addFileWrapperParams(String key, List<HttpParams.FileWrapper> fileWrappers);

    R params(String key, File file, String fileName);

    R params(String key, File file, String fileName, MediaType contentType);

    R upString(String string);

    R upJson(String json);

    R upBytes(byte[] bs);
}




席方正
关注
专栏目录
android okgo 参数map,OkGo 网络请求框架介绍与使用说明
weixin_39818631的博客
05-26 1176
前言使用Android Studio 用户一般来说，只需要添加第一个 okgo 的核心包即可，其余的三个库根据自己的需要选择添加。//必须使用compile 'com.lzy.net:okgo:3.0.4'//以下三个选择添加，okrx和okrx2不能同时使用compile 'com.lzy.net:okrx:1.0.2'compile 'com.lzy.net:okrx2:2.0.2'compi...
网络请求框架——OkGo解读（二）——cookie
XiFangzheng的博客
10-31 3878
cookie持久化保存： public interface CookieStore { /** 保存url对应所有cookie */ void saveCookies(HttpUrl url, List cookie); /** 加载url所有的cookie */ List loadCookies(HttpUrl url); /** 获取当前所有
安卓项目实战之强大的网络请求框架okGo使用详解（五）：扩展项目okRx，完美结合RxJava
智玲君
11-02 2504
前言 在第一篇讲解okGo框架添加依赖支持时，还记得我们额外添加的两个依赖吗，一个okRx和一个okServer，这两个均是基于okGo框架的扩展项目，其中okRx可以使请求结合RxJava一起使用，而okServer则提供了强大的下载上传功能，如断点支持，多任务管理等，本篇我们主要讲解okRx的使用。 OkRx主要功能 1，可以很完美结合RxJava做网络请求 2，在使用上比Retrofit更简...
Android强大的网络请求框架----OkGo
你的外祖父的博客
07-30 1944
OkGo的主要功能： 基本的get、post、put、delete、head、options、trace、patch八种请求 支持upString，upJson，upBytes，upFile等up类方法上传特定数据 支持一个key上传一个文件，也可以一个key上传多个文件，也可以多文件和多参数一起上传 大文件下载和下载进度回调 大文件上传和上传进度回调 支持自定义超时自动重连次数 支持https访...
OKGO 同步数据请求 数据解析
u012922981的专栏
12-03 2082
Response resStr = OkGo.post(URI) .upJson(upJson) .execute(); NewLoginBean message = gson.fromJson(resStr.body().string(), new TypeToken<NewLogin...
使用okgo传递body(application/json)
qq_33339175的博客
06-05 8653
网络请求常见的有这么几种： 1.get无参/有参 2.post，然后表单模式，不停的put、put、put 3.post 上传文件 这些基本都是常见的，但是有个接口，如下图所示： 这是服务端给我的swagger，用上面这些假数据测试了一下之后，发现实际上userId和storeId是拼接在url里的，唯一一个麻烦的是body这个参数 以前服务端也给我弄过这种接口，用的是okhttp3生成re...
安卓项目实战之强大的网络请求框架okGo使用详解（一）：实现get，post基本网络请求，下载上传进度监听以及对Callback自定义的深入理解
智玲君
10-30 6303
1.添加依赖 //必须使用 compile 'com.lzy.net:okgo:3.0.4' //以下三个选择添加，okrx和okrx2不能同时使用，一般选择添加最新的rx2支持即可 compile 'com.lzy.net:okrx:1.0.2' compile 'com.lzy.net:okrx2:2.0.2' compile 'com.lzy.net:okserver:2.0.5' ...
网络请求框架——OkGo解读（一）——数据的缓存
XiFangzheng的博客
10-31 1万+
前言：       OkGo   ——    OkHttpUtils-2.0.0升级后改名 OkGo，全新完美支持RxJava。 该库是封装了okhttp的网络框架，可以与RxJava完美结合，比Retrofit更简单易用。支持大文件上传下载，上传进度回调，下载进度回调，表单上传（多文件和多参数一起上传），链式调用，可以自定义返回对象，支持Https和自签名证书，支持超时自动重连，支持
Android框架之路——OkGo的使用
热门推荐
等一杯咖啡的博客
05-10 5万+
一、简介 该库是封装了okhttp的标准RESTful风格的网络框架，可以与RxJava完美结合，比Retrofit更简单易用。支持大文件上传下载，上传进度回调，下载进度回调，表单上传（多文件和多参数一起上传），链式调用，可以自定义返回对象，支持Https和自签名证书，支持超时自动重连，支持cookie与session的自动管理，支持四种缓存模式缓存网络数据，支持301、302重定向，扩展了统一
android okhttp网络请求框架
08-08
**Android OkHttp 网络请求框架** OkHttp 是由 Square 公司开发的一个高效的网络请求库，广泛应用于 Android 开发中。它以其强大的性能、简单易用的 API 和丰富的特性，深受开发者喜爱。OkHttp 的核心设计理念是...
Android开发HTTP使用okgo请求数据的实现demo
08-13
Android开发HTTP使用okgo请求数据的实现demo，实现方法——引入依赖再进行自定义封装，封装了传参和解析返回的json数据，使用非常方便。
OKGo网络框架 开发 超简单方便 很详细
12-04
OKGo网络框架是一款在Android平台上广泛使用的开源网络库，它为开发者提供了简洁、高效且易于使用的网络请求解决方案。本文将深入探讨OKGo框架的核心特性、使用方法以及如何将其集成到你的Android项目中，帮助你实现...
安卓强大的网络请求框架okGo使用详解（一）
dlshtian的博客
02-02 1986
转载：https://blog.csdn.net/gpf1320253667/article/details/83515852
OkHttp的使用之{RequestBody、FormBody、MultipartBody}，2024年最新腾讯Android面经
最新发布
2401_84132723的博客
04-11 2575
我们可以使用HashMap这样的数据结构来存储接口所需参数的键值对，它的查找速度为O(1),很快，但是对于API接口参数来说，数据不会太多，查找快体现不出优势来，并且HashMap比较耗费内存。我搜集整理过这几年字节跳动，以及腾讯，阿里，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含。学习方向很容易规划，但是如果只通过碎片化的学习，对自己的提升是很慢的。//把参数传进Map中。
OKGO设置超时时间
findsafety的专栏
07-05 1402
项目使用了OKGO，有一个需求是需要某个接口设置不同的超时时间，一开始是这样改的 if(OkHttpUrlUtils.ORDER_SIGN_URL.equals(url)){ LogKit.d("该接口需要修改超时时间，修改了超时的参数为10S"); OkHttpClient okHttpClient = OkGo.getInstance().getOkHttpClient(); OkHttpClient lo...
OkHttpClient设置请求响应时长和请求重试次数
hkm的博客
04-06 9441
依赖jar包 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.6.0</version> </dependency> 代码 import okhttp3.Interceptor; import okhttp3.OkHttpClient; im
OkGoHttp让网络请求更简单
u012426327的专栏
11-30 8648
OkGo - OkHttpUtils-2.0.0升级后改名 OkGo,全新完美支持RxJava 项目地址：https://github.com/jeasonlzy，欢迎star，欢迎issue 该库是封装了okhttp的网络框架，可以与RxJava完美结合，比Retrofit更简单易用。支持大文件上传下载，上传进度回调，下载进度回调，表单上传（多文件和多参数一起上传），链式调用，可
OkGo添加公共参数
pzhu_lcx的博客
11-27 2616
静态公共参数不会更改的公共参数使用,比如设备信息之类的可以在Application初始化时使用 OkGo.getInstance().addCommonParams(params);添加进入，后续请求时都会携带上这些信息。 动态改变的参数我需要上传的是MultipartBody,多文件带参数的上传，一开始我想着使用OkHttp的拦截器来实现,但发现OkGo对Body使用ProgressReques
OKhttp设置UserAgent的那些事儿
vchao的博客
02-03 1万+
首先科普一下，UserAgent中文名为用户代理，简称 UA，它是一个*特殊字符串头，使得服务器能够识别客户使用的操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。 Okhttp走的并不是原生的http请求，因此它在header里面并没有真正的User-Agent，而是“okhttp/版本号”这样的字符串，因为后台需要统计信息，要求传入自定义的User
OkGo框架：深度解析网络请求与文件处理
资源摘要信息: "OkHttp-OkGo-master.zip 是一个开源的网络请求框架，其核心基于 OkHttp，集成了一些常见网络请求操作，如文件上传、下载以及图片缓存等功能。OkGo旨在简化网络请求的编码工作，提供流畅和高效的用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值