OKHttp&Retrofit

最新推荐文章于 2024-04-02 08:18:35 发布
最新推荐文章于 2024-04-02 08:18:35 发布
阅读量252 收藏
点赞数 1
分类专栏： Android 文章标签： java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43880692/article/details/119742146
版权
本文详细介绍了如何在Android中使用OKHttp进行HTTP请求，包括GET、POST同步和异步请求，文件上传，JSON请求，拦截器和缓存的使用。接着，文章讲解了Retrofit的基本使用，如创建接口、注解方式发送请求，并展示了如何添加转换器和使用RxJava进行响应订阅。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

OkHttp&Retrofit

OkHttp的使用

  1. 导入依赖

        implementation("com.squareup.okhttp3:okhttp:4.9.0")

  2. 使用

    1. Get

      1. 同步请求：注意在Android开发中同步请求会等待请求执行完毕，再往下走，同时，同步网络请求需要在子线程中使用，同步调用的execute方法。

        new Thread(()->{
            Request request = new Request.Builder().url("https://www.httpbin.org/get?key=1&value=2").build();
            //准备请求的Call对象
            Call call = mOkHttpClient.newCall(request);
            try {
                Response response = call.execute();
                Log.d(TAG, "getSync: response = "+response.body().string());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

      2. 异步请求，异步调用的是enqueue方法，同时这里要注意onResponse不一定是成功的需要判断状态码为200-300之间，这里用isSuccessful判断即可

        Request request = new Request.Builder().url("https://www.httpbin.org/get?key=1&value=2").build();
        //准备请求的Call对象
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {
            }
            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                if (response.isSuccessful()){
                    Log.d(TAG, "onResponse: success："+response.body().string());
                }
            }
        });

    2. Post

      1. 同步请求，Request.Builder默认是GET，这里需要调用Post，同时需要一个RequestBody参数，这里使用的是Form表单的格式

        new Thread(()->{
            FormBody formBody = new FormBody.Builder()
                    .add("key", "1")
                    .add("value", "2").build();
            Request request = new Request.Builder()
                    .url("https://www.httpbin.org/post")
                    .post(formBody)
                    .build();
            Call call = mOkHttpClient.newCall(request);
            try {
                Response response = call.execute();
                Log.d(TAG, "postSync: response = " + response.body().string());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

      2. 异步请求

        FormBody formBody = new FormBody.Builder()
                .add("key", "1")
                .add("value", "2").build();
        Request request = new Request.Builder()
                .url("https://www.httpbin.org/post")
                .post(formBody)
                .build();
        //准备请求的Call对象
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NonNull Call call, @NonNull IOException e) {

            }

            @Override
            public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                if (response.isSuccessful()){
                    Log.d(TAG, "onResponse: success："+response.body().string());
                }
            }
        });
    }

  3. OKHttp上传文件，MediaType.parse根据上传文件类型进行修改，TXT格式的类型就是text/plain

    public void uploadFile() throws IOException {
        OkHttpClient okHttpClient = new OkHttpClient();

        File file = new File(filePath);
        File file2 = new File(filePath);

        MultipartBody multipartBody = new MultipartBody.Builder()
                .addFormDataPart("file1", file.getName(), RequestBody.create(file, MediaType.parse("text/plain")))
                .addFormDataPart("file2", file2.getName(), RequestBody.create(file2, MediaType.parse("text/plain")))
                .build();
        Request request = new Request.Builder().url("https://www.httpbin.org/post")
                .post(multipartBody)
                .build();
        Call call = okHttpClient.newCall(request);
        Response response = call.execute();
        System.out.println(response.body().string());
    }

  4. 发送Json请求

    public void jsonTest() throws IOException {
        OkHttpClient okHttpClient = new OkHttpClient();
        RequestBody requestBody = RequestBody.create("{\"key\":1,\"value\":2}", MediaType.parse("application/json\n"));
        Request request = new Request.Builder().url("https://www.httpbin.org/post")
                .post(requestBody)
                .build();
        Call call = okHttpClient.newCall(request);
        Response response = call.execute();
        System.out.println(response.body().string());
    }

  5. 拦截器、缓存：创建OKHttpClient的时候采用构建者模式进行创建，.addInterceptor添加拦截器，在intercept方法中可以进行Request请求的处理，这里只是添加了请求头；.addNetWorkInterceptor同样也是拦截器不过它是在addInterceptor后执行；开启缓存，默认是关闭的，通过.cache开启new一个Cache传入要缓存进的文件地址以及缓存大小即可

    public void interceptorTest() throws IOException {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .cache(new Cache(new File("/path/cache"),1024*1024))
                .addInterceptor(new Interceptor() {
                    @NonNull
                    @Override
                    public Response intercept(@NonNull Chain chain) throws IOException {
                        Request request = chain.request().newBuilder()
                                .addHeader("os", "android")
                                .addHeader("version", "1.0")
                                .build();
                        Response response = chain.proceed(request);
                        return response;
                    }
                })
                .addNetworkInterceptor(new Interceptor() {
                    @NonNull
                    @Override
                    public Response intercept(@NonNull Chain chain) throws IOException {
                        System.out.println("version:" + chain.request().header("version"));
                        return chain.proceed(chain.request());
                    }
                }).build();

        Request request = new Request.Builder().url("https://www.httpbin.org/get?key=1&value=2").build();
        Call call = okHttpClient.newCall(request);
        Response response = call.execute();
        System.out.println(response.body().string());
    }

  6. Cookie：这里使用了wanAndroid中的开源请求方法，需要注册使用

    List<Cookie> cookies = new ArrayList<>();

    @Test
    public void cookieTest() throws IOException {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .cookieJar(new CookieJar() {
                    @Override
                    public void saveFromResponse(@NonNull HttpUrl httpUrl, @NonNull List<Cookie> list) {
                        cookies = list;
                    }

                    @NonNull
                    @Override
                    public List<Cookie> loadForRequest(@NonNull HttpUrl httpUrl) {
                        if (httpUrl.host().equals("www.wanandroid.com")){
                            return cookies;
                        }
                        return null;
                    }
                })
                .build();
        FormBody formBody = new FormBody.Builder().add("username", "")
                .add("password", "")
                .build();
        Request request = new Request.Builder().url("https://www.wanandroid.com/user/login")
                .post(formBody)
                .build();
        Call call = okHttpClient.newCall(request);
        Response response = call.execute();
        System.out.println(response.body().string());

        request = new Request.Builder().url("https://www.wanandroid.com/lg/collect/list/0/json")
                .build();
        call = okHttpClient.newCall(request);
        response = call.execute();
        System.out.println(response.body().string());
    }

Retrofit

入门使用

  1. 创建Http接口，注意这里如果是GET请求则参数的注解为Query；如果是POST请求，则根据请求类型进行参数注解的添加，这里的请求体类型为FromUrlEncoded，所以请求参数为Field；还有就是这里的方法名是可变的请求类型由方法上的注解决定：

    public interface HttpService {
    @GET("get")
    Call<ResponseBody> get(@Query("username") String username,
                           @Query("password") String password);

    @POST("post")
    @FormUrlEncoded
    Call<ResponseBody> post(@Field("username") String username,
                            @Field("password") String password);
}

  2. 创建Retrofit实例

    private Retrofit  mRetrofit = new Retrofit.Builder().baseUrl("https://www.httpbin.org/").build();

  3. 根据实例进行创建接口实例

    HttpService httpService = mRetrofit.create(HttpService.class);

  4. 然后就是调用方法生成Call对象

    retrofit2.Call<ResponseBody> post = httpService.post("Hello", "World");

  5. 最后就是进行请求

    post.enqueue(new retrofit2.Callback<ResponseBody>() {
            @Override
            public void onResponse(retrofit2.Call<ResponseBody> call, retrofit2.Response<ResponseBody> response) {
                if (response.isSuccessful()){
                    try {
                        Log.d(TAG, "onResponse: success："+response.body().string());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(retrofit2.Call<ResponseBody> call, Throwable t) {

            }
        });

Retrofit注解

  1. Path

    @POST("{id}")
    @FormUrlEncoded
    Call<ResponseBody> postPath(@Path("id")String path,
                                @Field("username") String username,
                                @Field("password") String password);

        Retrofit mRetrofit = new Retrofit.Builder().baseUrl("https://www.httpbin.org/").build();
    HttpService httpService = mRetrofit.create(HttpService.class);

    @Test
    public void postPathTest() throws IOException {
        Response<ResponseBody> post = httpService
                .postPath("post","11","22")
                .execute();
        System.out.println(post.body().string());
    }

  2. Headers

        @Headers({"os:android","version:1.0"})
    @POST("post")
    Call<ResponseBody> postHeaders();

        @Test
    public void postHeadersTest() throws IOException {
        Response<ResponseBody> post = httpService
                .postHeaders()
                .execute();
        System.out.println(post.body().string());
    }

  3. Url

        @POST
    Call<ResponseBody> postUrl(@Url String url);

        @Test
    public void postUrlTest() throws IOException {
        Response<ResponseBody> post = httpService
                .postUrl("https://www.httpbin.org/post")
                .execute();
        System.out.println(post.body().string());
    }

  4. QueryMap

        @GET("get")
    Call<ResponseBody> getMap(@QueryMap Map<String,String> map);

    public void getAsync(View view) {
        HttpService httpService = mRetrofit.create(HttpService.class);
        HashMap<String,String> hashMap = new HashMap<>();
        hashMap.put("username","1111");
        hashMap.put("password","2222");
        retrofit2.Call<ResponseBody> call = httpService.getMap(hashMap);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(retrofit2.Call<ResponseBody> call, retrofit2.Response<ResponseBody> response) {
                if (response.isSuccessful()){
                    try {
                        Log.d(TAG, "onResponse: success："+response.body().string());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFailure(retrofit2.Call<ResponseBody> call, Throwable t) {

            }
        });
    }

  5. Header

        @POST("{id}")
    @FormUrlEncoded
    Call<ResponseBody> postHeader(@Path("id")String path,
                                @Header("os")String os,
                                @Field("username") String username,
                                @Field("password") String password);

        @Test
    public void postHeaderTest() throws IOException {
        Response<ResponseBody> post = httpService
                .postHeader("post","android","11","22")
                .execute();
        System.out.println(post.body().string());
    }

Retrofit转换器

转化器就是对我们获取到responseBody进行转换，之前我们只能拿到String或者byte等类型，但我们使用转换器之后又就可以转换成我们需要使用的JavaBean等；这里我推荐一个在线Json转JavaBean的工具网站：https://www.bejson.com/json2javapojo/new/

Retrofit mRetrofit = new Retrofit.Builder().baseUrl("https://www.wanandroid.com/").build();
    WanAndroidService mWanAndroidService = mRetrofit.create(WanAndroidService.class);

  1. 引入依赖

    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

    这里我们也可以引入Gson的依赖来进行转换，但使用起来并没有Retrofit的converter-gson好用

  2. 使用

    1. 使用Gson

          @POST("user/login")
    @FormUrlEncoded
    Call<ResponseBody> postLogin(@Field("username")String username, @Field("password") String password);

      注意，这里的Call里面的泛型为ResponseBody

      @Test
    public void postLoginTest() throws IOException {
        Response<ResponseBody> post = mWanAndroidService
                .postLogin("", "")
                .execute();
        Gson gson = new Gson();
        if (post.body() != null) {
            BaseResponse baseResponse = gson.fromJson(post.body().string(), BaseResponse.class);
            System.out.println(baseResponse);
        } else {
            System.out.println("Post body is null");
        }
    }

    2. 使用converter-gson

          @POST("user/login")
    @FormUrlEncoded
    Call<BaseResponse> loginConverter(@Field("username")String username, @Field("password") String password);

      这里我们使用的泛型为实体类

          @Test
    public void postLoginConverterTest() throws IOException {
        Retrofit converterRetrofit = new Retrofit.Builder()
                .baseUrl("https://www.wanandroid.com/")
                .addConverterFactory(GsonConverterFactory.create()) //添加转换器
                .build();
        WanAndroidService wanAndroidService = converterRetrofit.create(WanAndroidService.class);
        Response<BaseResponse> post = wanAndroidService
                .loginConverter("", "")
                .execute();
        BaseResponse baseResponse = post.body();
        System.out.println(baseResponse);
    }

使用RxJava3转换器

  1. 引入依赖

    implementation 'com.squareup.retrofit2:adapter-rxjava3:latest.version'

    如果我们引入上面的3.0及以后的版本我们是无法使用转换器的，我们可以使用下面的，通常我们也会引入RxAndroid使用

        implementation 'com.squareup.retrofit2:adapter-rxjava3:2.9.0'
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'

  2. 使用

        @POST("user/login")
    @FormUrlEncoded
    Flowable<BaseResponse> getLogin(@Field("username")String username, @Field("password") String password);
    @GET("lg/collect/list/{pageNum}/json")
    Flowable<ResponseBody> getArticle(@Path("pageNum")int pageNum);

    这里我们通过登录然后再进行获取收藏列表

    //Android主线程：AndroidSchedulers.mainThread();
    //单元测试中无法使用Android主线程
    List<Cookie> cookies = new ArrayList<>();

    @Test
    public void postLoginRxJavaTest() throws IOException {
        //这里如果需要使用Cookie来获取登录结果，但Cookie需要OKHttpClient对象，这里可以使用
        //CallFactory来进行创建

        Retrofit rxJavaRetrofit = new Retrofit.Builder()
                .baseUrl("https://www.wanandroid.com/")
                .callFactory(new OkHttpClient
                        .Builder()
                        .cookieJar(new CookieJar() {
                            @Override
                            public void saveFromResponse(@NonNull HttpUrl httpUrl, @NonNull List<Cookie> list) {
                                cookies = list;
                            }

                            @NonNull
                            @Override
                            public List<Cookie> loadForRequest(@NonNull HttpUrl httpUrl) {
                                if (httpUrl.host().equals("www.wanandroid.com")){
                                    return cookies;
                                }
                                return null;
                            }
                        }).build())
                .addConverterFactory(GsonConverterFactory.create()) //添加转换器
                .addCallAdapterFactory(RxJava3CallAdapterFactory.create()) //添加Rxjava3的适配器
                .build();
        WanAndroidService wanAndroidService = rxJavaRetrofit.create(WanAndroidService.class);
        wanAndroidService
                .getLogin("", "")
                .flatMap(new Function<BaseResponse, Publisher<ResponseBody>>() {
                    //flatMap：根据apply的结果生成一个新的Publisher
                    @Override
                    public Publisher<ResponseBody> apply(BaseResponse baseResponse) throws Throwable {
                        //return null;
                        return wanAndroidService.getArticle(0);
                    }
                })
                .observeOn(Schedulers.io())
                .subscribeOn(Schedulers.newThread()) //这里我们可以切换Android主线程进行下面的UI操作，但在单元测试中我们无法使用所以就创建一个新线程了
                .subscribe(new Consumer<ResponseBody>() {
                    @Override
                    public void accept(ResponseBody responseBody) throws Throwable {
                        //如果实在Android中，此处可以进行UI操作
                        System.out.println(responseBody.string());
                    }
                });
        //这里使用阻塞来获取返回值，否则就直接结束了
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

Rxtrofit文件上传下载

上代码：

    @POST("post")
    @Multipart
    Call<ResponseBody> uploadFile(@Part MultipartBody.Part file);

    //如果文件过大则可以加@Streaming注解，可以有效避免出现内存溢出的问题
    @Streaming
    @GET
    Flowable<ResponseBody> downloadFile(@Url String url);

上传：

	@Test
    public void uploadFileWithRetrofit() throws IOException {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://www.httpbin.org")
                .build();
        HttpService httpService = retrofit.create(HttpService.class);
        File file = new File("");
        MultipartBody.Part part = MultipartBody.Part
                .createFormData("file",
                        file.getName(),
                        RequestBody.create(file, MediaType.parse("text/plain")));
        retrofit2.Call<ResponseBody> uploadFile = httpService.uploadFile(part);
        System.out.println(uploadFile.execute().body().string());
    }

下载：

   @Test
    public void downloadFile() throws InterruptedException {
        Retrofit retrofit = new Retrofit.Builder()
                .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
                .baseUrl("https://www.httpbin.org")
                .build();
        HttpService httpService = retrofit.create(HttpService.class);
        httpService
                .downloadFile("url地址")
        .map(new Function<ResponseBody, File>() {
            @Override
            public File apply(ResponseBody responseBody) throws Throwable {
                File file = new File("");
                InputStream inputStream = responseBody.byteStream();
                FileOutputStream outputStream = new FileOutputStream(file);
                int length;
                byte[] buffer = new byte[1024];
                while ((length = inputStream.read(buffer)) != -1){
                    outputStream.write(buffer,0,length);
                }
                outputStream.close();
                inputStream.close();
                return file;
            }
        }).observeOn(Schedulers.io())
        .subscribeOn(Schedulers.newThread())
        .subscribe(new Consumer<File>() {
            @Override
            public void accept(File file) throws Throwable {
                //do something...
            }
        });
        Thread.sleep(1000);
    }
OkHttp和Retrofit
android_ErChen的开发之路
03-26 1717
介绍 OkHttp OkHttp是由Square公司提供的处理网络请求的开源库，有以下特性： 支持Http2.0,对一台机器的所有请求共享同一个socket 内置连接池，支持连接复用，减少延迟 Interceptors（拦截器）轻松处理请求与响应，支持透明的GZIP压缩响应体 请求失败时自动重连 拥有队列线程池，轻松写并发 基于Headers的缓存策略 Retrofit Retr...
Android OkHttp+Retrofit+RxJava搭建网络访问框架（含源码）
最新发布
2401_87029380的博客
09-06 1105
week = “昨天”;week = “今天”;week = “明天”;} else {case 1:week = “星期日”;break;case 2:week = “星期一”;break;case 3:week = “星期二”;break;case 4:week = “星期三”;break;case 5:week = “星期四”;break;case 6:week = “星期五”;break;case 7:week = “星期六”;
Okhttp 与 Retrofit的简单介绍及两者间的联系
紫雾凌寒
03-25 8606
前言 Android为我们提供了两种HTTP交互的方式：HttpURLConnection和Apache HTTP Client（ Android 6.0——API 23已经不支持该方式了 ），虽然两者都支持HTTPS，流的上传和下载，配置超时IPv6和连接池，已足够满足我们各种HTTP请求的需求。但更高效的使用HTTP可以让我们的应用运行更快、更节省流量。这就诞生了Okhttp及Ret...
OKhttp+Retrofit
dreamflylb的博客
12-21 416
public interface SubService { //http://120.27.23.105/product/getProductDetail @GET("product/getProductDetail") Observable text(@Query("pid") int pid); } public class App exte
Okhttp和Retrofit介绍
qq_53077129的博客
02-25 1550
android常用网络加载库Okhttp介绍
一篇文章带你走通 OkHttp+Retrofit+Rxjava
Daker's Blog
02-18 1万+
一篇文章带你走通 OkHttp+Retrofit+Rxjava@(Android)[android]一篇文章带你走通 OkHttpRetrofitRxjava 参考网站 OkHttp部分 OkHttp依赖 Okio依赖 使用OkHttp下载图片例子 Retrofit部分 Retrofit依赖 Gson依赖 返回数据转换器依赖 例子所有依赖 请求String数据例子 请求Json数据例子 使用 Res
GankMM:（Material Design & MVP & Retrofit + OKHttp & RecyclerView ...）Gank.io Android客户端：每天一张美女图片，一个视频短片，若干Android，iOS等程序干货，周一到周五每天更新，数据全部由 干货集中营 提供
04-13
(Material Design & MVP & Retrofit2 + OKHttp & RecyclerView ...) 知识点： 1.Retrofit2和OKHttp的使用； 2.MVP模式的基本使用； 3.RecycleView控件的使用； 4.状态的的颜色的设置（Android 4.4 +）； 5.Android ...
Android-okhttp-json-mock帮助你为Okhttp和Retrofit模拟json格式的数据
08-12
在Android应用开发中，OkHttp和Retrofit是两个非常重要的组件。OkHttp作为一个高效的网络库，负责处理HTTP请求和响应，而Retrofit则是一个接口层的抽象，使得开发者可以通过简单的Java接口来调用网络API。然而，在...
Okhttp、Retrofit进度获取的方法(一行代码搞定)
08-27
Okhttp、Retrofit进度获取的方法 Okhttp和Retrofit是Android开发中常用的网络库，它们都依赖于Okio库来实现数据的读写操作。Okio是一个实现了java.io和java.nio的类库，用于连接、存储和处理数据。Okhttp可以添加...
OKHttp+Retrofit的使用
N_Y_S的博客
08-12 1461
Retrofit+OKHttp的使用
okhttp+retrofit+rxjava（含服务器）
04-12
本资源主要是基于Android平台，一个关于okhttp + retrofit + rxjava网络请求框架的Demo，Android是9.0，服务器采用websocket，jdk1.8，Tomcat 9.0进行简单数据通信。
Okhttp+Retrofit封装
Mrzhaoplus的博客
01-09 489
单例模式加上封装调取的方法 public static OkHttpClient okHttpClient; public static SerViceAPI serViceAPI; /** * 优先执行 */ static { getOkHttpClient(); } public static OkHttpC
OkHttp学习系列之Retrofit
柚子君的博客
03-25 293
Retrofit严格意义上不是OkHttp的，但是这两个东西联系太紧密了，在Android开发商，经常会把Retrofit和OkHttp混到一起用，很方便！！ 所以不得不讲一下Retrofit 注意下，这篇文章是讲原理的，不是讲用法的，想学习Retrofit怎么用，不要看这篇文章，纯属浪费时间 深入到Retrofit的源码中可以看到，Retrofit的设计是非常精巧的，他利用了动态代理和注解技术，用几个类搭建了一个可扩展性非常好的框架，实在是我辈的楷模。 Retrofit的逻辑分成以下三个部分 创建代理对
OkHttp与Retrofit的作用和联系
白手黑书
12-30 2299
一、OkHttp 1、OkHttp的介绍 OkHttp是一个关于网络请求的第三方类库，其中封装了网络请求的get、post等操作的底层实现，是Android端目前最为火热的网络请求框架之一。 2、OkHttp的使用 在Android Studio中不需要下载专门的jar包，直接在gradle中添加依赖，如下所示： compile 'com.squareup.okhttp3:okhttp...
OKHttp+Retrofit+RxJava
天王盖地虎
03-24 340
implementation 'com.squareup.okhttp3:okhttp:3.1.2' implementation 'com.facebook.fresco:fresco:0.12.0' implementation 'com.squareup.retrofit2:converter-gson:2.1.0' implementation 'com.squareu...
『Android基础入门』网络编程之OKHTTP与Retrofit框架
2401_84003839的博客
04-02 1613
添加网络请求权限添加依赖3.2 框架使用。
Android开发—OkHttp&Retrofit
罗密欧与猪过夜的博客
06-26 2952
Android开发—OkHttp & Retrofit
Carson带你学Android：主流开源网络请求库对比(Volley、OkHttp、Retrofit)
热门推荐
Carson带你学Android
08-10 1万+
前言 网络请求在 Android 开发中非常常见，为了降低开发周期和难度，我们经常会选用网络请求的开源库 而现在网络请求的开源库越来越多，我们应该选用哪种呢？ 今天我就给大家分别介绍 &amp; 对比现今主流的网络请求库。 目录 1. 为什么要用网络请求开源库？ 网络请求开源库是一个将 网络请求的相关功能封装好的类库 没有网络请求框架之前 App想与服务器进行...
OkHttp和Retrofit的区别
qq_44782714的博客
04-27 2699
OkHttp和Retrofit请求方式区别 首先Ok分为同步和异步的网络请求 同步请求步骤： 创建okhttpclient对象 创建request对象，或者是response对象 通过call对象来操作请求 （call是一个接口，所以要实现他的callback对象 callback有3个特点： 1， 只能用一次 如果再次使用就要抛出异常 2， 将同步请求放入到请求队列中 3， Okhttp通过拦...
深入解析：Volley、OkHttp与Retrofit网络请求实践
从上述代码中我们可以看到，无论是 Volley、OkHttp 还是 Retrofit，它们都提供了丰富的网络请求功能，并且各自的 API 设计都尽可能简化了开发者的使用难度。在实际项目中，可以根据具体需求和场景选择最适合的网络...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

立花泷える宫水三叶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值