Retroift初探

2016-08-31 18:25 · 3 min read · android retrofit ·

文章目录

retrofit 初探

引用

maven

1<dependency>
2  <groupId>com.squareup.retrofit2</groupId>
3  <artifactId>retrofit</artifactId>
4  <version>2.1.0</version>
5</dependency>

gradle

1    api 'com.squareup.retrofit2:retrofit:2.1.0'

github

个人意见

其实，最适合使用 retrofit 的是 rest 请求类的交互，如果具体的请求参数是以 url 区分业务逻辑，请求参数通过 json 进行的，那其实 retrofit 不太适用

俗话说，demo 是最好的学习先来看看怎么定义业务逻辑

1public interface GitHubService {
2  @GET("users/{user}/repos")
3  Call<List<Repo>> listRepos(@Path("user") String user);
4}

这里的{user}是一个会在实际使用时会被动态改变的，会根据 String user 中的变量而改变

 1public class RetrofitDemo {
 2  private static OkHttpClient client;
 3
 4    static {
 5        client = new OkHttpClient.Builder()
 6                .addInterceptor(new HttpInterceptor())
 7                .build();
 8    }
 9
10    public static void main(String[] args) throws IOException {
11        Retrofit retrofit = new Retrofit.Builder()
12                .baseUrl("http://127.0.0.1:32001")
13                .addConverterFactory(GsonConverterFactory.create())
14  //              .addConverterFactory(StringConverterFactory.create())
15                .client(client)
16                .build();
17
18        RequestServer requestServer = retrofit.create(RequestServer.class);
19        TestEntity bean = new TestEntity();
20        bean.setTest("text1");
21        Call<ResponseEntity> call = requestServer.post("ping", "test", bean);
22        Response<ResponseEntity> response = call.execute();
23        ResponseEntity body = response.body();
24        System.out.println(body.toString());
25    }
26}

在上述的代码中访问的 url 是 http://127.0.0.1:32001/ping/test 请求的方式是post 返回值是Call<ResponseEntity> 这里的具体访问是框架实现的框架会将请求的 Bean 转换成 Json Post 请求到指定的 url

然后返回值也会被转化成对应的类型这里依赖的是ConverterFactory 这里的使用的GsonConverterFactory 是官方 Demo 中的一个converter

用于实现 bean 到 json 的转化，再将回包转化成 bean 返回

看下GsonConverterFactory的实现

这里其实就 4 个关键方法

 1  @Override
 2  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
 3      Retrofit retrofit) {
 4    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
 5    return new GsonResponseBodyConverter<>(gson, adapter);
 6  }
 7
 8  @Override
 9  public Converter<?, RequestBody> requestBodyConverter(Type type,
10      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
11    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
12    return new GsonRequestBodyConverter<>(gson, adapter);
13  }

1@Override public RequestBody convert(T value) throws IOException {
2    Buffer buffer = new Buffer();
3    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
4    JsonWriter jsonWriter = gson.newJsonWriter(writer);
5    adapter.write(jsonWriter, value);
6    jsonWriter.close();
7    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
8  }

1  @Override public T convert(ResponseBody value) throws IOException {
2  JsonReader jsonReader = gson.newJsonReader(value.charStream());
3    try {
4      return adapter.read(jsonReader);
5    } finally {
6      value.close();
7    }
8  }

前两个方法用于生成 Converter

后面的是 Converter 中的方法用于将 bean 转化成 RequestBody 和将 ResponseBody 转化成 bean

仿照这个自己写一个 Factory StringConverterFactory

 1public final class StringConverterFactory extends Converter.Factory {
 2
 3  public static StringConverterFactory create() {
 4    return new StringConverterFactory();
 5  }
 6
 7  private StringConverterFactory() {
 8  }
 9
10  @Override
11  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
12    return new StringResponseBodyConverter();
13  }
14
15  @Override
16  public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
17    return new StringRequestBodyConverter();
18  }
19}

StringRequestBodyConverter

 1final class StringRequestBodyConverter implements Converter<String, RequestBody> {
 2
 3    StringRequestBodyConverter() {
 4    }
 5
 6    @Override
 7    public RequestBody convert(String s) throws IOException {
 8        return RequestBody.create(MediaType.parse("text/json"), s);
 9    }
10}

StringResponseBodyConverter

 1final class StringResponseBodyConverter implements Converter<ResponseBody, String> {
 2
 3    StringResponseBodyConverter() {
 4    }
 5
 6    @Override
 7    public String convert(ResponseBody value) throws IOException {
 8
 9        try {
10            return value.string();
11        } finally {
12            value.close();
13        }
14    }
15}

其实就是 Factory 中的两个方法控制使用哪个转化器转化两个 Convert 控制怎么转化