Retrofit 2 Tutorial

Retrofit is one of the most popular REST client library for android developed by Square . For HTTP requests, retrofit uses OkHttp library. Also we can process the return values easily using custom converters. Following converters are supported by Retrofit : 

Gson: com.squareup.retrofit2:converter-gson

Jackson: com.squareup.retrofit2:converter-jackson

Moshi: com.squareup.retrofit2:converter-moshi

Protobuf: com.squareup.retrofit2:converter-protobuf

Wire: com.squareup.retrofit2:converter-wire

Simple XML: com.squareup.retrofit2:converter-simplexml

Scalars (primitives, boxed, and String): com.squareup.retrofit2:converter-scalars

In this tutorial, we will make one request to the Github Api,GET THE RETURN JSON VALUES using retrofit , and finally we will convert these json values using json converter.

API Request :
As mentioned above, we are making a request to GitHub public api to get list of all repositories.

Response Type : 

Response type will be JSON. You can use online JSON Viewer tool like this to see how it looks like.

retrofit

JSON Objects are written inside curly braces “{}” and JSON arrays are written inside square brackets “[]” . i.e. our return type is a JSON array containing JSON objects. 

Each JSON objects looks like :

 retrofit_tutorial

 
We will extract only “name” of each JSON object. 
  1. Create a simple Android application on Android Studio.
  2. Gradle Dependencies : Add the following dependencies to your build.gradle file :

    compile 'com.google.code.gson:gson:2.6.2'
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
  3. Add internet permission inside your AndroidManifest.xml file :
    <uses-permission android:name="android.permission.INTERNET"/>
  4.  We need 3 classes mainly to work with Retrofit :
    1. One Model class to map JSON data.
    2. One Interface class to define network operations.
    3. One instance of Retrofit.Builder class . This instance will use the instance of the interface class to make a call. 
  1. Model Class:
    Create one class GitRepoModel.java as below :

    import com.google.gson.annotations.SerializedName;
    
    public class GitRepoModel {
        @SerializedName("name")
        private String name;
    
        public String getName(){
            return name;
        }
    }

     As we are getting only “name” of each JSON object, only one variable is defined here.

  2. Interface Class :
    Create one Interface class as APIService.java as below :

    import java.util.List;
    
    import retrofit2.Call;
    import retrofit2.http.GET;
    import retrofit2.http.Path;
    
    
    public interface APIService {
    
        @GET("users/{user}/repos")
        Call<List<GitRepoModel>> getRepos(@Path("user") String user);
    }

     Note : As we are getting an array of JSON Objects, "List<GitRepoModel>"is used in this example.

  3. Change your MainActivity.java as below  :

    public class MainActivity extends AppCompatActivity implements Callback<List<GitRepoModel>> {
        private static final String ENDPOINT = "http://api.github.com/";
        private static final String TAG = "RETRODEMO";
        
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            Gson gson = new GsonBuilder()
                    .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
                    .create();
    
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(ENDPOINT)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .build();
    
            APIService githubUserAPI = retrofit.create(APIService.class);
    
            Call<List<GitRepoModel>> call = githubUserAPI.getRepos("codevscolor");
    
            //asynchronous call
            call.enqueue(this);
    
        }
    
        @Override
        public void onResponse(Call<List<GitRepoModel>> call, Response<List<GitRepoModel>> response) {
            int code = response.code();
    
            if (code == 200) {
    
                for(int i=0;i< response.body().size();i++){
                    Log.d(TAG,response.body().get(i).getName());
                }
    
            } else {
    
            }
        }
    
    
        @Override
        public void onFailure(Call<List<GitRepoModel>> call, Throwable t) {
       
        }
    }

    a. We are creating a JSON builder first
    b. One Retrofit.builder instance is created with the api endpoint url and adding converter factory as JSON
    c. “Call” object is created from the APIService interface and one HTTP request is made to the remote webserver using enqueue method
    d. We will get the response callback on onResponse method and failure on onFailure method.

  4. Run the project and Check your logs .You will see something as below :

retrofit_demo
All the repository names are extracted from the json response.
You can see that API EndPoint is “http://api.github.com/” and url inside @GET is @GET(“users/{user}/repos”) which makes a combined url http://api.github.com/users/{user}/repos

  So, always remember to end your ENDPOINT Url with “/” and never begin your url inside APIService class with “/” . “call.enqueue(this)” is used to make an asynchronous call. For synchronous, you can use “execute” method. ( but use execute only on background thread)

This project is shared on GitHub

 

Leave a Reply