Retrofit 基本使用教程

最新推荐文章于 2024-05-15 13:12:47 发布
置顶 最新推荐文章于 2024-05-15 13:12:47 发布
阅读量1w 收藏 13
点赞数 4
分类专栏： Android开源项目学习 文章标签： Retrofit 查询参数 异步请求 教程

原文地址：

https://futurestud.io/blog/retrofit-getting-started-and-android-client#

部分内容，根据自己的理解添加或者修改

URL拼接

Retrofit 在初始化的时候，需要指定一个baseUrl:

 private static Retrofit.Builder mBuilder = new Retrofit.Builder()
            .baseUrl("http://192.168.0.102/")
            .addConverterFactory(GsonConverterFactory.create());

在我们定义请求的接口时，会传入具体的接口的地址（Endpoint）：

 @GET("index.php?c=User&m=getUser")
    Call<List<User>> getUser();

Retrofit会帮我们完成拼接，最后的URL是：

http://192.168.0.102/index.php?c=User&m=getUser

需要注意的是baseUrl必须以”/”结尾

正确的写法：

Base URL: http://example.com/api/
Endpoint: foo/bar/
Result: http://example.com/api/foo/bar/

错误写法：

Base URL: http://example.com/api
Endpoint: foo/bar/
Result: http://example.com/foo/bar/

Endpoint可以为完整的URL：

  Base URL: http://example.com/
  Endpoint: https://github.com/square/retrofit/
  Result: https://github.com/square/retrofit/

当我们需要请求不同服务器上的API时，这就非常有用了。

另外，Retrofit还支持我们在调用时，传入URL：

@GET
Call<List<User>> getUser2(@Url String url);
Call<List<User>> call=userClient.getUser2("http://www.jiangxu.online/index.php?c=User&m=getUser");

Get查询参数

查询参数是一种很常见的客户端往服务端传递数据的方式，比如我们需要传一个id给服务端，那么URL可能是这样的：

https://api.example.com/tasks?id=123

Retrofit 定义实现查询参数：

public interface TaskService {  
    @GET("/tasks")
    Call<Task> getTask(@Query("id") long taskId);
}

方法getTask需要传入taskId，这个参数会被映射到@Query(“id”)中的id中，最后的URL会变成这样：

/tasks?id=<taskId>

有时我们需要对于一个id参数传入多个值，比如这样：

https://api.example.com/tasks?id=123&id=124&id=125

对于这样的需求，Retrofit 通过传入一个List来实现：

public interface TaskService {  
    @GET("/tasks")
    Call<List<Task>> getTask(@Query("id") List<Long> taskIds);
}

这样，拼接后的URL就是我们需要的那样。

有时，我们在给服务端传递数据时，有些参数是可选的，比如下面的URL：

https://your.api.com/tasks?sort=value-of-order-parameter

sort参数是可选的，有些情况下可能不需要传入。

接口的定义：

public interface TaskService {  
    @GET("/tasks")
    Call<List<Task>> getTasks(@Query("sort") String order);
}

那么，在我们不想添加排序控制的时候，我们可以传入null,Retrofit 会忽略值为null的参数。

service.getTasks(null);

需要注意的是，可忽略参数的参数类型不能是int, float, long这些基本类型，应该用Integer, Float, Long来代替。

Post 提交参数

Retrofit Post方式提交表单形式的参数需要添加标记@FormUrlEncoded，通过@Field注释添加键值对。
接口定义：

public interface UserClient {
    @FormUrlEncoded
    @POST("/index.php?c=User&m=login")
    Call<List<User>> login(@Field("phone") String phone, @Field("password") String password);
}

客户端调用：

 private void login() {
        UserClient userClient = ServiceGenerator.createService(UserClient.class);
        Call<List<User>> call = userClient.login("13695378745","123456");
        call.enqueue(new Callback<List<User>>() {

        });
    }

Post 提交JSON数据

有时提交的数据量比较大时，用键值对的方式提交参数不太方便，Retrofit可以通过@Body注释，直接传递一个对象给请求主体，Retrofit通过JSON转化器，把对象映射成JSON数据。

接口定义：

public interface TaskService {  
    @POST("/tasks")
    Call<Task> createTask(@Body Task task);
}

传递实体需要有Model：

public class Task {  
    private long id;
    private String text;

    public Task() {}
    public Task(long id, String text) {
        this.id = id;
        this.text = text;
    }
}

客户端调用：

Task task = new Task(1, "my task title");  
Call<Task> call = taskService.createTask(task);  
call.enqueue(new Callback<Task>() {});

这样，服务端得到的是JOSN数据：

{
    "id": 1,
    "text": "my task title"
}

文件下载

接口定义：

 @Streaming
    @GET
    Call<ResponseBody> downloadFile(@Url String fileUrl);

在下载的时候，是在子线程中工作运行的，有时需要显示下载的进度，同时支持多个下载并发进行，这样需要封装一下，使用起来方便：

public class DownFileManager {

    private final static String TAG = "DownFileManager";
    private static DownFileManager sDownFileManager;
    private CallBack mCallBack;
    private final Handler mHandler = new Handler(Looper.getMainLooper());
    private ExecutorService executorService;

    public interface CallBack {

        void onSuccess(String path);

        void inProgress(int progress);

        void onFail();
    }

    public static DownFileManager getInstance() {
        if (sDownFileManager == null) {
            sDownFileManager = new DownFileManager();
        }
        return sDownFileManager;
    }

    public synchronized ExecutorService executorService() {
        if (executorService == null) {
            executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), Util.threadFactory("DownFileManager", false));
        }
        return executorService;
    }

    public void download(final String path, final String filePath, CallBack callBack) {
        mCallBack = callBack;
        executorService();
        executorService.submit(new Runnable() {
            boolean isSuccess;

            @Override
            public void run() {
                DownloadService service = ServiceGenerator.createService(DownloadService.class);
                Call<ResponseBody> call = service.downloadFile(path);
                try {
                    isSuccess = writeResponseBodyToDisk(filePath, call.execute().body());
                } catch (Exception e) {
                    e.printStackTrace();
                }
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (isSuccess) {
                            mCallBack.onSuccess(filePath);
                        } else {
                            mCallBack.onFail();
                        }
                    }
                });
            }
        });
    }

    private boolean writeResponseBodyToDisk(String path, ResponseBody body) {
        try {
            File futureStudioIconFile = new File(path);
            InputStream inputStream = null;
            OutputStream outputStream = null;
            try {
                byte[] fileReader = new byte[4096];

                long fileSize = body.contentLength();
                long fileSizeDownloaded = 0;

                inputStream = body.byteStream();
                outputStream = new FileOutputStream(futureStudioIconFile);
                int oldProgress = 0;
                while (true) {
                    int read = inputStream.read(fileReader);

                    if (read == -1) {
                        break;
                    }
                    outputStream.write(fileReader, 0, read);
                    fileSizeDownloaded += read;
                    final int progress = (int) ((fileSizeDownloaded * 1.0 / fileSize) * 100);
                    if (oldProgress != progress) {
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                mCallBack.inProgress(progress);
                            }
                        });
                    }
                    oldProgress = progress;
                }
                outputStream.flush();
                return true;
            } catch (IOException e) {
                return false;
            } finally {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
            }
        } catch (IOException e) {
            return false;
        }
    }

}

使用：

 DownFileManager.getInstance().download(downloadUrl, filePath, new DownFileManager.CallBack() {
            @Override
            public void onSuccess(String path) {
                //下载文件的路径
            }

            @Override
            public void inProgress(int progress) {
                //下载的进度
                Trace.i("DownFileManager","progress  ="+progress);
            }

            @Override
            public void onFail() {
            }
        });

文件上传

Retrofit 支持 Multipart 请求，所以我们可以用它来实现文件上传，对于要实现文件上传的接口，需要添加@Multipart注释。
接口定义：

public interface FileUploadService {
    @Multipart
    @POST("index.php?c=Upload&m=doUpload")
    Call<Msg> upload(
            @Part("file\"; filename=\"image.png\" ") RequestBody file,
            @Part("description") RequestBody description);
}

对于要上传的文件，我们需要把它包装成RequestBody 对象：

 private void uploadFile( File file) {
        FileUploadService service =
                ServiceGenerator.createService(FileUploadService.class);

        String descriptionString = "hello, this is description speaking";
        RequestBody description =
                RequestBody.create(MediaType.parse("multipart/form-data"), descriptionString);
        RequestBody requestBody =
                RequestBody.create(MediaType.parse("multipart/form-data"), file);

        Call<Msg> call = service.upload(requestBody, description);
        call.enqueue(new Callback<Msg>() {
            @Override
            public void onResponse(Call<Msg> call, Response<Msg> response) {
                Log.v("Upload", "success");
            }

            @Override
            public void onFailure(Call<Msg> call, Throwable t) {
                Log.e("Upload", t.getMessage());
            }
        });
    }

同步请求和异步请求

同步的请求会在同一个线程中执行，在Android中必须另开线程，否则在主线程中执行会抛出异常。
同步和异步请求的接口都是一样的，只是调用的时候会不一样：

public interface TaskService {  
    @GET("/tasks")
    Call<List<Task>> getTasks();
}

同步请求调用：

TaskService taskService = ServiceGenerator.createService(TaskService.class);  
Call<List<Task>> call = taskService.getTasks();  
List<Task>> tasks = call.execute().body();

异步请求调用：

TaskService taskService = ServiceGenerator.createService(TaskService.class);  
Call<List<Task>> call = taskService.getTasks();  
call.enqueue(new Callback<List<Task>>() {  
    @Override
    public void onResponse(Call<List<Task>> call, Response<List<Task>> response) {
        if (response.isSuccess()) {
            // tasks available
        } else {
            // error response, no access to resource?
        }
    }

    @Override
    public void onFailure(Call<List<Task>> call, Throwable t) {
        // something went completely south (like no internet connection)
        Log.d("Error", t.getMessage());
    }
}

异步请求实现了一个CallBack，包含了两个回调方法：onResponse和 onFailure，在onResponse中我们可以拿到我们需要的实体数据，在onFailure中，可以拿到错误的Log。

Demo地址：

http://download.csdn.net/detail/jiangxuqaz/9452369

small-dream
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
2.Retrofit上传list数组给后端
weixin_46785122的博客
03-26 670
bean类： public class Answer { /** * subject_id : 1 * option_opt : ["a"] */ private int subject_id; private List<String> option_opt; public int getSubject_id() { return subject_id; } public void setSubject_id(int subject_id) { this.subje
android retrofit上传List集合数据
易寻资料的博客
02-06 1518
使用时如使用的android默认的CallAdapter，则不需要添加网络请求适配器的依赖，否则则需要按照 需求进行添加Retrofit提供的CallAdapter。App应用程序通过retrofit请求网络，实际上是使用retrofit接口层封装请求参数，Header，Url等信息，之后由OkHttp完成后续的请求操作。与@Field的区别：功能相同，但携带的参数类型更加丰富，包括数据流，所以适用于有文件上传的场景具体使用：与@Multipart注解配合使用。’后面的key-value）
2024年安卓最全Retrofit使用教程（一）- Retrofit入门详解，2024年最新移动端页面开发 模板
最新发布
2301_82242326的博客
05-15 377
针对Android程序员，我这边给大家整理了一些资料，包括不限于高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！往期Android高级架构资料、源码、笔记、视频。高级UI、性能优化、架构师课程、混合式开发（ReactNative+Weex）全方面的Android进阶实践技术，群内还有技术大牛一起讨论交流解决问题。
Retrofit简单使用（小白都会了）
zjcoming
08-07 3150
文章目录【1】Retrofit 简单使用1.1 目的1.2 关于API1.3Retrofit的使用1.3.1 配置客户端的API接口`WeatherService`1.3.2 简单封装一下获取retrofit实例和Service的工具类（单例设计模式）1.3.3 写一个javabean接收返回的json数据1.4 实现效果： 【1】Retrofit 简单使用 1.1 目的 我们使用Retrofit+OKhttp网络框架完成请求并返回数据显示。 1.2 关于API 我这里使用的是聚合数据，里面有很多免费的接
Retrofit教程
m0_49508485的博客
09-26 339
创建一个自定义的Interceptor拦截器，然后在创建Retrofit实例的地方通过addInterceptor()进行添加，通过它我们可以实现一些拦截的操作，比如下面：我们想要拦截每一次请求，添加一个公共的请求参数。但是如果提交的是一个Map集合，那么@Body的作用就相当于@Field，不过此时的map需要被FormBody.Builder处理成符合Okhttp的表单。@Url 用于在网络请求的时候，直接传入一个请求的Url变量，用于Url设置。来注解每个键值对的键名称，随后的对象需要提供键值对的。
retrofit简单使用
10-27
这个教程将带你了解Retrofit的基础使用，包括GET和POST请求以及JSON数据解析，这对于任何使用Retrofit的初学者来说都是必要的基础知识。 首先，让我们理解Retrofit的基本架构。Retrofit是由Square公司开发的一个...
Retrofit2最新视频教程
08-10
Retrofit2视频教程目录： 1.基本介绍.mp4 2.快速上手体验.mp4 3.GET请求介绍.mp4 4.Post请求介绍.mp4 5.与RxJava结合使用.mp4
retrofit视频教程
03-22
通过这套视频教程，开发者不仅能学习到Retrofit的基本用法，还能了解到如何将Retrofit与其他库（如RxJava）集成，提升Android应用的网络功能。对于初学者和有一定经验的开发者来说，都是十分有价值的参考资料。
Android Retrofit的简单使用
08-09
在本教程中，我们将探讨如何使用 Retrofit 来实现基本的网络请求。 ### 1. 添加依赖 首先，我们需要在项目的 `build.gradle` 文件中添加 Retrofit 和其依赖的 OkHttp 库的依赖项： ```groovy dependencies { ...
retrofit使用的简单demo
06-27
在本教程中，我们将深入探讨Retrofit的基本使用方法，包括其核心概念、配置、接口定义以及如何进行实际的网络请求。 首先，让我们了解Retrofit的核心概念。Retrofit是一个基于注解的HTTP客户端，它允许开发者将HTTP...
Retrofit2基本使用
10-20
Retrofit2基本使用，参数注解的基本使用，Path、Field、FieldMap、Body、Part、partMap、Query、QueryMap
Retrofit各个注解的含义及作用
IT666DHW的博客
12-01 630
本篇文章基于retrofit-2.1进行分析. 1. 各个注解的含义及使用 1.1 Body注解: 作用于方法的参数使用该注解定义的参数不可为null当你发送一个post或put请求,但是又不想作为请求参数或表单的方式发送请求时,使用该注解定义的参数可以直接传入一个实体类,retrofit会通过convert把该实体序列化并将序列化后的结果直接作为请求体发送出去. 示例:
Retrofit使用教程
wdd1324的博客
04-26 815
1、网络、图片框架介绍，retrofit（需要okhttp和oki）、glide     1.接口地址拼接，baseurl以/结尾，@get（）内部要以字母开头     2.get请求的操作         1.@GET设置get的请求方式         2.@Query 动态设置get请求参数         3.{method}    @Path动态设置接口后缀
安卓 retrofit @body用法
a506656675的博客
05-16 3273
Api @POST("接口") Observable<PullBean> pull(@Body RequestBody body); presenter public void pull(String json){ RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json); Observabl
Retrofit 基本使用
无问西东的博客
09-06 690
内容导图 1、依赖库导入 implementation 'com.squareup.retrofit2:retrofit:2.4.0' implementation 'com.squareup.retrofit2:converter-gson:2.3.0' 2、基本使用 2.1、定义请求接口 import hq.demo.net.model.WeatherBeans; impo...
retrofit中使用body标签传RequestBody
热门推荐
帅气的红烧肉的博客
08-01 2万+
现在的Android开发者基本上都用过retrofit这个第三方网络请求库吧！！！ 网络请求中有get、post、delete和put等等请求方式。 现在我们需要用到post请求： @POST(&quot;exec&quot;) Observable&amp;lt;HttpResult&amp;gt; getSystemContent(@Body RequestBody body); 可以注意到我们这里请求参数的标签用到...
retrofit的基本使用
04-28
Retrofit 是一个用于 Android 和 Java 的 Type-Safe HTTP 客户端，它可以将 HTTP API 转换为 Java 接口。Retrofit 通过注解来描述 HTTP 请求和响应的结构，从而使得开发者可以使用 Java 接口来调用 API。 基本使用步骤如下： 1. 导入 Retrofit 库。在 build.gradle 文件中添加以下代码： ``` dependencies { implementation 'com.squareup.retrofit2:retrofit:2.9.0' } ``` 2. 定义 API 接口。通过 Java 接口的方式定义 API 接口，如： ``` public interface ApiService { @GET("user/{id}") Call<User> getUser(@Path("id") int userId); } ``` 3. 创建 Retrofit 实例。通过 Retrofit.Builder 创建 Retrofit 实例，如： ``` Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.github.com/") .build(); ``` 4. 创建 API 实例。通过 Retrofit.create() 方法创建 API 接口的实例，如： ``` ApiService apiService = retrofit.create(ApiService.class); ``` 5. 发起请求。通过 API 接口实例来发起请求，如： ``` Call<User> call = apiService.getUser(userId); call.enqueue(new Callback<User>() { @Override public void onResponse(Call<User> call, Response<User> response) { // 请求成功处理 } @Override public void onFailure(Call<User> call, Throwable t) { // 请求失败处理 } }); ``` 以上就是 Retrofit 的基本使用步骤。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值