说明：该文章转载于

前言

• 在andrroid开发中，网络请求十分常用
• 而在android网络请求库中，retrofit是当下最热的一个网络请求库

• 今天，我将献上一份非常详细retrofit v2.0的使用教程，希望你们会喜欢。

如果对retrofit v2.0的源码感兴趣，可看文章：android：手把手带你深入剖析 retrofit 2.0 源码

---

目录

---

1. 简介

特别注意：

• 准确来说，retrofit 是一个 restful 的 http 网络请求框架的封装。
• 原因：网络请求的工作本质上是 okhttp 完成，而 retrofit 仅负责 网络请求接口的封装

• app应用程序通过 retrofit 请求网络，实际上是使用 retrofit 接口层封装请求参数、header、url 等信息，之后由 okhttp 完成后续的请求操作
• 在服务端返回数据之后，okhttp 将原始的结果交给 retrofit，retrofit根据用户的需求对结果进行解析

---

2. 与其他开源请求库对比

除了retrofit，如今android中主流的网络请求框架有：

• android-async-http
• volley
• okhttp

下面是简单介绍：

一图让你了解全部的网络请求库和他们之间的区别！

---

附：各个主流网络请求库的github地址

• android-async-http
• volley
• okhttp
• retrofit

---

3. 使用介绍

使用 retrofit 的步骤共有7个：

步骤1：添加retrofit库的依赖
步骤2：创建 接收服务器返回数据 的类
步骤3：创建 用于描述网络请求 的接口
步骤4：创建 retrofit 实例
步骤5：创建 网络请求接口实例 并 配置网络请求参数
步骤6：发送网络请求（异步 / 同步）

封装了 数据转换、线程切换的操作

**步骤7： **处理服务器返回的数据

接下来，我们一步步进行讲解。

步骤1：添加retrofit库的依赖

1. 在 gradle加入retrofit库的依赖

build.gradle

dependencies {
    compile 'com.squareup.retrofit2:retrofit:2.0.2'
    // retrofit库
  }

2. 添加 网络权限
androidmanifest.xml

<uses-permission android:name="android.permission.internet"/>

步骤2：创建 接收服务器返回数据 的类

reception.java

public class reception {
    ...
    // 根据返回数据的格式和数据解析方式（json、xml等）定义
    // 下面会在实例进行说明
        }

步骤3：创建 用于描述网络请求 的接口

• retrofit将 http请求 抽象成 java接口：采用 注解 描述网络请求参数 和配置网络请求参数

1. 用 动态代理 动态 将该接口的注解“翻译”成一个 http 请求，最后再执行 http 请求
2. 注：接口中的每个方法的参数都需要使用注解标注，否则会报错

getrequest_interface.interface

public interface getrequest_interface {

    @get("openapi.do?keyfrom=yanzhikai&key=2032414398&type=data&doctype=json&version=1.1&q=car")
    call<translation>  getcall();
    // @get注解的作用:采用get方法发送网络请求

    // getcall() = 接收网络请求数据的方法
    // 其中返回类型为call<*>，*是接收数据的类（即上面定义的translation类）
    // 如果想直接获得responsebody中的内容，可以定义网络请求返回值为call<responsebody>
}

下面详细介绍retrofit 网络请求接口 的注解类型。

注解类型

注解说明

第一类：网络请求方法

详细说明：
a. @get、@post、@put、@delete、@head
以上方法分别对应 http中的网络请求方式

public interface getrequest_interface {

    @get("openapi.do?keyfrom=yanzhikai&key=2032414398&type=data&doctype=json&version=1.1&q=car")
    call<translation>  getcall();
    // @get注解的作用:采用get方法发送网络请求
    // getcall() = 接收网络请求数据的方法
    // 其中返回类型为call<*>，*是接收数据的类（即上面定义的translation类）
}

此处特意说明url的组成：retrofit把 网络请求的url 分成了两部分设置：

// 第1部分：在网络请求接口的注解设置
 @get("openapi.do?keyfrom=yanzhikai&key=2032414398&type=data&doctype=json&version=1.1&q=car")
call<translation>  getcall();

// 第2部分：在创建retrofit实例时通过.baseurl()设置
retrofit retrofit = new retrofit.builder()
                .baseurl("http://fanyi.youdao.com/") //设置网络请求的url地址
                .addconverterfactory(gsonconverterfactory.create()) //设置数据解析器
                .build();

// 从上面看出：一个请求的url可以通过 替换块 和 请求方法的参数 来进行动态的url更新。
// 替换块是由 被{}包裹起来的字符串构成
// 即：retrofit支持动态改变网络请求根目录

• 网络请求的完整 url =在创建retrofit实例时通过.baseurl()设置 +网络请求接口的注解设置（下面称 “path“ ）
• 具体整合的规则如下：

建议采用第三种方式来配置，并尽量使用同一种路径形式。

b. @http

• 作用：替换@get、@post、@put、@delete、@head注解的作用 及 更多功能拓展
• 具体使用：通过属性method、path、hasbody进行设置

public interface getrequest_interface {
    /**
     * method：网络请求的方法（区分大小写）
     * path：网络请求地址路径
     * hasbody：是否有请求体
     */
    @http(method = "get", path = "blog/{id}", hasbody = false)
    call<responsebody> getcall(@path("id") int id);
    // {id} 表示是一个变量
    // method 的值 retrofit 不会做处理，所以要自行保证准确
}

第二类：标记

a. @formurlencoded

• 作用：表示发送form-encoded的数据

每个键值对需要用@filed来注解键名，随后的对象需要提供值。

b. @multipart

• 作用：表示发送form-encoded的数据（适用于 有文件 上传的场景）

每个键值对需要用@part来注解键名，随后的对象需要提供值。

具体使用如下：
getrequest_interface

public interface getrequest_interface {
        /**
         *表明是一个表单格式的请求（content-type:application/x-www-form-urlencoded）
         * <code>field("username")</code> 表示将后面的 <code>string name</code> 中name的取值作为 username 的值
         */
        @post("/form")
        @formurlencoded
        call<responsebody> testformurlencoded1(@field("username") string name, @field("age") int age);

        /**
         * {@link part} 后面支持三种类型，{@link requestbody}、{@link okhttp3.multipartbody.part} 、任意类型
         * 除 {@link okhttp3.multipartbody.part} 以外，其它类型都必须带上表单字段({@link okhttp3.multipartbody.part} 中已经包含了表单字段的信息)，
         */
        @post("/form")
        @multipart
        call<responsebody> testfileupload1(@part("name") requestbody name, @part("age") requestbody age, @part multipartbody.part file);

}

// 具体使用
       getrequest_interface service = retrofit.create(getrequest_interface.class);
        // @formurlencoded 
        call<responsebody> call1 = service.testformurlencoded1("carson", 24);

        //  @multipart
        requestbody name = requestbody.create(texttype, "carson");
        requestbody age = requestbody.create(texttype, "24");

        multipartbody.part filepart = multipartbody.part.createformdata("file", "test.txt", file);
        call<responsebody> call3 = service.testfileupload1(name, age, filepart);

第三类：网络请求参数

详细说明

a. @header & @headers

• 作用：添加请求头 &添加不固定的请求头
• 具体使用如下：

// @header
@get("user")
call<user> getuser(@header("authorization") string authorization)

// @headers
@headers("authorization: authorization")
@get("user")
call<user> getuser()

// 以上的效果是一致的。
// 区别在于使用场景和使用方式
// 1\. 使用场景：@header用于添加不固定的请求头，@headers用于添加固定的请求头
// 2\. 使用方式：@header作用于方法的参数；@headers作用于方法

b. @body

• 作用：以 post方式 传递 自定义数据类型 给服务器
• 特别注意：如果提交的是一个map，那么作用相当于 @field

不过map要经过 formbody.builder 类处理成为符合 okhttp 格式的表单，如：

formbody.builder builder = new formbody.builder();
builder.add("key","value");

c. @field & @fieldmap

• 作用：发送 post请求 时提交请求的表单字段
• 具体使用：与 @formurlencoded 注解配合使用

public interface getrequest_interface {
        /**
         *表明是一个表单格式的请求（content-type:application/x-www-form-urlencoded）
         * <code>field("username")</code> 表示将后面的 <code>string name</code> 中name的取值作为 username 的值
         */
        @post("/form")
        @formurlencoded
        call<responsebody> testformurlencoded1(@field("username") string name, @field("age") int age);

/**
         * map的key作为表单的键
         */
        @post("/form")
        @formurlencoded
        call<responsebody> testformurlencoded2(@fieldmap map<string, object> map);

}

// 具体使用
         // @field
        call<responsebody> call1 = service.testformurlencoded1("carson", 24);

        // @fieldmap
        // 实现的效果与上面相同，但要传入map
        map<string, object> map = new hashmap<>();
        map.put("username", "carson");
        map.put("age", 24);
        call<responsebody> call2 = service.testformurlencoded2(map);

d. @part & @partmap

• 作用：发送 post请求 时提交请求的表单字段

与@field的区别：功能相同，但携带的参数类型更加丰富，包括数据流，所以适用于 有文件上传 的场景

• 具体使用：与 @multipart 注解配合使用

public interface getrequest_interface {

          /**
         * {@link part} 后面支持三种类型，{@link requestbody}、{@link okhttp3.multipartbody.part} 、任意类型
         * 除 {@link okhttp3.multipartbody.part} 以外，其它类型都必须带上表单字段({@link okhttp3.multipartbody.part} 中已经包含了表单字段的信息)，
         */
        @post("/form")
        @multipart
        call<responsebody> testfileupload1(@part("name") requestbody name, @part("age") requestbody age, @part multipartbody.part file);

        /**
         * partmap 注解支持一个map作为参数，支持 {@link requestbody } 类型，
         * 如果有其它的类型，会被{@link retrofit2.converter}转换，如后面会介绍的 使用{@link com.google.gson.gson} 的 {@link retrofit2.converter.gson.gsonrequestbodyconverter}
         * 所以{@link multipartbody.part} 就不适用了,所以文件只能用<b> @part multipartbody.part </b>
         */
        @post("/form")
        @multipart
        call<responsebody> testfileupload2(@partmap map<string, requestbody> args, @part multipartbody.part file);

        @post("/form")
        @multipart
        call<responsebody> testfileupload3(@partmap map<string, requestbody> args);
}

// 具体使用
 mediatype texttype = mediatype.parse("text/plain");
        requestbody name = requestbody.create(texttype, "carson");
        requestbody age = requestbody.create(texttype, "24");
        requestbody file = requestbody.create(mediatype.parse("application/octet-stream"), "这里是模拟文件的内容");

        // @part
        multipartbody.part filepart = multipartbody.part.createformdata("file", "test.txt", file);
        call<responsebody> call3 = service.testfileupload1(name, age, filepart);
        responsebodyprinter.printresponsebody(call3);

        // @partmap
        // 实现和上面同样的效果
        map<string, requestbody> fileupload2args = new hashmap<>();
        fileupload2args.put("name", name);
        fileupload2args.put("age", age);
        //这里并不会被当成文件，因为没有文件名(包含在content-disposition请求头中)，但上面的 filepart 有
        //fileupload2args.put("file", file);
        call<responsebody> call4 = service.testfileupload2(fileupload2args, filepart); //单独处理文件
        responsebodyprinter.printresponsebody(call4);
}

e. @query和@querymap

• 作用：用于 @get 方法的查询参数（query = url 中 ‘?’ 后面的 key-value）

如：url = http://www.println.net/?cate=android，其中，query = cate

• 具体使用：配置时只需要在接口方法中增加一个参数即可：

   @get("/")    
   call<string> cate(@query("cate") string cate);
}

// 其使用方式同 @field与@fieldmap，这里不作过多描述

f. @path

• 作用：url地址的缺省值
• 具体使用：

public interface getrequest_interface {

        @get("users/{user}/repos")
        call<responsebody>  getblog（@path("user") string user ）;
        // 访问的api是：https://api.github.com/users/{user}/repos
        // 在发起请求时， {user} 会被替换为方法的第一个参数 user（被@path注解作用）
    }

g. @url

• 作用：直接传入一个请求的 url变量 用于url设置
• 具体使用：

public interface getrequest_interface {

        @get
        call<responsebody> testurlandquery(@url string url, @query("showall") boolean showall);
       // 当有url注解时，@get传入的url就可以省略
       // 当get、post...http等方法中没有设置url时，则必须使用 {@link url}提供

}

汇总

步骤4：创建 retrofit 实例

 retrofit retrofit = new retrofit.builder()
                .baseurl("http://fanyi.youdao.com/") // 设置网络请求的url地址
                .addconverterfactory(gsonconverterfactory.create()) // 设置数据解析器
                .addcalladapterfactory(rxjavacalladapterfactory.create()) // 支持rxjava平台
                .build();

a. 关于数据解析器（converter）

• retrofit支持多种数据解析方式
• 使用时需要在gradle添加依赖

数据解析器	gradle依赖
gson	com.squareup.retrofit2:converter-gson:2.0.2
jackson	com.squareup.retrofit2:converter-jackson:2.0.2
simple xml	com.squareup.retrofit2:converter-simplexml:2.0.2
protobuf	com.squareup.retrofit2:converter-protobuf:2.0.2
moshi	com.squareup.retrofit2:converter-moshi:2.0.2
wire	com.squareup.retrofit2:converter-wire:2.0.2
scalars	com.squareup.retrofit2:converter-scalars:2.0.2

b. 关于网络请求适配器（calladapter）

• retrofit支持多种网络请求适配器方式：guava、java8和rxjava

使用时如使用的是 android 默认的 calladapter，则不需要添加网络请求适配器的依赖，否则则需要按照需求进行添加
retrofit 提供的 calladapter

• 使用时需要在gradle添加依赖：

网络请求适配器	gradle依赖
guava	com.squareup.retrofit2:adapter-guava:2.0.2
java8	com.squareup.retrofit2:adapter-java8:2.0.2
rxjava	com.squareup.retrofit2:adapter-rxjava:2.0.2

步骤5：创建 网络请求接口实例

        // 创建 网络请求接口 的实例
        getrequest_interface request = retrofit.create(getrequest_interface.class);

        //对 发送请求 进行封装
        call<reception> call = request.getcall();

步骤6：发送网络请求（异步 / 同步）

封装了 数据转换、线程切换的操作

//发送网络请求(异步)
        call.enqueue(new callback<translation>() {
            //请求成功时回调
            @override
            public void onresponse(call<translation> call, response<translation> response) {
                //请求处理,输出结果
                response.body().show();
            }

            //请求失败时候的回调
            @override
            public void onfailure(call<translation> call, throwable throwable) {
                system.out.println("连接失败");
            }
        });

// 发送网络请求（同步）
response<reception> response = call.execute();

步骤7：处理返回数据

通过response类的 body（）对返回的数据进行处理

//发送网络请求(异步)
        call.enqueue(new callback<translation>() {
            //请求成功时回调
            @override
            public void onresponse(call<translation> call, response<translation> response) {
                // 对返回数据进行处理
                response.body().show();
            }

            //请求失败时候的回调
            @override
            public void onfailure(call<translation> call, throwable throwable) {
                system.out.println("连接失败");
            }
        });

// 发送网络请求（同步）
  response<reception> response = call.execute();
  // 对返回数据进行处理
  response.body().show();

---

4. 实例讲解

接下来，我将用两个实例分别对 retrofit get方式 和 post方式进行 网络请求 讲解。

4.1 实例1

• 实现功能：将中文翻译成英文
• 实现方案：采用get方法对 金山词霸api 发送网络请求

采用 gson 进行数据解析

• 步骤说明

步骤1：添加retrofit库的依赖
步骤2：创建 接收服务器返回数据 的类
步骤3：创建 用于描述网络请求 的接口
步骤4：创建 retrofit 实例
步骤5：创建 网络请求接口实例 并 配置网络请求参数
步骤6：发送网络请求（采用最常用的异步方式）

封装了 数据转换、线程切换的操作

**步骤7： **处理服务器返回的数据

接下来，我们一步步进行讲解。

• 具体使用

步骤1：添加retrofit库的依赖

1. 在 gradle加入retrofit库的依赖

build.gradle

dependencies {
    compile 'com.squareup.retrofit2:retrofit:2.0.2'
    // retrofit库
  }

2. 添加 网络权限
androidmanifest.xml

<uses-permission android:name="android.permission.internet"/>

步骤2：创建 接收服务器返回数据 的类

• 金山词霸api 的数据格式说明如下：

// url模板
http://fy.iciba.com/ajax.php

// url实例
http://fy.iciba.com/ajax.php?a=fy&f=auto&t=auto&w=hello%20world

// 参数说明：
// a：固定值 fy
// f：原文内容类型，日语取 ja，中文取 zh，英语取 en，韩语取 ko，德语取 de，西班牙语取 es，法语取 fr，自动则取 auto
// t：译文内容类型，日语取 ja，中文取 zh，英语取 en，韩语取 ko，德语取 de，西班牙语取 es，法语取 fr，自动则取 auto
// w：查询内容

• 根据 金山词霸api 的数据格式，创建 接收服务器返回数据 的类：

translation.java

public class translation {
        private int status;

    private content content;
    private static class content {
        private string from;
        private string to;
        private string vendor;
        private string out;
        private int errno;
    }

    //定义 输出返回数据 的方法
    public void show() {
        system.out.println(status);

        system.out.println(content.from);
        system.out.println(content.to);
        system.out.println(content.vendor);
        system.out.println(content.out);
        system.out.println(content.errno);
    }
}

步骤3：创建 用于描述网络请求 的接口

采用 **注解 ** 描述 网络请求参数。
getrequest_interface.java

public interface getrequest_interface {

 @get("ajax.php?a=fy&f=auto&t=auto&w=hello%20world")
    call<translation> getcall();
    // 注解里传入 网络请求 的部分url地址
    // retrofit把网络请求的url分成了两部分：一部分放在retrofit对象里，另一部分放在网络请求接口里
    // 如果接口里的url是一个完整的网址，那么放在retrofit对象里的url可以忽略
    // getcall()是接受网络请求数据的方法
}

接下来的步骤均在getrequest.java内实现（看注释）

步骤4：创建retrofit对象
步骤5：创建 网络请求接口 的实例
步骤6：发送网络请求

以最常用的 异步请求 为例

步骤7：处理返回数据

getrequest.java

public class getrequest extends appcompatactivity {

    @override
    protected void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        setcontentview(r.layout.activity_main);

        request();
        // 使用retrofit封装的方法
    }
    public void request() {

        //步骤4:创建retrofit对象
        retrofit retrofit = new retrofit.builder()
                .baseurl("http://fy.iciba.com/") // 设置 网络请求 url
                .addconverterfactory(gsonconverterfactory.create()) //设置使用gson解析(记得加入依赖)
                .build();

        // 步骤5:创建 网络请求接口 的实例
        getrequest_interface request = retrofit.create(getrequest_interface.class);

        //对 发送请求 进行封装
        call<translation> call = request.getcall();

        //步骤6:发送网络请求(异步)
        call.enqueue(new callback<translation>() {
            //请求成功时回调
            @override
            public void onresponse(call<translation> call, response<translation> response) {
                // 步骤7：处理返回的数据结果
                response.body().show();
            }

            //请求失败时回调
            @override
            public void onfailure(call<translation> call, throwable throwable) {
                system.out.println("连接失败");
            }
        });
    }
}

由于此处采用了 gson 解析，所以需要在 gradle加入依赖
build.gradle

compile 'com.squareup.retrofit2:converter-gson:2.0.2'

运行结果

demo地址

carson_ho的github：https://github.com/carson-ho/retrofitdemo

---

4.2 实例2

• 实现的功能：将 英文 翻译成 中文
• 实现方法：采用post方法对 有道api 发送网络请求

采用 gson 进行数据解析

• 使用步骤

步骤1：添加retrofit库的依赖
步骤2：创建 接收服务器返回数据 的类
步骤3：创建 用于描述网络请求 的接口
步骤4：创建 retrofit 实例
步骤5：创建 网络请求接口实例 并 配置网络请求参数
步骤6：发送网络请求（采用最常用的异步方式）

封装了 数据转换、线程切换的操作

**步骤7： **处理服务器返回的数据

接下来，我们一步步进行retrofit的使用。

• 具体使用

步骤1：添加retrofit库的依赖

1. 在 gradle加入retrofit库的依赖

build.gradle

dependencies {
    compile 'com.squareup.retrofit2:retrofit:2.0.2'
    // retrofit库
  }

2. 添加 网络权限
androidmanifest.xml

<uses-permission android:name="android.permission.internet"/>

步骤2：创建 接收服务器返回数据 的类

• api 的数据格式说明如下：

// url
http://fanyi.youdao.com/translate

// url实例
http://fanyi.youdao.com/translate?doctype=json&jsonversion=&type=&keyfrom=&model=&mid=&imei=&vendor=&screen=&ssid=&network=&abtest=

// 参数说明
// doctype：json 或 xml
// jsonversion：如果 doctype 值是 xml，则去除该值，若 doctype 值是 json，该值为空即可
// xmlversion：如果 doctype 值是 json，则去除该值，若 doctype 值是 xml，该值为空即可
// type：语言自动检测时为 null，为 null 时可为空。英译中为 en2zh_cn，中译英为 zh_cn2en，日译中为 ja2zh_cn，中译日为 zh_cn2ja，韩译中为 kr2zh_cn，中译韩为 zh_cn2kr，中译法为 zh_cn2fr，法译中为 fr2zh_cn
// keyform：mdict. + 版本号 + .手机平台。可为空
// model：手机型号。可为空
// mid：平台版本。可为空
// imei：???。可为空
// vendor：应用下载平台。可为空
// screen：屏幕宽高。可为空
// ssid：用户名。可为空
// abtest：???。可为空

// 请求方式说明
// 请求方式：post
// 请求体：i
// 请求格式：x-www-form-urlencoded

• 根据 有道api 的数据格式，创建 接收服务器返回数据 的类：

translation.java

public class translation1 {

    private string type;
    private int errorcode;
    private int elapsedtime;
    private list<list<translateresultbean>> translateresult;

    public string gettype() {
        return type;
    }

    public void settype(string type) {
        this.type = type;
    }

    public int geterrorcode() {
        return errorcode;
    }

    public void seterrorcode(int errorcode) {
        this.errorcode = errorcode;
    }

    public int getelapsedtime() {
        return elapsedtime;
    }

    public void setelapsedtime(int elapsedtime) {
        this.elapsedtime = elapsedtime;
    }

    public list<list<translateresultbean>> gettranslateresult() {
        return translateresult;
    }

    public void settranslateresult(list<list<translateresultbean>> translateresult) {
        this.translateresult = translateresult;
    }

    public static class translateresultbean {
        /**
         * src : merry me
         * tgt : 我快乐
         */

        public string src;
        public string tgt;

        public string getsrc() {
            return src;
        }

        public void setsrc(string src) {
            this.src = src;
        }

        public string gettgt() {
            return tgt;
        }

        public void settgt(string tgt) {
            this.tgt = tgt;
        }
    }

}

步骤3：创建 用于描述网络请求 的接口

采用 注解 描述 网络请求参数。

postrequest_interface.java

public interface postrequest_interface {

    @post("translate?doctype=json&jsonversion=&type=&keyfrom=&model=&mid=&imei=&vendor=&screen=&ssid=&network=&abtest=")
    @formurlencoded
    call<translation1> getcall(@field("i") string targetsentence);
    //采用@post表示post方法进行请求（传入部分url地址）
    // 采用@formurlencoded注解的原因:api规定采用请求格式x-www-form-urlencoded,即表单形式
    // 需要配合@field 向服务器提交需要的字段
}

接下来的步骤均在postrequest.java内实现（看注释）

步骤4：创建retrofit对象
步骤5：创建 网络请求接口 的实例
步骤6：发送网络请求

以最常用的 异步请求 为例

步骤7：处理返回数据

postrequest.java

public class postrequest extends appcompatactivity {

    @override
    protected void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        setcontentview(r.layout.activity_main);

        request();
    }
    public void request() {

        //步骤4:创建retrofit对象
        retrofit retrofit = new retrofit.builder()
                .baseurl("http://fanyi.youdao.com/") // 设置 网络请求 url
                .addconverterfactory(gsonconverterfactory.create()) //设置使用gson解析(记得加入依赖)
                .build();

        // 步骤5:创建 网络请求接口 的实例
        postrequest_interface request = retrofit.create(postrequest_interface.class);

        //对 发送请求 进行封装(设置需要翻译的内容)
        call<translation1> call = request.getcall("i love you");

        //步骤6:发送网络请求(异步)
        call.enqueue(new callback<translation1>() {

            //请求成功时回调
            @override
            public void onresponse(call<translation1> call, response<translation1> response) {
                // 步骤7：处理返回的数据结果：输出翻译的内容
                system.out.println(response.body().gettranslateresult().get(0).get(0).gettgt());
            }

            //请求失败时回调
            @override
            public void onfailure(call<translation1> call, throwable throwable) {
                system.out.println("请求失败");
                system.out.println(throwable.getmessage());
            }
        });
    }

}

由于此处采用了 gson 解析，所以需要在 gradle 加入依赖
build.gradle

compile 'com.squareup.retrofit2:converter-gson:2.0.2'

运行结果

demo地址

carson_ho的github：https://github.com/carson-ho/retrofitdemo

---

5. retrofit 的拓展使用

• retrofit的使用场景非常丰富，如支持rxjava和prototocobuff
• 具体设置也非常简单 & 方便：

<-- 主要在创建retrofit对象中设置 -->
retrofit retrofit = new retrofit.builder()
  .baseurl(""http://fanyi.youdao.com/"")
  .addconverterfactory(protoconverterfactory.create()) // 支持prototocobuff解析
  .addconverterfactory(gsonconverterfactory.create()) // 支持gson解析
  .addcalladapterfactory(rxjavacalladapterfactory.create()) // 支持rxjava
  .build();

如对本文有疑问， 点击进行留言回复！！