Retrofit turns your HTTP API into a Java interface.
public interface GitHubService { @GET("users/{user}/repos") Call<List<Repo>> listRepos(@Path("user") String user); }
The Retrofit
class generates an implementation of the GitHubService
interface.
Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.github.com/") .build(); GitHubService service = retrofit.create(GitHubService.class);
Each Call
from the created GitHubService
can make a synchronous or asynchronous HTTP request to the remote webserver.
Call<List<Repo>> repos = service.listRepos("octocat");
Use annotations to describe the HTTP request:
Annotations on the interface methods and its parameters indicate how a request will be handled.
Every method must have an HTTP annotation that provides the request method and relative URL. There are eight built-in annotations: HTTP
, GET
, POST
, PUT
, PATCH
, DELETE
, OPTIONS
and HEAD
. The relative URL of the resource is specified in the annotation.
@GET("users/list")
You can also specify query parameters in the URL.
@GET("users/list?sort=desc")
A request URL can be updated dynamically using replacement blocks and parameters on the method. A replacement block is an alphanumeric string surrounded by {
and }
. A corresponding parameter must be annotated with @Path
using the same string.
@GET("group/{id}/users") Call<List<User>> groupList(@Path("id") int groupId);
Query parameters can also be added.
@GET("group/{id}/users") Call<List<User>> groupList(@Path("id") int groupId, @Query("sort") String sort);
For complex query parameter combinations a Map
can be used.
@GET("group/{id}/users") Call<List<User>> groupList(@Path("id") int groupId, @QueryMap Map<String, String> options);
An object can be specified for use as an HTTP request body with the @Body
annotation.
@POST("users/new") Call<User> createUser(@Body User user);
The object will also be converted using a converter specified on the Retrofit
instance. If no converter is added, only RequestBody
can be used.
Methods can also be declared to send form-encoded and multipart data.
Form-encoded data is sent when @FormUrlEncoded
is present on the method. Each key-value pair is annotated with @Field
containing the name and the object providing the value.
@FormUrlEncoded @POST("user/edit") Call<User> updateUser(@Field("first_name") String first, @Field("last_name") String last);
Multipart requests are used when @Multipart
is present on the method. Parts are declared using the @Part
annotation.
@Multipart @PUT("user/photo") Call<User> updateUser(@Part("photo") RequestBody photo, @Part("description") RequestBody description);
Multipart parts use one of Retrofit
's converters or they can implement RequestBody
to handle their own serialization.
You can set static headers for a method using the @Headers
annotation.
@Headers("Cache-Control: max-age=640000") @GET("widget/list") Call<List<Widget>> widgetList();
@Headers({ "Accept: application/vnd.github.v3.full json", "User-Agent: Retrofit-Sample-App" }) @GET("users/{username}") Call<User> getUser(@Path("username") String username);
Note that headers do not overwrite each other. All headers with the same name will be included in the request.
A request Header can be updated dynamically using the @Header
annotation. A corresponding parameter must be provided to the @Header
. If the value is null, the header will be omitted. Otherwise, toString
will be called on the value, and the result used.
@GET("user") Call<User> getUser(@Header("Authorization") String authorization)
Similar to query parameters, for complex header combinations, a Map
can be used.
@GET("user") Call<User> getUser(@HeaderMap Map<String, String> headers)
Headers that need to be added to every request can be specified using an OkHttp interceptor.
Call
instances can be executed either synchronously or asynchronously. Each instance can only be used once, but calling clone()
will create a new instance that can be used.
On Android, callbacks will be executed on the main thread. On the JVM, callbacks will happen on the same thread that executed the HTTP request.
Interface methods support kotlin suspend functions which directly return a Response
object, creating and asynchronously executing the call while suspending the current function.
@GET("users") suspend fun getUser(): Response<User>
A suspend method may also directly return the body. If a non-2XX status is returned an HttpException
will be thrown containing the response.
@GET("users") suspend fun getUser(): User
Retrofit
is the class through which your API interfaces are turned into callable objects. By default, Retrofit will give you sane defaults for your platform but it allows for customization.
By default, Retrofit can only deserialize HTTP bodies into OkHttp's ResponseBody
type and it can only accept its RequestBody
type for @Body
.
Converters can be added to support other types. Sibling modules adapt popular serialization libraries for your convenience.
com.squareup.retrofit2:converter-gson
com.squareup.retrofit2:converter-jackson
com.squareup.retrofit2:converter-moshi
com.squareup.retrofit2:converter-protobuf
com.squareup.retrofit2:converter-wire
com.squareup.retrofit2:converter-simplexml
com.squareup.retrofit2:converter-jaxb
com.squareup.retrofit2:converter-scalars
Here's an example of using the GsonConverterFactory
class to generate an implementation of the GitHubService
interface which uses Gson for its deserialization.
Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://api.github.com/") .addConverterFactory(GsonConverterFactory.create()) .build(); GitHubService service = retrofit.create(GitHubService.class);
If you need to communicate with an API that uses a content-format that Retrofit does not support out of the box (e.g. YAML, txt, custom format) or you wish to use a different library to implement an existing format, you can easily create your own converter. Create a class that extends the Converter.Factory
class and pass in an instance when building your adapter.
The source code to the Retrofit, its samples, and this website is available on GitHub.
<dependency>
<groupId>com.squareup.retrofit2</groupId>
<artifactId>retrofit</artifactId>
<version>(insert latest version)</version>
</dependency>
implementation 'com.squareup.retrofit2:retrofit:(insert latest version)'
Retrofit requires at minimum Java 8 or Android API 21 .
If you are using R8 the shrinking and obfuscation rules are included automatically.
ProGuard users must manually add the options from retrofit2.pro.
You might also need rules for OkHttp and Okio which are dependencies of this library.
If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request.
When submitting code, please make every effort to follow existing conventions and style in order to keep the code as readable as possible. Please also make sure your code compiles by running ./gradlew build
(or gradlew.bat build
for Windows).
Before your code can be accepted into the project you must also sign the Individual Contributor License Agreement (CLA).
Copyright 2013 Square, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.