Retrofit – Java(Android) 的REST 接口封装类库汇总

合集下载

retrofit 原理解析

retrofit 原理解析

retrofit 原理解析【最新版】目录1.Retrofit 简介2.Retrofit 的原理3.Retrofit 的使用方法4.Retrofit 的优势与不足正文【Retrofit 简介】Retrofit 是一个基于 OkHttp 的网络请求库,用于实现 Android 和 Java 平台的 RESTful API 客户端。

它提供了一种简单、可靠的方式来发起 HTTP 请求,使得开发者可以专注于 API 的设计和实现,而无需花费大量时间处理底层网络请求细节。

【Retrofit 的原理】Retrofit 的核心原理是使用 OkHttp 作为底层 HTTP 客户端,通过动态生成请求的 API 接口,将 OkHttp 中的 Request 和 Response 对象映射到具体的 Java 对象。

具体来说,Retrofit 主要通过以下几个步骤实现这一原理:1.定义 API 接口:开发者需要创建一个接口,用于描述 API 的请求方法、URL 和参数。

Retrofit 会根据这个接口生成对应的 Request 对象。

2.配置 Retrofit:开发者需要创建一个 Retrofit 实例,并传入 API 接口和 OkHttp 客户端。

Retrofit 实例会根据配置信息生成具体的请求对象。

3.发起请求:开发者可以通过 Retrofit 实例发起 HTTP 请求,Retrofit 会将请求信息传递给 OkHttp,并将响应结果返回给开发者。

【Retrofit 的使用方法】使用 Retrofit 的步骤如下:1.添加依赖:在项目的 build.gradle 文件中添加 Retrofit 和OkHttp 的依赖。

2.定义 API 接口:创建一个接口,并使用 Retrofit 的注解来描述请求方法、URL 和参数。

3.创建 Retrofit 实例:创建一个 Retrofit 实例,并传入 API 接口和 OkHttp 客户端。

android retrofit用法

android retrofit用法

android retrofit用法Android Retrofit用法Retrofit是一个广泛使用的网络请求库,在Android开发中非常受欢迎。

它简化了与服务器进行通信的过程,提供了一种简单、灵活和高效的方式来处理网络请求。

下面是一些Android Retrofit的常见用法和详细的讲解。

1. 添加依赖库首先,在你的项目中添加Retrofit依赖库。

在你的文件中的dependencies块中添加以下代码:implementation ':retrofit:'请注意将”“替换为你需要使用的Retrofit版本号。

2. 创建网络请求接口接下来,创建一个接口来定义你的网络请求。

这个接口将包含你希望发送到服务器的所有请求。

public interface ApiService {@GET("users/{user}/repos")Call<List<Repo>> getRepos(@Path("user") String user); }在这个例子中,我们定义了一个名为getRepos的方法,该方法将使用GET请求获取指定用户的存储库列表。

@GET注释用于指定HTTP请求的类型和路径,@Path注释用于指定请求路径中的动态参数。

3. 创建网络请求实例接着,创建一个Retrofit实例来处理你的网络请求。

通常,在你的应用程序的某个单例类中创建并初始化Retrofit实例。

Retrofit retrofit = new ().baseUrl(".addConverterFactory(()).build();ApiService apiService = ();在这个例子中,我们使用Builder模式创建一个Retrofit实例。

我们指定了服务器的基本URL和要使用的转换器(这里我们使用Gson来将响应转换为Java对象)。

retrofit 参数

retrofit 参数

retrofit 参数摘要:I.简介- 介绍Retrofit 库- 阐述Retrofit 在Android 和Java 开发中的作用II.Retrofit 参数类型- 请求参数(Request Parameters)- 定义请求参数- 示例:使用请求参数的API 调用- 响应参数(Response Parameters)- 定义响应参数- 示例:使用响应参数的API 调用III.Retrofit 参数传递方式- 请求体(Request Body)- 定义请求体参数- 示例:使用请求体参数的API 调用- 请求头(Request Headers)- 定义请求头参数- 示例:使用请求头参数的API 调用- URL 参数(URL Query Parameters)- 定义URL 参数- 示例:使用URL 参数的API 调用IV.Retrofit 参数实战- 使用Retrofit 发送GET 请求并传递参数- 使用Retrofit 发送POST 请求并传递参数- 使用Retrofit 发送PUT 请求并传递参数- 使用Retrofit 发送DELETE 请求并传递参数V.总结- 回顾Retrofit 参数的相关内容- 强调Retrofit 参数在网络请求中的重要性正文:I.简介Retrofit 是一款强大的网络请求库,它基于Java 语言开发,适用于Android 和Java 平台。

Retrofit 可以帮助开发者轻松地实现网络请求,并简化API 的调用过程。

在Retrofit 中,参数的传递和处理是非常重要的一部分。

本文将详细介绍Retrofit 参数的相关知识,包括参数类型、传递方式以及实战应用。

II.Retrofit 参数类型Retrofit 参数主要分为请求参数和响应参数。

1.请求参数(Request Parameters)在Retrofit 中,请求参数可以通过在API 接口中定义参数类型和注解来完成。

Android网络请求框架之Retrofit

Android网络请求框架之Retrofit

Android网络请求框架之Retrofit Retrofit之前言Retrofit是square家族开源系列的精品之一,是一个简单好用的网络请求框架,基于REST 的架构风格,本框架的主要开发人Jake Wharton想必大家也有所耳闻,他也是REST的忠实拥护者和践行者。

引入开源框架,大部分开发者的目的是为了更快速的开发应用,省掉一些复杂的逻辑处理,Retrofit封装了网络请求,让开发者面向接口去请求服务,使用注解和代理去发起真正的请求,让开发者省掉所有网络请求的代码。

你不用担心android6.0不支持httpclient方式的请求,你也不用引入gson去转换数据与对象,所有的这一切,Retrofit都已帮你完美实现。

Retrofit之用法声明:1.以下例子是基于1.9.0版本的,后面还有2.0.0版的,下一篇文章我将给大家展示他们之间的区别;2.列子代码是基于AndroidStudio的。

1.在build.gradle文件里引入Retrofit需要的版本com.squareup.retrofit:retrofit:1.9.0,当然,如果了解RxJava和RxAndroid的童鞋也可以引入io.reactivex:rxjava:1.0.14 、io.reactivex:rxandroid:1.0.1,配合Retrofit使用会更加好用。

2.实现Callback接口public abstract class RCallback<T> implements retrofit.Callback<T> {@Overridepublic abstract void success(T t, Response response);@Overridepublic void failure(RetrofitError error) {Global.ProcException(error);}}看到泛型T,估计大家就知道意味着什么了吧?我们可以直接指定返回的对象了,不用再去解析json数据了!3.封装请求的载体public class RestAdapterFactory {private HashMap<String, SoftReference<RestAdapter>> adapters;private static volatile RestAdapterFactory maker;private RestAdapterFactory() {adapters = new HashMap<>();}/*** 获取创建RestAdapter的工厂** @return*/public synchronized static RestAdapterFactory getInstance() {synchronized (RestAdapterFactory.class) {if (null == maker) {synchronized (RestAdapterFactory.class) {maker = new RestAdapterFactory();}}}return maker;}/*** 创建RestAdapter** @param url* @return*/public synchronized RestAdapter build(final String url) {//这就是发起请求的对象RestAdapter adapter = null==adapters.get(url)?null:adapters.get(url).get();if (null == adapter) {final CellInfo cellInfo = Utils.getCellInfo();//添加一些headerRequestInterceptor requestInterceptor = new RequestInterceptor() {@Overridepublic void intercept(RequestFacade request) {request.addHeader("Authorization", String.format("Bearer %s", MainApp.getToken()));request.addHeader("LoyoPlatform", cellInfo.getLoyoPlatform());request.addHeader("LoyoAgent", cellInfo.getLoyoAgent());request.addHeader("LoyoOSVersion", cellInfo.getLoyoOSVersion());request.addHeader("LoyoVersionName", Global.getV ersionName());request.addHeader("LoyoVersionCode",String.valueOf(Global.getV ersion()));}};//指定url,设置log级别,设置拦截器。

android

android

android Retrofit2⽹络请求封装介绍⽬录1. Retrofit使⽤2. Retrofit封装3. RetrofitUtil使⽤最后1. Retrofit使⽤Retrofit是⼀个现在⽹络请求框架,先来说⼀下怎么使⽤⽹络权限(添加到AndroidManifest.xml)<uses-permission android:name="android.permission.INTERNET" />gradle依赖(添加到build.gradle)implementation("com.squareup.okhttp3:okhttp:4.9.2")implementation 'com.squareup.retrofit2:retrofit:2.9.0'implementation 'com.squareup.retrofit2:converter-gson:2.9.0'implementation 'com.squareup.retrofit2:converter-scalars:2.9.0'定义接⼝,⽹络请求的⽅法public interface Request {@GET("/xx/xx")Call<ResponseBody> get();}实例化RetrofitRetrofit retrofit = new Retrofit.Builder().baseUrl("BASE_URL").build();通过Retrofit实例创建接⼝服务对象Request request = retrofit.create(Request.class);调⽤接⼝中的⽅法Call<ResponseBody> call = request.get();执⾏异步请求(同步请求需要创建⼀个新的线程去执⾏)call.enqueue(new retrofit2.Callback<ResponseBody>() {@Overridepublic void onResponse(retrofit2.Call<ResponseBody> call, retrofit2.Response<ResponseBody> response) {}@Overridepublic void onFailure(retrofit2.Call<ResponseBody> call, Throwable t) {}});2. Retrofit封装以上可以看出Retrofit是个好东西,可是⽤起来是⽐较⿇烦的,所有在实际使⽤中对Retrofit进⾏⼀下⼩⼩的封装是很有必要的。

【推荐下载】Android Retrofit框架解析

【推荐下载】Android Retrofit框架解析

Android Retrofit 框架解析随着Google 对HttpClient 的摒弃,和Volley 的逐渐没落,OkHttp 开始异军突起,而Retrofit 则对okHttp 进行了强制依赖。

Retrofit 也是Square 公司开发的一款针对Android 网络请求的框架,其实质就是对okHttp 的封装,使用面向接口的方式进行网络请求,利用动态生成的代理类封装了网络接口。

retrofit 非常适合于RESTful url格式的请求,更多使用注解的方式提供功能。

既然是RESTful 架构,那么我们就来看一下什么是REST 吧。

REST(REpresentational State Transfer)是一组架构约束条件和原则。

RESTful 架构都满足以下规则:(1)每一个URI 代表一种资源;(2)客户端和服务器之间,传递这种资源的某种表现层;(3)客户端通过四个HTTP 动词(GET,POST,PUT,DELETE),对服务器端资源进行操作,实现”表现层状态转化”。

更多关于REST 的介绍使用Retrofit2.0 Eclipse 的用户,添加Jar 包和网络访问权限下载最新的jar:我将整理的所有jar 包已上传注意: 1.Retrofit 必须使用okhttp 请求了,如果项目中没有okhttp 的依赖的话,肯定会出错。

2.okhttp 内部依赖okio 因此也要添加。

uses-permission android:name=“android.permission.INTERNET”/用法介绍创建API 接口在retrofit 中通过一个Java 接口作为http 请求的api 接口。

//定以接口public interface GitHubService { @GET(“users/{user}/repos”) Call List Repo listRepos(@Path(“user”) String user);} 创建retrofit 实例/**获取实例*/Retrofit retrofit = new Retrofit.Builder() //设置OKHttpClient,如果不设置会提供一个默认的.client(new OkHttpClient()) //设置baseUrl .baseUrl(“https://api.github/”) //添加Gson 转换器.addConverterFactory(GsonConverterFactory.create()) .build(); 注:1.retrofit2.0 后:BaseUrl 要以/结尾;@GET 等请求不要以/开头;@Url: 可以定义完整url,不要以/ 开头。

移动应用开发复习题集及答案

移动应用开发复习题集及答案

移动应用开发复习题集及答案在移动应用开发领域,复习是非常重要的一环。

为了帮助大家系统地巩固和回顾移动应用开发的知识点,本文整理了一套复习题集及答案。

希望这些题目能够帮助你巩固知识,提高应用开发技能。

一、基础题1. 请解释什么是移动应用开发?移动应用开发指的是为移动平台(如手机、平板电脑)开发应用程序的过程,包括前端设计、后端开发、测试和发布等环节。

2. 列举出你熟悉的移动应用开发平台。

例如:iOS平台(使用Objective-C或Swift进行开发)、Android平台(使用Java或Kotlin进行开发)、Windows Phone平台(使用C#进行开发)等。

3. 移动应用开发中,什么是UI和UX设计的区别?UI(用户界面)设计关注应用的外观和交互,例如按钮的样式、颜色、排版等;而UX(用户体验)设计则更关注用户在应用中的整体体验,包括流畅性、易用性和便捷性等。

4. 请简要解释什么是原生应用开发?原生应用开发是指使用特定的开发语言和工具来针对特定移动平台进行应用开发的方式。

例如,在iOS平台上使用Objective-C或Swift 编写应用。

5. 移动应用开发中,什么是混合应用开发?混合应用开发是指使用Web技术(如HTML、CSS、JavaScript)开发应用,然后通过平台提供的WebView加载应用。

这种开发方式可以实现跨平台开发。

二、代码实践题1. 请编写一个Android应用,实现一个登录界面,并处理用户登录操作。

```java// 这里给出示例代码,供参考// MainActivity.javaimport android.support.v7.app.AppCompatActivity;import android.os.Bundle;import android.view.View;import android.widget.Button;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends AppCompatActivity {private EditText usernameEditText;private EditText passwordEditText;private Button loginButton;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);usernameEditText = findViewById(ernameEditText);passwordEditText = findViewById(R.id.passwordEditText);loginButton = findViewById(R.id.loginButton);loginButton.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {String username = usernameEditText.getText().toString();String password = passwordEditText.getText().toString();if (username.equals("admin") && password.equals("123456")) {Toast.makeText(MainActivity.this, "登录成功",Toast.LENGTH_SHORT).show();} else {Toast.makeText(MainActivity.this, "用户名或密码错误", Toast.LENGTH_SHORT).show();}}});}}```2. 请编写一个iOS应用,实现一个计算器界面,并能进行基本的加减乘除运算。

retrofit原理

retrofit原理

retrofit原理Retrofit是一个基于Java的RESTful API库,用于在Android 应用程序中处理网络请求。

它使用注解编程模型和OkHttp网络库来简化HTTP请求和响应的处理。

Retrofit的工作原理如下:1. 创建一个描述API接口的Java接口。

在接口中,可以使用注解来定义需要发送的HTTP请求和响应的格式。

2. 使用Retrofit创建一个与API接口关联的实例。

3. 当需要发送网络请求时,可以调用创建的API接口中的方法。

Retrofit将自动处理请求和响应的转换。

4. 请求将被转换为一个HTTP请求并发送到服务器。

5. 接收到的响应将被转换为预期的Java对象,并在合适的回调中返回给应用程序。

Retrofit使用注解来定义API接口中的方法和参数的行为:- @GET:定义一个GET请求。

- @POST:定义一个POST请求。

- @PUT:定义一个PUT请求。

- @DELETE:定义一个DELETE请求。

- @Query:将参数添加到请求的URL中作为查询参数。

- @Body:将参数作为请求体发送。

- @Path:将参数添加到请求的URL中作为路径参数。

在运行时,Retrofit将根据定义的注解和方法参数生成一个实现API接口的动态代理对象。

当调用该代理对象的方法时,Retrofit将根据注解和参数生成相应的HTTP请求,并通过OkHttp发送给服务器。

服务器返回的响应将通过Retrofit的转换器转换为预期的Java 对象,并通过回调返回给应用程序。

应用程序可以根据返回的结果进行相应的处理。

总结而言,Retrofit通过简化HTTP请求和响应的处理,使得开发人员可以更方便地与API进行交互和通信。

AndroidRetrofit框架的使用

AndroidRetrofit框架的使用

AndroidRetrofit框架的使⽤⽬录Retrofit介绍Retrofit优点Retrofit的使⽤1.引⼊依赖项2.添加⽹络权限3.编写Retrofit辅助类4.定义ApiService5.实现接⼝⽅法Retrofit介绍Retrofit是Square开源的⼀款基于OkHttp(也是他家的)封装的⽹络请求框架,主要的⽹络请求还是OkHttp来完成,Retrofit只是对OkHttp进⾏了封装,可以让我们更加简单⽅便的使⽤,⽬前⼤部分公司都在使⽤这款框架,Retrofit的原理也是⾯试必问的问题之⼀了,所以我们不仅要会使⽤,也要对其实现原理有⼀个⼤概的了解。

本⽚⽂章从使⽤⾓度来说,不对的地⽅希望⼤家在评论区交流,我会及时改进,共同进步,⽂章中的demo可以从github下载。

Retrofit优点Retrofit的⼤部分配置是通过注解来实现的,配置简单,使⽤⽅便;⽀持多种返回类型包括RxJava和协程,可以配置不同的解析器来进⾏数据解析,如Json,xml等Retrofit的使⽤以下代码全部为Kotlin语⾔编写,毕竟现在Kotlin也是⼤势所趋了。

1.引⼊依赖项github地址:implementation 'com.squareup.retrofit2:retrofit:2.9.0'//⽀持Gson解析json数据implementation 'com.squareup.retrofit2:converter-gson:2.9.0'//⽀持RxJava返回类型implementation "com.squareup.retrofit2:adapter-rxjava2:2.9.0"implementation "io.reactivex.rxjava2:rxandroid:2.0.2"//⽀持协程,Retrofit2.6.0及以上版本不需要引⼊,Retrofit内置已经⽀持//implementation 'com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2'2.添加⽹络权限<uses-permission android:name="android.permission.INTERNET"/>3.编写Retrofit辅助类⾸先定义⼀个RetrofitHelper辅助类,编写Retrofit单例,Retrofit内部已经维护了线程池做⽹络请求,不需要创建多个注:BASE_URL必须为 "/" 结尾object RetrofitHelper {//baseUrl根据⾃⼰项⽬修改private const val BASE_URL = "https://"private var retrofit: Retrofit? = nullprivate var retrofitBuilder: Retrofit.Builder? = null//Retrofit初始化fun init(){if (retrofitBuilder == null) {val client = OkHttpClient.Builder().connectTimeout(20, TimeUnit.SECONDS).readTimeout(20, TimeUnit.SECONDS).writeTimeout(20, TimeUnit.SECONDS).build()retrofitBuilder = Retrofit.Builder().baseUrl(BASE_URL)//⽀持Json数据解析.addConverterFactory(GsonConverterFactory.create())//⽀持RxJava返回类型.addCallAdapterFactory(RxJava2CallAdapterFactory.create()).client(client)}retrofit = retrofitBuilder!!.build()}fun getRetrofit():Retrofit{if (retrofit == null) {throw IllegalAccessException("Retrofit is not initialized!")}return retrofit!!}}然后再Application中进⾏初始化class App:Application() {override fun onCreate() {super.onCreate()RetrofitHelper.init()}}在Manifest⽂件中指定Application<applicationandroid:name=".App"android:allowBackup="true"android:icon="@mipmap/ic_launcher"android:label="@string/app_name"android:roundIcon="@mipmap/ic_launcher_round"android:supportsRtl="true"android:networkSecurityConfig="@xml/network_security_config"android:theme="@style/Theme.RetrofitDemo"><activity android:name=".MainActivity"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /></intent-filter></activity></application>Android P系统限制了明⽂流量的⽹络请求解决的办法有2种 1.把所有的http请求全部改为https请求 2.在res的xml⽬录(),然后创建⼀个名为:network_security_config.xml⽂件<?xml version="1.0" encoding="utf-8"?><network-security-config><base-config cleartextTrafficPermitted="true" /></network-security-config>4.定义ApiService⾸先我们先⽤⼀个最简单的GET请求来试⼀下,这个接⼝是请求天⽓情况的,免费的interface Api {@GET("/data/sk/{cityCode}.html")fun getWeather(@Path("cityCode")code:String):Observable<WeatherInfo>}定义返回类型,为了⽅便打印,⽤的data class 类型data class WeatherInfo(var weatherinfo:Info?=null) {data class Info(var city:String?,var cityid:String?,var temp:String?,var WD:String?,var WS:String?,var SD:String?,var AP:String?,var njd:String?,var WSE:String?,var time:String?)}⾸先⽤@GET注解表⽰该借⼝为get请求,GET注解的value为请求地址,完整的请求地址为baseUrl+value,如value为完整地址,则会使⽤value为请求地址,⼀般通⽤情况下baseUrl = "/", 然后GET("data/sk/{cityCode}.html")@Path是⽹址中的参数,⽤来替换。

AndroidRxJavaRetrofit完美封装

AndroidRxJavaRetrofit完美封装

AndroidRxJavaRetrofit完美封装今⽇科技快讯前⼏天,北京地区发⽣重度雾霾,不少中⼩学都已经停课,⼀些公司也临时启⽤了在家远程办公的⽅式。

据京东统计,在12⽉16⽇⾄12⽉20⽇五天时间内,京东⼀共卖出了1500万只⼝罩和11万台空⽓净化器。

但具有戏剧性的⼀幕是,就在昨天,北京的空⽓突然爆好,AQI指数从400多骤降到20左右,晴空万⾥,雾霾散尽,看来很多⼈的⼝罩可能都⽩买了。

作者简介本篇来⾃⼩河马的投稿,分享了⾃⼰是如何进⾏ RxJava+Retrofit 的封装。

本⽂的技术点⾃然没话说,另外对于这种模块化的思路,希望能帮助到⼤家。

最后提前祝⼤家周末愉快以及圣诞快乐!⼩河马的博客地址:前⾔Retrofit 和 RxJava 已经出来很久了,很多前辈写了很多不错的⽂章,在此不得不感谢这些前辈⽆私奉献的开源精神,能让我们站在巨⼈的肩膀上望得更远。

对于 RxJava 不是很了解的同学推荐你们看扔物线⼤神的这篇⽂章:给Android开发者的RxJava详解⼀遍看不懂就看第⼆遍。

Retrofit的使⽤可以参考:Android Retrofit2.0使⽤本⽂内容是基于 Retrofit + RxJava 做的⼀些巧妙的封装。

参考了很多⽂章加⼊了⼀些⾃⼰的理解,请多指教。

源码地址:先放出 build.gradle:本⽂是基于 RxJava1.1.0 和 Retrofit 2.0.0-beta4 来进⾏的。

初始化Retrofit新建类Api,此类就是初始化 Retrofit,提供⼀个静态⽅法初始化 Retrofit ⾮常简单.提供⼀个静态⽅法初始化 Retrofit,⼿动创建了 OkHttpClient 设置了请求的超时时间。

并在OkHttp 的拦截器中增加了请求头。

注意这⾥是为所有的请求添加了请求头,你可以单独的给请求增加请求头,例如:和 Retrofit 初始化不同的地⽅就在我们添加了这两句话:service 的定义也从这样:变成了:返回值变成了 Observable,这个 Observable 不就是 RxJava 的可观察者(即被观察者)么。

retrofit 参数

retrofit 参数

retrofit 参数Retrofit是一款非常流行的Java库,用于在Android和其他Java开发环境中进行网络请求。

在使用Retrofit进行网络请求时,我们需要指定请求的URL、HTTP方法、请求头、请求体等信息。

其中,参数是Retrofit中非常重要的一部分,它决定了请求的数据结构和发送方式。

一、参数类型Retrofit支持多种参数类型,包括:1.简单类型:如String、Integer、Boolean等。

2.集合类型:如List、Set、Map等。

3.自定义对象:如果需要发送复杂的数据结构,可以使用自定义对象作为参数。

二、参数命名规则在Retrofit中,参数的命名非常重要。

一般来说,参数名应该与请求体中的字段名一致。

如果请求体中只有一个字段,那么参数名应该与字段名相同。

如果请求体中有多个字段,那么应该使用特定的命名约定来命名参数,以方便解析请求体和设置响应体的值。

通常,参数名应该使用驼峰命名法,并且首字母应该大写。

三、参数顺序在Retrofit中,参数的顺序也非常重要。

一般来说,参数应该按照请求体中字段的顺序进行传递。

如果参数顺序不正确,可能会导致解析请求体时出现错误。

因此,在传递参数时,应该仔细检查参数顺序,确保与请求体中的字段顺序一致。

四、集合类型的参数如果需要传递集合类型的参数,可以使用List或Set等类型。

在使用集合类型时,需要注意集合元素的顺序和类型。

另外,对于Map 类型的参数,需要注意键值对的顺序和类型。

在设置响应体的值时,应该按照请求体中的字段顺序和类型进行设置。

五、自定义对象的参数如果需要传递自定义对象的参数,可以使用Retrofit中的Model 类。

Model类是一个简单的Java类,用于描述请求体和响应体的数据结构。

在使用Model类时,需要将请求体和响应体的字段与Model类中的属性进行映射。

在设置响应体的值时,应该按照Model类中的字段顺序和类型进行设置。

retrofit post 参数list

retrofit post 参数list

retrofit post 参数list什么是Retrofit?Retrofit是一款基于Java的类型安全的HTTP客户端工具,专门用于Android开发。

它基于Square开源的OkHttp库,使得网络请求更加简单和高效。

Retrofit允许开发者定义一个RESTful API的接口,并且通过注解的方式将HTTP请求方法映射到相应的接口中,从而快速、方便地进行网络请求。

为什么选择使用Retrofit?Retrofit相比传统的网络请求方式具有很多优点。

首先,Retrofit支持将Java接口转化为HTTP请求,这样在编写代码时可以以面向对象的方式进行操作,大大降低了开发难度。

其次,Retrofit使用注解的方式来定义和处理HTTP请求,使得代码更加简洁清晰,易于维护和扩展。

此外,Retrofit 与OkHttp底层库结合,提供了网络请求的高性能和稳定性。

最重要的是,Retrofit支持自动化解析JSON格式的响应数据,将其转化为Java对象,简化了数据处理的过程。

如何使用Retrofit发送POST请求?使用Retrofit发送POST请求非常简单。

首先,在项目的build.gradle文件中添加Retrofit的依赖:javaimplementation 'com.squareup.retrofit2:retrofit:2.x.x'接下来,在网络请求的接口中定义POST请求方法,并使用POST注解指定请求路径:javapublic interface ApiService {POST("/api/login")Call<User> login(Body User user);}在上述代码中,我们定义了一个名为login的方法,该方法接受一个User 对象作为参数,并使用Body注解将其作为请求体发送给服务器。

接口中的返回类型为Call<T>,其中T为响应数据的类型。

Android开发retrofit入门讲解

Android开发retrofit入门讲解

Android开发retrofit⼊门讲解前⾔ retrofit基于okhttp封装的⽹络请求框架,⽹络请求的⼯作本质上是 OkHttp 完成,⽽ retrofit 仅负责⽹络请求接⼝的封装.如果你不了解OKhttp建议你还是先了解它在来学习使⽤retrofit,传送门: Retrofit优势,就是简洁易⽤,解耦,扩展性强,可搭配多种Json解析框架(例如Gson),另外还⽀持RxJava.但是,这篇博客不讲解RxJava配合使⽤的部分,与RxJava的配合使⽤将在另外⼀篇博客中讲解. 另外retrofit已经是封装的⾮常好了,作者的想的很完整,它的封装的思想⼗分准确⽽且恰到好处(堪称标准),所以不建议多此⼀举的再次封装retrofit. 再次封装不会让你很⽜逼. 只会让你看起来更蠢。

你会想封装只能说明你压根没理解或者阅读过retrofit。

过度封装以后出现⼀个任何问题都可能出现重构灾难,那就整个项⽬的接⼝代码都要增加代码。

减少重复⼯作只需要给2个东西做⼀个⼯具类(OkHttpClient与Retrofit.Builder()),在⼀些简单场景只需要将配置好的⽹络接⼝列表服务类保存好(保存到Application或者单例保存)。

Github地址依赖 如果你不需要使⽤RxJava模式,那么你只需要依赖下⾯2个:implementation 'com.squareup.retrofit2:retrofit:2.6.2'implementation 'com.squareup.retrofit2:converter-gson:2.4.0' gson是⽤来解析的Json数据使⽤的(个⼈偏爱Gson),retrofit也⽀持其他解析⼯具⽐如fastJson简单的Demo(异步请求) ⽼规矩按思维顺序讲解demo1.创建Retrofit请求基础配置 Retrofit配置好后,你可以将它单例保存,也不可以保存。

如何动态改变Retrofit的baseurl和rest版本详解

如何动态改变Retrofit的baseurl和rest版本详解

如何动态改变Retrofit的baseurl和rest版本详解概述随着Google对HttpClient 摒弃,和Volley的逐渐没落,OkHttp开始异军突起,⽽Retrofit则对okHttp进⾏了强制依赖。

Retrofit是由Square公司出品的针对于Android和Java的类型安全的Http客户端,如果看源码会发现其实质上就是对okHttp的封装,使⽤⾯向接⼝的⽅式进⾏⽹络请求,利⽤动态⽣成的代理类封装了⽹络接⼝请求的底层,其将请求返回javaBean,对⽹络认证 REST API进⾏了很好对⽀持此,使⽤Retrofit将会极⼤的提⾼我们应⽤的⽹络体验。

REST既然是RESTful架构,那么我们就来看⼀下什么是REST吧。

REST(REpresentational State Transfer)是⼀组架构约束条件和原则。

RESTful架构都满⾜以下规则:(1)每⼀个URI代表⼀种资源;(2)客户端和服务器之间,传递这种资源的某种表现层;(3)客户端通过四个HTTP动词,对服务器端资源进⾏操作,实现”表现层状态转化”。

下⾯话不多说了,来开始本⽂的正⽂吧1. 需求与前提base urlrest 版本/rest/v1//rest/v2//rest/v3/需求点⼤部分接⼝使⽤ cloud host, 部分接⼝使⽤ private host⼤部分接⼝使⽤ rest/v3 版本, 部分接⼝使⽤ v2, v1版本.每个host 都有可能存在 rest v1, v2, v3的接⼝2. 实现思路okhttp 可以添加拦截器, 可在发起访问前进⾏拦截, 通常我们会在拦截器中统⼀添加 header, ⽐如:class HeaderInterceptor implements Interceptor {private static final String ENCODING_GZIP = "gzip";private static final String CONTENT_TYPE_JSON = "application/json;charset=UTF-8";private static final String HEADER_CONTENT_TYPE = "Content-Type";private static final String HEADER_ACCEPT_TYPE = "application/json";private static final String HEADER_CONTENT_ENCODING = "Content-Encoding";private final static String CHARSET = "UTF-8";@Overridepublic Response intercept(Chain chain) throws IOException {Request originRequest = chain.request();Request.Builder newBuilder = originRequest.newBuilder();newBuilder.addHeader("Accept", HEADER_ACCEPT_TYPE);newBuilder.addHeader("Accept-Charset", CHARSET);newBuilder.addHeader("Accept-Encoding", ENCODING_GZIP);newBuilder.addHeader("Accept-Language", Locale.getDefault().toString().replace("_", "-"));newBuilder.addHeader(HEADER_CONTENT_TYPE, CONTENT_TYPE_JSON);return chain.proceed(newBuilder.build());}}同理我们也可以在所有请求中添加统⼀的uuid 或者 key 进⾏防劫持或者认证. ⽐如:Request originRequest = chain.request();if (paramsMap != null) {HttpUrl originUrl = originRequest.url();HttpUrl.Builder newBuilder = originUrl.newBuilder();for (String key : paramsMap.keySet()) {newBuilder.addEncodedQueryParameter(key, paramsMap.get(key));}HttpUrl newUrl = newBuilder.build();Request newRequest = originRequest.newBuilder().url(newUrl).build();return chain.proceed(newRequest);}return chain.proceed(originRequest);那么, 同样我们可以再拦截器中进⾏host 和 path的替换, 那么怎么替换呢?3. 实现过程3.1 定义host 类型和 rest 版本host类型:interface HostName {String CLOUD = "CLOUD";String PRIVATE = "PRIVATE";String DEV = "DEV";}interface HostValue {String CLOUD = "https://";String PRIVATE = "https://";String DEV = "https://";}rest 版本:interface RestVersionCode {String EMPTY = "EMPTY";String V1 = "V1";String V2 = "V2";String PRIVATE = "PRIVATE";}/*** path 前缀值*/interface RestVersionValue {String EMPTY = "";String V1 = "rest/v1";String V2 = "rest/v2";String PRIVATE = "rest/private";}设置⼀个默认的 host 和 rest 版本, 然后在需要更改host和rest 版本的请求接⼝处添header, 根据header设置来变更. interface BaiduApiService {@GET("s")Observable<Response<Object>> search(@Query("wd")String wd);@GET("s")@Headers({UrlConstants.Header.REST_VERSION_V1})Observable<Response<Object>> searchChangePath(@Query("wd")String wd);@GET("s")@Headers({UrlConstants.Header.HOST_DEV})Observable<Response<Object>> searchChangeHost(@Query("wd")String wd);@Headers({UrlConstants.Header.HOST_PRIVATE, UrlConstants.Header.REST_VERSION_PRIVATE})@GET("s")Observable<Response<Object>> searchChangeHostPath(@Query("wd")String wd);}header 的可选值:interface Header {String SPLIT_COLON = ":";String HOST = "HostName";String HOST_CLOUD = HOST + SPLIT_COLON + HostName.CLOUD;String HOST_PRIVATE = HOST + SPLIT_COLON + HostName.PRIVATE;String HOST_DEV = HOST + SPLIT_COLON + HostName.DEV;String REST_VERSION = "RestVersion";String REST_VERSION_V1 = REST_VERSION + SPLIT_COLON + RestVersionCode.V1;String REST_VERSION_V2 = REST_VERSION + SPLIT_COLON + RestVersionCode.V2;String REST_VERSION_PRIVATE = REST_VERSION + SPLIT_COLON + RestVersionCode.PRIVATE; String REST_VERSION_EMPTY = REST_VERSION + SPLIT_COLON + RestVersionCode.EMPTY;}然后是解析:class RequestInterceptor implements Interceptor {@Overridepublic Response intercept(Chain chain) throws IOException {Request originRequest = chain.request();HttpUrl originUrl = originRequest.url();HttpUrl.Builder newBuilder;String hostType = originRequest.header(UrlConstants.Header.HOST);System.out.println("hostType:" + hostType);if (hostType != null && hostType.length() > 0) {String hostValue = UrlManager.getInstance().getHost(hostType);HttpUrl temp = HttpUrl.parse(hostValue);if (temp == null) {throw new IllegalArgumentException(hostType + "对应的host地址不合法:" + hostValue);}newBuilder = temp.newBuilder();} else {newBuilder = new HttpUrl.Builder().scheme(originUrl.scheme()).host(originUrl.host()).port(originUrl.port());}String restVersion = originRequest.header(UrlConstants.Header.REST_VERSION);System.out.println("restVersion:" + restVersion);if (restVersion == null) {restVersion = UrlConstants.RestVersionCode.V2;}String restValue = UrlManager.getInstance().getRest(restVersion);if (restValue.contains("/")) {String[] paths = restValue.split("/");for (String path : paths) {newBuilder.addEncodedPathSegment(path);}} else {newBuilder.addEncodedPathSegment(restValue);}for (int i = 0; i < originUrl.pathSegments().size(); i++) {newBuilder.addEncodedPathSegment(originUrl.encodedPathSegments().get(i));}newBuilder.encodedPassword(originUrl.encodedPassword()).encodedUsername(originUrl.encodedUsername()).encodedQuery(originUrl.encodedQuery()).encodedFragment(originUrl.encodedFragment());HttpUrl newUrl = newBuilder.build();System.out.println("newUrl:" + newUrl.toString());Request newRequest = originRequest.newBuilder().url(newUrl).build();return chain.proceed(newRequest);}}为了能动态设置host, 我们需要⼀个map来存储host 类型和值.private Map<String, String> hostMap;private Map<String, String> restMap;private UrlManager() {hostMap = new HashMap<>(16);for (UrlConstants.Host host : UrlConstants.Host.values()) {hostMap.put(host.getName(), host.getValue());}restMap = new HashMap<>();for (UrlConstants.Rest rest : UrlConstants.Rest.values()) {restMap.put(rest.getVersion(), rest.getValue());}}//更新host 的值public void setHost(String name, String value) {if (hostMap.containsKey(name)) {HttpUrl httpUrl = HttpUrl.parse(value);if (httpUrl == null) {throw new IllegalArgumentException("要存⼊的Host " + name + "对应的value:"+ value + "不合法!");}hostMap.put(name, value);} else {throw new NoSuchElementException("没有找到已经定义的Host名称:" + name + ",请先在" +"net.devwiki.manager.UrlConstants.Host中定义!");}}//根据host 获取值public String getHost(String name) {if (!hostMap.containsKey(name)) {throw new NoSuchElementException("没有找到已经定义的Host名称:" + name + ",请先在" +"net.devwiki.manager.UrlConstants.Host中定义!");}return hostMap.get(name);}这样就可以动态替换host 和 rest版本了.4.测试运⾏测试代码:private static void testRequest() {BaiduRest rest = new BaiduRest();testDefault(rest);testChangeHost(rest);testChangePath(rest);testChangeHostPath(rest);}测试运⾏结果:结果按照设置进⾏了host 和 rest 的变更.5. 项⽬代码项⽬代码地址: ()总结以上就是这篇⽂章的全部内容了,希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值,如果有疑问⼤家可以留⾔交流,谢谢⼤家对的⽀持。

android retrofit原理

android retrofit原理

android retrofit原理Android Retrofit原理Retrofit是一个类型安全的REST客户端,可以轻松地将android应用程序连接到web服务。

这是一个可以使用HTTP网络请求并处理他们的强大库,它允许你将你的网络代码以声明性的方式标记,从而节省了大量的时间和努力。

它的特点是高度灵活性,简单易用,可扩展性。

Retrofit是一个基于OkHttp的库,将HTTP请求封装成接口,只需要通过注解提供URL信息,然后Retrofit会自动生成相应的网络请求代码。

使用Retrofit可以更快更容易地与网络数据进行交互,而不必写大量的样板代码。

Retrofit的原理是基于Java中的反射机制,在编译时它会动态生成与接口声明的代理类,这个代理类实现了你定义的接口,并在运行时动态生成实现细节。

Retrofit的工作流程是,首先定义一个接口(基本上就是一个方法),接口中定义好URL、HTTP方法,然后定义参数,比如字符串,JSON对象等,当你调用这个接口时,Retrofit会解析接口,生成HTTTP请求,并将参数绑定到HTTP请求中,然后使用OkHttp发送请求,服务器响应后,Retrofit会将响应解析成相应的数据类型(比如JSON),返回给调用者。

Retrofit支持多种参数类型,比如:query参数,path参数,body参数,part参数等等。

Retrofit也支持多种数据类型,比如:String、JSON、XML、Bitmap等等。

Retrofit也支持rxjava,可以使用Rxjava来调用Retrofit接口。

Retrofit的优点就是可以使用简单的API快速构建灵活的网络应用程序,减少了大量重复性的工作,并且可以很容易地更新或替换网络库。

Retrofit也很容易集成,因为它是基于OkHttp和Gson的,所以可以利用OkHttp和Gson的优势,而不需要额外的工作。

retrofit 原理解析

retrofit 原理解析

retrofit 原理解析
Retrofit 是一个基于 Square 公司开发的 OkHttp 库的 RESTful
网络请求框架,它简化了 Android 开发中网络请求的复杂度。

Retrofit 的原理可以分为以下几个部分:
1. 注解解析:Retrofit 使用了注解来定义网络请求接口,如
`@GET`、`@POST` 等。

在编译时,Retrofit 会解析这些注解,并生成相应的网络请求代码。

2. 接口动态代理:Retrofit 使用动态代理技术生成网络请求接
口的实现类。

当应用调用网络请求接口的方法时,实际上是调用了动态代理类中的方法。

动态代理类会根据注解的信息构建具体的网络请求。

3. 请求构建:动态代理类根据注解中的信息,构建一个网络请求对象。

这个对象包含了请求的 URL、请求方法、请求头、
请求参数等信息。

4. 请求发送:Retrofit 使用 OkHttp 库来发送网络请求。

通过调
用 OkHttp 的 `newCall()` 方法,将构建的请求对象传递给OkHttp,然后通过 `enqueue()` 方法异步地发送请求。

5. 响应处理:OkHttp 发送请求后,会通过回调方法返回响应。

Retrofit 根据响应的内容,使用内置的转换器将响应数据转换
成 Java 对象,并将数据返回给应用。

总结起来,Retrofit 的原理就是通过注解解析和动态代理技术,
将网络请求接口转化为实际的网络请求对象,并使用 OkHttp 发送请求和接收响应。

这样可以使网络请求的使用变得简单和灵活,减少了开发的复杂度。

retrofit原理

retrofit原理

retrofit原理Retrofit原理。

Retrofit是一个针对Android平台的类型安全的HTTP客户端,它是Square公司开发的一个强大的RESTful类型安全的网络库。

它可以将HTTP API转换为Java 接口,并且可以使用注解来描述HTTP请求参数和请求方法。

Retrofit的原理是基于OkHttp的,OkHttp是一个处理网络请求的库,而Retrofit是在OkHttp的基础上进行了封装和扩展,提供了更加便捷和灵活的网络请求方式。

Retrofit的原理主要包括以下几个方面:1. 接口定义,在使用Retrofit的过程中,首先需要定义一个接口来描述HTTP 请求方法和请求参数。

通过注解的方式,可以很方便地描述请求的URL、请求方法、请求头、请求参数等信息。

Retrofit会根据接口的定义来生成实际的网络请求代码。

2. 请求转换,Retrofit会将接口定义中的注解信息转换为实际的HTTP请求。

它会根据接口定义中的注解信息,将请求参数转换为HTTP请求的URL、请求方法、请求头、请求体等信息,并使用OkHttp来发送网络请求。

3. 响应转换,当网络请求返回响应时,Retrofit会将HTTP响应转换为Java对象。

通过定义接口方法的返回类型,可以指定期望的响应类型,Retrofit会根据指定的响应类型来将HTTP响应转换为相应的Java对象。

4. 异步处理,Retrofit默认是在后台线程中进行网络请求的,当网络请求返回响应时,可以通过回调的方式来处理响应结果。

也可以通过RxJava等方式来进行异步处理。

总的来说,Retrofit的原理就是将接口定义中的注解信息转换为实际的HTTP 请求,并将HTTP响应转换为Java对象。

它通过封装和扩展OkHttp,提供了一种类型安全、便捷、灵活的网络请求方式,使得在Android平台上进行网络请求变得更加简单和高效。

在实际使用Retrofit的过程中,需要注意的是,要合理地定义接口和注解,合理地处理请求和响应,以及合理地进行异步处理,这样才能充分发挥Retrofit的优势,实现高效、稳定的网络请求功能。

retrofit核心实现原理

retrofit核心实现原理

retrofit核心实现原理Retrofit是一个开源的网络请求框架,它主要用于在Android中进行网络请求操作。

它的核心实现原理是通过注解和动态代理技术来实现的。

在使用Retrofit进行网络请求时,我们首先需要定义一个接口,接口中的方法用于描述我们要进行的网络请求操作。

在方法上使用注解来设置请求的方式、URL地址、请求参数、请求头等信息。

然后,通过Retrofit的动态代理技术,将这个接口转换成一个实现类的对象,该对象封装了网络请求的具体逻辑。

Retrofit的核心实现原理可以分为以下几个步骤:1. 创建Retrofit对象:我们需要创建一个Retrofit对象,通过Builder模式来设置一些基本的配置信息,比如服务器的地址、数据解析器、日志打印等。

2. 定义接口:我们需要定义一个接口,接口中的方法用于描述我们要进行的网络请求操作。

在方法上使用注解来设置请求的方式、URL地址、请求参数、请求头等信息。

3. 创建动态代理类:Retrofit通过动态代理技术,将定义的接口转换成一个实现类的对象。

在这个过程中,Retrofit会解析接口中的注解信息,并根据注解的设置生成相应的网络请求逻辑。

4. 发起网络请求:通过调用动态代理类中的方法,我们就可以发起网络请求了。

Retrofit会根据注解中设置的信息,自动构建出一个符合HTTP协议的请求对象,并将请求发送到服务器端。

同时,Retrofit还会将服务器返回的数据解析成我们定义的Java对象,并通过回调函数将结果返回给我们。

总的来说,Retrofit的核心实现原理是通过注解和动态代理技术来简化网络请求的操作。

通过注解,我们可以在接口方法上设置请求的方式、URL地址、请求参数等信息。

通过动态代理技术,Retrofit将接口转换成一个实现类的对象,封装了网络请求的具体逻辑。

这样,我们只需要调用接口中的方法,就能发起网络请求并获取结果。

这种方式简化了网络请求的代码编写,提高了开发效率。

retrofit 原理

retrofit 原理

retrofit 原理Retrofit 是一个功能强大的网络请求库,它通过将网络请求接口定义为 Java 接口的方式,使得网络请求的实现变得简单和直观。

Retrofit 的原理可以分为以下几个部分:1. 注解解析:Retrofit 使用注解的方式来定义网络请求的接口和参数。

在编译阶段,Retrofit 会通过使用 Java 反射来解析这些注解从而生成相关的代码。

例如,@GET 注解表示一个GET 请求,@Query 注解可以添加查询参数等。

2. 动态代理:Retrofit 会将网络请求接口通过动态代理的方式,创建一个接口的实例。

这个实例会在调用方法时,通过注解等信息来构造网络请求的参数和参数值。

然后,Retrofit 会使用底层的 OkHttp 库来发送网络请求。

3. 反序列化和类型转换:Retrofit 提供了多种转换器,用于将服务器返回的数据进行反序列化和类型转换。

比如可以使用Gson 转换器将服务器返回的 JSON 数据反序列化为 Java 对象。

开发者也可以自定义转换器,以支持其他的数据格式。

4. 线程切换:Retrofit 可以在网络请求的过程中,自动进行线程切换。

默认情况下,Retrofit 使用 OkHttp 的异步请求方式,在子线程中执行网络请求,然后在主线程中执行回调。

开发者也可以通过使用 RxJava 等其他框架,来自定义线程切换的方式。

由于 Retrofit 的设计思想是将网络请求接口定义为 Java 接口,所以使用 Retrofit 的流程非常简洁和直观。

开发者只需要通过定义一个接口,并使用注解标记接口的方法,然后通过Retrofit 创建接口的实例即可。

接口的方法通过注解的方式定义了网络请求的类型、路径、参数等信息,Retrofit 会根据这些注解解析生成对应的网络请求代码。

总结起来,Retrofit 的原理就是通过注解解析、动态代理、反序列化和类型转换、线程切换等技术,将网络请求的实现变得简单和直观。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Retrofit 和Java领域的ORM概念类似, ORM把结构化数据转换为Java对象,而Retrofit 把REST API返回的数据转化为Java对象方便操作。

同时还封装了网络代码的调用。

例如:public interface GitHubService {@GET("/users/{user}/repos")List<Repo> listRepos(@Path("user") String user);}定义上面的一个REST API接口。

该接口定义了一个函数 listRepos , 该函数会通过HTTP GET请求去访问服务器的/users/{user}/repos路径并把返回的结果封装为List<Repo> Java对象返回。

其中URL路径中的{user}的值为listRepos 函数中的参数 user的取值。

然后通过RestAdapter 类来生成一个GitHubService 接口的实现;GitHubService service = restAdapter.create(GitHubService.class);获取接口的实现后就可以调用接口函数来和服务器交互了;List<Repo> repos = service.listRepos("octocat");从上面的示例可以看出, Retrofit 使用注解来声明HTTP请求1.支持 URL 参数替换和查询参数2.返回结果转换为Java对象(返回结果可以为JSON, protocol buffers)3.支持 Multipart请求和文件上传具体使用文档函数和函数参数上的注解声明了请求方式请求方式每个函数都必须带有 HTTP 注解来表明请求方式和请求的URL路径。

类库中有5个HTTP 注解: GET , POST , PUT , DELETE , 和HEAD。

注解中的参数为请求的相对URL路径。

@GET("/users/list")在URL路径中也可以指定URL参数@GET("/users/list?sort=desc")URL处理请求的URL可以根据函数参数动态更新。

一个可替换的区块为用{ 和} 包围的字符串,而函数参数必需用@Path 注解表明,并且注解的参数为同样的字符串@GET("/group/{id}/users") //注意字符串idList<User> groupList(@Path("id") int groupId); //注意 Path注解的参数要和前面的字符串一样 id还支持查询参数@GET("/group/{id}/users")List<User> groupList(@Path("id") int groupId, @Query("sort") String sort);请求体(Request Body)通过@Body 注解可以声明一个对象作为请求体发送到服务器。

@POST("/users/new")void createUser(@Body User user, Callback<User> cb);对象将被RestAdapter 使用对应的转换器转换为字符串或者字节流提交到服务器。

FORM ENCODED AND MULTIPART 表单和Multipart函数也可以注解为发送表单数据和multipart 数据使用@FormUrlEncoded 注解来发送表单数据;使用@Field 注解和参数来指定每个表单项的Key,value为参数的值。

@FormUrlEncoded@POST("/user/edit")User updateUser(@Field("first_name") String first, @Field("last_name") String last);使用@Multipart 注解来发送multipart数据。

使用@Part 注解定义要发送的每个文件。

@Multipart@PUT("/user/photo")User updateUser(@Part("photo") TypedFile photo, @Part("description") TypedString des cription);Multipart 中的Part使用RestAdapter 的转换器来转换,也可以实现TypedOutput 来自己处理序列化。

异步VS 同步每个函数可以定义为异步或者同步。

具有返回值的函数为同步执行的。

@GET("/user/{id}/photo")Photo listUsers(@Path("id") int id);而异步执行函数没有返回值并且要求函数最后一个参数为Callback对象@GET("/user/{id}/photo")void listUsers(@Path("id") int id, Callback<Photo> cb);在 Android 上,callback对象会在主(UI)线程中调用。

而在普通Java应用中,callback 在请求执行的线程中调用。

服务器结果转换为Java对象使用RestAdapter的转换器把HTTP请求结果(默认为JSON)转换为Java对象,Java对象通过函数返回值或者Callback接口定义@GET("/users/list")List<User> userList();@GET("/users/list")void userList(Callback<List<User>> cb);如果要直接获取HTTP返回的对象,使用Response 对象。

@GET("/users/list")Response userList();@GET("/users/list")void userList(Callback<Response> cb);项目主页:http://square.github.io/retrofit/参考项目:http://square.github.io/okhttp/Android 示例项目:https:///goodev/RetrofitDemo定义一个注解,用来对bean进行要序列化的字段[java]view plaincopy1.import ng.annotation.Documented;2.import ng.annotation.ElementType;3.import ng.annotation.Retention;4.import ng.annotation.RetentionPolicy;5.import ng.annotation.Target;6.7./**8. * 用于Gson命名策略的注解9. */10.@Documented11.@Retention(RetentionPolicy.RUNTIME)12.@Target(ElementType.FIELD)13.public@interface ParamName {14.15. String value();16.}将注解对需要网络传输bean进行标注:[java]view plaincopy1.public class requestBean implements Parcelable {2.public static final int RESPONSE_OK = 1;3.@ParamName("id")4.private String mId;5.@ParamName("name")6.private String mName;7.@ParamName("result")8.private int mResult;9.@ParamName("message")10.private String mMessage;11.public int getResult() {12.return mResult;13.}14.public String getMessage() {15.return mMessage;16.}17.public String getId()18.{19.return mId;20.}21.public String getName()22.{23.return mName;24.}25.public boolean succeed() {26.return getResult() == RESPONSE_OK;27.}28.}把定义好的注解封装进gson[java]view plaincopy1.import com.google.gson.FieldNamingPolicy;2.import com.google.gson.FieldNamingStrategy;3.import com.google.gson.Gson;4.import com.google.gson.GsonBuilder;5.6.import com.newandbie.privatecustomize.Config;7.import com.newandbie.privatecustomize.annotate.ParamName;8.import com.newandbie.privatecustomize.model.Gender;9.10.import ng.reflect.Field;11.12./**13. * 自定义的Gson14. */15.public class GsonUtils {16.17.public static Gson newInstance() {18. GsonBuilder builder = new GsonBuilder();19.20. builder.setFieldNamingStrategy(new AnnotateNaming());21.22.return builder.create();23. }24.25.private static class AnnotateNaming implements FieldNamingStrategy {26.27.@Override28.public String translateName(Field field) {29. ParamName a = field.getAnnotation(ParamName.class);30.return a != null ? a.value() : FieldNamingPolicy.IDENTITY.translateName(field);31. }32. }33.}[java]view plaincopy1.import com.squareup.okhttp.Cache;2.import com.squareup.okhttp.OkHttpClient;3.5.6.import java.io.File;7.import java.io.IOException;8.import java.util.concurrent.TimeUnit;9.10./**11. * OkHttpClient自定义工具类12. */13.public class OkHttpUtils {14.15.private static OkHttpClient singleton;16.17.public static OkHttpClient getInstance(Context context) {18.if (singleton == null) {19.synchronized (OkHttpUtils.class) {20.if (singleton == null) {21. File cacheDir = new File(context.getCacheDir(), Config.RESPONSE_CACHE);22.23. singleton = new OkHttpClient();24.try {25. singleton.setCache(new Cache(cacheDir, Config.RESPONSE_CACHE_SIZE));26. } catch (IOException e) {27. e.printStackTrace();28. }29. singleton.setConnectTimeout(Config.HTTP_CONNECT_TIMEOUT,LISECONDS);30. singleton.setReadTimeout(Config.HTTP_READ_TIMEOUT, TimeULISECONDS);31. }32. }33. }34.return singleton;35. }36.}定义Retrofit工具将以上两个工具配置到RetrofitUtils[java]view plaincopy1.import android.content.Context;2.3.import retrofit.RestAdapter;5.import retrofit.converter.GsonConverter;6.7.public class RetrofitUtils {8.9.private static RestAdapter singleton;10.11.public static <T> T createApi(Context context, Class<T> clazz) {12.if (singleton == null) {13.synchronized (RetrofitUtils.class) {14.if (singleton == null) {15. RestAdapter.Builder builder = new RestAdapter.Builder();16. builder.setEndpoint(ip地址);//设置远程地址17. builder.setConverter(new GsonConverter(GsonUtils.newInstance()));18. builder.setClient(new OkClient(OkHttpUtils.getInstance(context)));19. builder.setLogLevel(20. Config.DEBUG ? RestAdapter.LogLevel.FULL : RestAdapter.LogLevel.NONE);21. singleton = builder.build();22. }23. }24. }25.return singleton.create(clazz);26. }27.}那么工具集准备好了,使用retrofit放在父类以便子类调用[java]view plaincopy1.import retrofit.Callback;2.import retrofit.RetrofitError;3.import retrofit.client.Response;/**4. * 界面的基类5. */6.public class BaseActivity extends ActionBarActivity {7.8.....9.11. * 创建API实例12. *13. * @param cls Api定义类的类型14. * @param <T> 范型15. * @return API实例16. */17.public <T> T createApi(Class<T> cls) {18.return RetrofitUtils.createApi(this, cls);19. }20.21.22.public static abstract class ActivityCallback<T>23.implements Callback<T> {24. <span style="white-space:pre"> </span>//软引用,缓存引用对象25.private final WeakReference<BaseActivity> mRef;26.27.28.public ActivityCallback(BaseActivity activity) {29. mRef = new WeakReference<BaseActivity>(activity);30. }31.32.33.public Activity getActivity() {34.return mRef.get();35. }36.37.38.@Override39.public void failure(RetrofitError error) {40.final BaseActivity activity = mRef.get();41.42.43. Response response = error.getResponse();44.if (response != null) {45. Toast.makeText(activity, activity.getString(R.string.server_error),46. Toast.LENGTH_SHORT).show();47. Log.e(getLogTag(),48."code:" + response.getStatus() + ", reason:" + response.getReason());49. error.printStackTrace();50. }51.53.54.55. }56.57......58.59.}定义下面的一个REST API接口。

相关文档
最新文档