retrofit2联网框架封装使用

最新推荐文章于 2024-01-03 16:16:44 发布
最新推荐文章于 2024-01-03 16:16:44 发布
阅读量462 收藏
点赞数
分类专栏： Android笔记 文章标签： Retrofit2 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lumingzhang/article/details/89636604
版权

1.依赖添加：

implementation 'com.squareup.retrofit2:retrofit:2.4.0'

2.Retrofit请求类

package com.example.zb.retrofit2demo.retrofit;

/**
 * Created by zb on 2019/4/19.
 */

import android.content.Context;
import android.widget.Toast;

import com.example.zb.retrofit2demo.R;
import com.example.zb.retrofit2demo.bean.BaseResult;
import com.example.zb.retrofit2demo.interfice.FileRequest;
import com.example.zb.retrofit2demo.interfice.GetRequest;
import com.example.zb.retrofit2demo.interfice.PostRequest;
import com.example.zb.retrofit2demo.utils.Constant;
import com.example.zb.retrofit2demo.utils.NetworkUtil;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import java.io.File;
import java.io.IOException;
import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.security.cert.CertificateException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.X509TrustManager;

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;

/**
 * Retrofit请求类
 */
public class RetrofitRequest {

    private static int TIME_OUT = 30; // 30秒超时断开连接

    // 自定义一个信任所有证书的TrustManager，添加SSLSocketFactory的时候要用到
    private static X509TrustManager trustAllCert = new X509TrustManager() {
        @Override
        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
        }

        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return new java.security.cert.X509Certificate[]{};
        }
    };
    private static SSLSocketFactory sslSocketFactory = new SSLSocketFactoryCompat(trustAllCert);

    // httpclient
    public static OkHttpClient client = new OkHttpClient.Builder()
            .sslSocketFactory(sslSocketFactory, trustAllCert)
            .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
            .readTimeout(TIME_OUT, TimeUnit.SECONDS)
            .writeTimeout(TIME_OUT, TimeUnit.SECONDS)
            .build();
    /**
     * 网络框架单例
     * <p>因为示例中用到不同的接口地址，URL_BASE随便写了一个，如果是实际项目中，则设置为根路径即可</p>
     */
    private static Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(Constant.URL_BASE)
            .client(client)
            .build();

    /**
     * 发送GET网络请求
     * @param url 请求地址
     * @param clazz 返回的数据类型
     * @param resultHandler 回调
     * @param <T> 泛型
     */
    public static <T extends BaseResult> void sendGetRequest(String url, final Class<T> clazz, final ResultHandler<T> resultHandler) {
        // 判断网络连接状况
        if (resultHandler.isNetDisconnected()) {
            resultHandler.onAfterFailure();
            return;
        }

        GetRequest getRequest = retrofit.create(GetRequest.class);

        // 构建请求
        Call<ResponseBody> call = getRequest.getUrl(url);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                resultHandler.onBeforeResult();
                try {
                    ResponseBody body = response.body();
                    if (body == null) {
                        resultHandler.onServerError();
                        return;
                    }
                    String string = body.string();
                    T t = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create().fromJson(string, clazz);

                    resultHandler.onResult(t);
                } catch (IOException e) {
                    e.printStackTrace();
                    resultHandler.onFailure(e);
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                resultHandler.onFailure(t);
                resultHandler.onAfterFailure();
            }
        });
    }

    /**
     * 发送post网络请求
     * @param url 请求地址
     * @param paramMap 参数列表
     * @param clazz 返回的数据类型
     * @param resultHandler 回调
     * @param <T> 泛型
     */
    public static <T extends BaseResult> void sendPostRequest(String url, Map<String, String> paramMap, final Class<T> clazz, final ResultHandler<T> resultHandler) {
        // 判断网络连接状况
        if (resultHandler.isNetDisconnected()) {
            resultHandler.onAfterFailure();
            return;
        }
        PostRequest postRequest = retrofit.create(PostRequest.class);

        // 构建请求
        Call<ResponseBody> call = postRequest.postMap(url, paramMap);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                resultHandler.onBeforeResult();
                try {
                    ResponseBody body = response.body();
                    if (body == null) {
                        resultHandler.onServerError();
                        return;
                    }
                    String string = body.string();
                    T t = new Gson().fromJson(string, clazz);

                    resultHandler.onResult(t);
                } catch (IOException e) {
                    e.printStackTrace();
                    resultHandler.onFailure(e);
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                resultHandler.onFailure(t);
                resultHandler.onAfterFailure();
            }
        });
    }

    /**
     * 发送上传文件网络请求
     * @param url 请求地址
     * @param file 文件
     * @param clazz 返回的数据类型
     * @param resultHandler 回调
     * @param <T> 泛型
     */
    public static <T extends BaseResult> void fileUpload(String url, File file, final Class<T> clazz, final ResultHandler<T> resultHandler) {
        // 判断网络连接状况
        if (resultHandler.isNetDisconnected()) {
            resultHandler.onAfterFailure();
            return;
        }
        FileRequest fileRequest = retrofit.create(FileRequest.class);

        Map<String, RequestBody> paramMap = new HashMap<>();
        addMultiPart(paramMap, "file", file);

        // 构建请求
        Call<ResponseBody> call = fileRequest.postFile(url, paramMap);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                resultHandler.onBeforeResult();
                try {
                    ResponseBody body = response.body();
                    if (body == null) {
                        resultHandler.onServerError();
                        return;
                    }
                    String string = body.string();
                    T t = new Gson().fromJson(string, clazz);

                    resultHandler.onResult(t);
                } catch (IOException e) {
                    e.printStackTrace();
                    resultHandler.onFailure(e);
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                resultHandler.onFailure(t);
                resultHandler.onAfterFailure();
            }
        });
    }

    /**
     * 文件下载
     * @param url 请求地址
     * @param downloadHandler 回调接口
     */
    public static void fileDownload(String url, final DownloadHandler downloadHandler) {
        // 回调方法执行器，定义回调在子线程中执行，避免Callback返回到MainThread，导致文件下载出现NetworkOnMainThreadException
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        // 网络框架
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(Constant.URL_BASE)
                .callbackExecutor(executorService)
                .build();

        FileRequest fileRequest = retrofit.create(FileRequest.class);
        // 构建请求
        Call<ResponseBody> call = fileRequest.download(url);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.isSuccessful()) {
                    // 写入文件
                    downloadHandler.onBody(response.body());
                } else {
                    downloadHandler.onError();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
                downloadHandler.onError();
            }
        });
    }

    /**
     * 添加多媒体类型
     *
     * @param paramMap 参数对
     * @param key      键
     * @param obj      值
     */
    private static void addMultiPart(Map<String, RequestBody> paramMap, String key, Object obj) {
        if (obj instanceof String) {
            RequestBody body = RequestBody.create(MediaType.parse("text/plain;charset=UTF-8"), (String) obj);
            paramMap.put(key, body);
        } else if (obj instanceof File) {
            RequestBody body = RequestBody.create(MediaType.parse("multipart/form-data;charset=UTF-8"), (File) obj);
            paramMap.put(key + "\"; filename=\"" + ((File) obj).getName() + "", body);
        }
    }

    /**
     * 网络请求结果处理类
     * @param <T> 请求结果封装对象
     */
    public static abstract class ResultHandler<T> {
        Context context;

        public ResultHandler(Context context) {
            this.context = context;
        }

        /**
         * 判断网络是否未连接
         *
         * @return
         */
        public boolean isNetDisconnected() {
            return NetworkUtil.isNetDisconnected(context);
        }

        /**
         * 请求成功之前
         */
        public abstract void onBeforeResult();

        /**
         * 请求成功时
         *
         * @param t 结果数据
         */
        public abstract void onResult(T t);

        /**
         * 服务器出错
         */
        public void onServerError() {
            // 服务器处理出错
            Toast.makeText(context, R.string.net_server_error, Toast.LENGTH_SHORT).show();
        }

        /**
         * 请求失败后的处理
         */
        public abstract void onAfterFailure();

        /**
         * 请求失败时的处理
         *
         * @param t
         */
        public void onFailure(Throwable t) {
            if (t instanceof SocketTimeoutException || t instanceof ConnectException) {
                // 连接异常
                if (NetworkUtil.isNetworkConnected(context)) {
                    // 服务器连接出错
                    Toast.makeText(context, R.string.net_server_connected_error, Toast.LENGTH_SHORT).show();
                } else {
                    // 手机网络不通
                    Toast.makeText(context, R.string.net_not_connected, Toast.LENGTH_SHORT).show();
                }
            } else if (t instanceof Exception) {
                // 功能异常
                Toast.makeText(context, R.string.net_unknown_error, Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 文件下载回调
     */
    public interface DownloadHandler {
        /**
         * 接收到数据体
         * @param body 响应体
         */
        public void onBody(ResponseBody body);

        /**
         * 文件下载出错
         */
        public void onError();
    }
}

3.Android4.4以下系统不支持TLS协议的适配

package com.example.zb.retrofit2demo.retrofit;

import android.os.Build;

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.GeneralSecurityException;
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.SSLSocketFactory;
import javax.net.ssl.X509TrustManager;

/**
 * Android4.4以下系统不支持TLS协议的适配
 */

public class SSLSocketFactoryCompat extends SSLSocketFactory {
    private SSLSocketFactory defaultFactory;
    // 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
    static String protocols[] = null, cipherSuites[] = null;

    static {
        try {
            SSLSocket socket = (SSLSocket) SSLSocketFactory.getDefault().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);
                SSLSocketFactoryCompat.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())));
                    SSLSocketFactoryCompat.cipherSuites = enabledCiphers.toArray(new String[enabledCiphers.size()]);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public SSLSocketFactoryCompat(X509TrustManager tm) {
        try {
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, (tm != null) ? new X509TrustManager[]{tm} : null, null);
            defaultFactory = sslContext.getSocketFactory();
        } catch (GeneralSecurityException e) {
            throw new AssertionError(); // The system has no TLS. Just give up.
        }
    }

    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);
        }
    }

    @Override
    public String[] getDefaultCipherSuites() {
        return cipherSuites;
    }

    @Override
    public String[] getSupportedCipherSuites() {
        return cipherSuites;
    }

    @Override
    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
        Socket ssl = defaultFactory.createSocket(s, host, port, autoClose);
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket) ssl);
        return ssl;
    }

    @Override
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        Socket ssl = defaultFactory.createSocket(host, port);
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket) ssl);
        return ssl;
    }

    @Override
    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
        Socket ssl = defaultFactory.createSocket(host, port, localHost, localPort);
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket) ssl);
        return ssl;
    }

    @Override
    public Socket createSocket(InetAddress host, int port) throws IOException {
        Socket ssl = defaultFactory.createSocket(host, port);
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket) ssl);
        return ssl;
    }

    @Override
    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
        Socket ssl = defaultFactory.createSocket(address, port, localAddress, localPort);
        if (ssl instanceof SSLSocket)
            upgradeTLS((SSLSocket) ssl);
        return ssl;
    }
}

3.文件上传请求封装

package com.example.zb.retrofit2demo.interfice;

import java.util.Map;

import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.PartMap;
import retrofit2.http.Streaming;
import retrofit2.http.Url;

/**
 * 文件上传请求封装
 */

public interface FileRequest{
    /**
     * 上传文件请求
     * @param url      URL路径
     * @param paramMap 请求参数
     * @return
     */
    @Multipart
    @POST
    Call<ResponseBody> postFile(@Url String url, @PartMap Map<String, RequestBody> paramMap);
    /**
     * 下载文件get请求
     * @param url 链接地址
     * @return
     */
    @Streaming
    @GET
    Call<ResponseBody> download(@Url String url);
}

4.get请求封装

package com.example.zb.retrofit2demo.interfice;

import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Url;

/**
 * get请求封装
 */

public interface GetRequest {
    /**
     * 发送Get请求请求
     * @param url URL路径
     * @return
     */
    @GET
    Call<ResponseBody> getUrl(@Url String url);
}

5.Post请求封装

package com.example.zb.retrofit2demo.interfice;

import java.util.Map;

import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.POST;
import retrofit2.http.Url;

/**
 * Post请求封装
 */

public interface PostRequest {
    /**
     * 发送Post请求
     * @param url URL路径
     * @param requestMap 请求参数
     * @return
     */
    @FormUrlEncoded
    @POST
    Call<ResponseBody> postMap(@Url String url, @FieldMap Map<String, String> requestMap);

}

6.get调用代码处理

private void onGet() {
    // 这里放显示loading
    String url = Constant.URL_WEATHER;
    url += "?city=北京";
    RetrofitRequest.sendGetRequest(url, WeatherResult2.class, new RetrofitRequest.ResultHandler<WeatherResult2>(this) {
        @Override
        public void onBeforeResult() {
            // 这里可以放关闭loading
        }
        @Override
        public void onResult(WeatherResult2 weatherResult2) {
            String s = new Gson().toJson(weatherResult2);
            MyLog.i("get------", s);
        }

        @Override
        public void onAfterFailure() {
            // 这里可以放关闭loading
        }
    });
}

7.post调用代码处理

private void onPost() {
    // 这里放显示loading
    progressDialog.show();
    String url = Constant.URL_BASE1;
    Map<String, String> paramMap = new HashMap<>(1);
    paramMap.put("code", "admin");
    paramMap.put("password", "123456");
    RetrofitRequest.sendPostRequest(url, paramMap, WeatherResult.class, new RetrofitRequest.ResultHandler<WeatherResult>(this) {
        @Override
        public void onBeforeResult() {
            // 这里可以放关闭loading
            progressDialog.dismiss();
        }
        @Override
        public void onResult(WeatherResult weatherResult) {
            progressDialog.dismiss();
            String weather = new Gson().toJson(weatherResult);
            MyLog.i("retrofit------", weather);
            MyLog.i("errMsg------", weatherResult.getErrMsg());
            MyLog.i("Name------", weatherResult.getResult().getName());
            MyLog.i("password------", weatherResult.getResult().getPassword());
        }

        @Override
        public void onAfterFailure() {
            // 这里可以放关闭loading
            progressDialog.dismiss();
        }
    });

}

github地址：https://github.com/b888zhang/Retrofit2Demo

 

 

一直在路过
关注
专栏目录
Android面试必备知识：Android络访问框架对比（特点、使用高级技巧、使用场景）
大模型大数据攻城狮的专栏
09-28 461
该框架支持多种网络请求方式，如GET、POST等，以及数据解析方式，如JSON、XML等，这种灵活性使得开发者能够根据不同场景选择合适的请求和数据处理方式，提高了开发的效率和应用的适应性。Retrofit，作为一个类型安全的HTTP客户端，专为Android和Java设计，其核心思想在于通过注解的方式定义接口，以此将HTTP请求与Java接口方法紧密绑定，实现网络请求的自动化处理。例如，在需要频繁进行网络通信的社交应用中，OkHttp能够通过其高效的连接池和缓存机制，为用户提供流畅的数据加载体验。
网络请求框架——OkGo解读（一）——数据的缓存
XiFangzheng的博客
10-31 1万+
前言：       OkGo   ——    OkHttpUtils-2.0.0升级后改名 OkGo，全新完美支持RxJava。 该库是封装了okhttp的网络框架，可以与RxJava完美结合，比Retrofit更简单易用。支持大文件上传下载，上传进度回调，下载进度回调，表单上传（多文件和多参数一起上传），链式调用，可以自定义返回对象，支持Https和自签名证书，支持超时自动重连，支持
Android网络框架Retrofit2使用封装：Get/Post/文件上传/下载
10-16
为了方便Android开发，特封装了一些关于Retrofit2的代码，分享给大家。框架主要包括：Get请求、Post请求、文件上传、文件下载。效果图及讲解见：https://blog.csdn.net/ahuyangdong/article/details/82760382。github源码：https://github.com/ahuyangdong/RetrofitFrame
使用Retrofit2封装适用于组件化项目的网络库
热门推荐
不学习傻了吧
07-05 1万+
Android组件化项目HttpClient的封装过程这篇文章主要讲解Android组件化项目中的网络请求工具类HttpClient的封装过程，首先简单介绍了Url和Http请求的概念，接下来讲解了Retrofit的使用方法，最后是HttpClient的封装思想和封装过程。
Retrofit2框架封装（源码+java）
最新发布
唐诺
01-03 747
【代码】Retrofit2框架封装（源码+java）
RxJava2+Retrofit2优雅简洁封装
weixin_30872789的博客
03-14 231
RxJava2 封装主要变化 Transformer的变化:RxJava1.X为rx.Observable.Transformer接口, 继承自Func1<Observable, Observable>, RxJava2.X为io.reactivex.ObservableTransformer<Upstream, Downstream>,是一个独立的接口。 Flowabl...
好用的retrofit2请求封装类
幽默UY的博客
01-14 529
package com.nbniu.app.common.tool; import android.content.Context; import retrofit2.Call; import retrofit2.Callback; import retrofit2.Response; /** * 请求回调封装 */ public abstract class Request&amp;amp;amp;amp;lt;T&amp;amp;amp;amp;...
Retrofit2和Rxjava2和LiveData的请求整理
u011652925的博客
07-10 1087
Retrofit2返回 LiveData + ViewModel替代Rxjava2，但缺少一些Rxjava2没有的功能，如Stream，Rxjava2中缺少关于LiveData中 LiveData 算是一个数据持久类 Rxjava2 有链式响应请求的过程 组合方式 1、Retrofit 单独请求 2、Retrofit+RxJava实现网络请求，返回的是Observable 3、Retrofit+LiveData实现网络请求，返回的是LiveData 以上请求加上OkHttpClien...
Android-retrofit网络工具类
08-13
写在前面: Retrofit与okhttp共同出自于Square公司，是目前市场上使用最多的联网框架,retrofit是对okhttp做了一层封装,不过封装之后的retrofit上手还是极其复杂,为了解决使用难度问题,本文推荐使用github开源项目...
Android网络交互框架
06-19
2. 网络库与业务逻辑解耦：框架应封装底层的网络库（如OkHttp），隐藏其复杂的API，提供简单的接口供上层使用，避免了应用与具体网络库的强绑定。 3. 线程管理与网络交互解耦：网络请求通常在后台线程执行，防止...
retrofit2 极简封装
12-04
retrofit2 极简封装，极简接入。一个请求只需三步。 1.针对不同项目需求，支持三种不同的初始化。 2.高度定制请求主体 3.支持下载，显示进度 4.支持取消请求 5.支持loding
Android-retrofit2.0rxjava2网络封装框架
08-13
retrofit2.0 rxjava2 网络封装框架。支持请求取消 支持上传下载进度监听
Retrofit2+RxJava封装的网络框架
03-21
封装的网络框架，请看我的博文http://blog.csdn.net/sinat_30949835/article/details/79627080
Android实战——Retrofit2的使用和封装
11-08
Android实战——Retrofit2的使用和封装
Retrofit的二次封装
06-05
添加 以JSON形式上传参数，自定义使用的Retrofit的二次封装的module，可直接导入项目使用，包含有无token两种情况，以及支持后台证书校验等。部分代码需根据项目需要修改后使用
retrofit2封装
magic_lemolang的博客
06-18 395
1. retrofit2客户端封装 public class RetrofitClient { private String baseUrl; private long readTimeout = 10000; private long connectTimeout = 10000; public RetrofitClient(String baseUrl...
Retrofit网络框架封装
xujiajian119的博客
11-22 162
听到 Retrofit 大家伙应该都很熟悉吧 ， 近期研究了一下  其实很简单 ， 本人对他进行了 一个 简单的封装 。 网络权限不必多说了吧  &lt;uses-permission android:name="android.permission.INTERNET" /&gt; 首页  我们先来加入 Gradle中的配置 compile 'com.squareup.retrofit...
Retrofit2 的使用与封装
m0_48342140的博客
09-14 353
Retrofit2 的使用与封装 响应基类 public class BaseResponse { public String code; public String message; } 请求数据对象基类 public class BaseRequest { public String productGuid = BuildConfig.PRODUCT_GUID; public int version = 1; public int cl..
RxJava2与Retrofit2网络框架封装实践
"这篇文章主要探讨了如何将RxJava2与Retrofit2结合，实现网络框架的简洁封装。作者分享了自己的实践经验和封装思路，包括异常处理、兼容性问题、内存泄漏的预防以及添加异步请求时的加载提示。文章还提到了相关依赖...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值