DEV Community: Dhananjay Bagul

Connecting an Android App to a REST API Using Retrofit in Java

Dhananjay Bagul — Sat, 10 Oct 2026 21:13:03 +0000

When building an Android application, we often need to communicate with a backend server to fetch or send data. For example, an HRMS app may need to display employees, a shopping app may need to load products, or a booking app may need to retrieve reservations.

One popular way to make these network requests in Android is Retrofit.

In this article, we will learn how to connect an Android application to a REST API using Java and Retrofit, step by step.

What Is Retrofit?

Retrofit is a type-safe HTTP client for Android and Java. It helps us make API requests without writing all the networking code manually.

With Retrofit, we can:

Send GET requests to fetch data.

Send POST requests to submit data.

Convert JSON responses into Java objects using a converter.

Handle successful responses and network errors.

Keep API-related code organized in a separate interface.

Add Retrofit Dependencies

Open your app-level build.gradle file and add these dependencies inside dependencies:

implementation 'com.squareup.retrofit2:retrofit:2.11.0'
implementation 'com.squareup.retrofit2:converter-gson:2.11.0'

Sync the project after adding them. If your project uses build.gradle.kts, use the Kotlin DSL syntax for dependencies.

Add Internet Permission

Open AndroidManifest.xml and add this permission above the tag:

This permission allows your application to access the internet.

Create a Java Model Class

Suppose our backend returns employee information in JSON format:

{
"id": 1,
"name": "Rahul",
"email": "rahul@example.com"
}

Create a Java class named Employee.java:

public class Employee {

private int id;
private String name;
private String email;

public int getId() {
    return id;
}

public String getName() {
    return name;
}

public String getEmail() {
    return email;
}

}

Gson converts the JSON response into an Employee object when the JSON field names match the Java fields.

Create the API Interface

Create a file named ApiService.java:

import java.util.List;
import retrofit2.Call;
import retrofit2.http.GET;

public interface ApiService {

@GET("api/employees")
Call<List<Employee>> getEmployees();

}

The @get annotation tells Retrofit to send a GET request to the api/employees endpoint.

Replace this endpoint with the path exposed by your own backend API.

Configure Retrofit

Create a class named ApiClient.java:

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class ApiClient {

private static final String BASE_URL =
        "https://your-domain.com/";

private static Retrofit retrofit;

public static ApiService getApiService() {

    if (retrofit == null) {
        retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(
                        GsonConverterFactory.create()
                )
                .build();
    }

    return retrofit.create(ApiService.class);
}

}

Replace https://your-domain.com/ with your backend's base URL. Keep the trailing slash because Retrofit requires the base URL to end with /.

For local testing with the Android emulator, a backend running on your development computer can often be reached using http://10.0.2.2:8080/. Configure local HTTP access appropriately for development, or use HTTPS.

Make an API Request from an Activity

Now, call the API from your Activity:

import android.widget.Toast;
import java.util.List;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

ApiService apiService = ApiClient.getApiService();

apiService.getEmployees().enqueue(
new Callback>() {

@Override
public void onResponse(
        Call<List<Employee>> call,
        Response<List<Employee>> response) {

    if (response.isSuccessful()
            && response.body() != null) {

        List<Employee> employees = response.body();

        // Pass the employee list to your RecyclerView adapter.

    } else {
        Toast.makeText(
                MainActivity.this,
                "Unable to load employees",
                Toast.LENGTH_SHORT
        ).show();
    }
}

@Override
public void onFailure(
        Call<List<Employee>> call,
        Throwable t) {

    Toast.makeText(
            MainActivity.this,
            "Network error: " + t.getMessage(),
            Toast.LENGTH_SHORT
    ).show();
}

});

This example assumes the request is made inside MainActivity. In a real project, keep the networking logic in an appropriate class and update your UI through your chosen architecture.

The important part is enqueue(). It executes the request asynchronously, so the network call does not block the main UI thread.

Connect It to a Spring Boot Backend

If your backend is built with Spring Boot, it might expose an endpoint like this:

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {

@GetMapping
public List<Employee> getEmployees() {
    return employeeService.getAllEmployees();
}

}

The Android endpoint and the Spring Boot route must match. The controller's response should also return JSON in a structure that your Android model can parse.

Once the response arrives, you can pass the employee list to a RecyclerView.Adapter and display each employee inside a card or list item.

Common Mistakes to Avoid

Incorrect base URL: Make sure the server address and endpoint path are correct.

Missing internet permission: Check AndroidManifest.xml if requests never reach the server.

Mismatched JSON fields: Verify that the backend's JSON response matches your model class.

Testing with localhost: The Android emulator's localhost refers to the emulator itself, not your development computer.

Ignoring errors: Handle unsuccessful HTTP responses as well as network failures.

Using insecure production URLs: Prefer HTTPS for production applications and never expose passwords, private keys, or sensitive tokens in source code.

Conclusion

Retrofit makes it easier to connect an Android application to a REST API using Java. By separating the model class, API interface, and Retrofit client, we can keep our code cleaner and easier to maintain.

Whether you are building an HRMS application, an e-commerce app, or a booking system, learning Retrofit is a valuable skill for Android development.

Start with a simple GET request, verify the JSON response, and then move on to POST, PUT, and DELETE operations as your project grows.

What API integration are you working on in your Android project? Share your experience in the comments.

Understanding REST APIs in Java with Spring Boot: A Beginner-Friendly Guide

Dhananjay Bagul — Sat, 10 Oct 2026 03:46:21 +0000

As a Java developer, understanding REST APIs is an important step toward building backend applications. REST APIs allow different applications to communicate with each other and exchange data over HTTP.

In this article, we will understand what REST APIs are, how they work, and how to create a simple REST API using Java and Spring Boot.

What Is a REST API?

REST stands for Representational State Transfer. A REST API allows clients, such as Android applications, web applications, or other services, to communicate with a server using HTTP requests.

For example, an Android HRMS application might need to retrieve employee information from a backend server. The Android application sends a request to a REST API, and the server returns the requested data.

A typical API response may look like this:

{
"id": 1,
"name": "Rahul",
"department": "IT"
}

JSON is commonly used to exchange data between clients and servers.

Common HTTP Methods

REST APIs commonly use the following HTTP methods:

GET — Retrieve data.

POST — Create a new resource.

PUT — Update an existing resource.

PATCH — Partially update a resource.

DELETE — Delete a resource.

For example, an employee management application may use these endpoints:

Method

Endpoint

Purpose

GET

/api/employees

Retrieve employees

GET

/api/employees/1

Retrieve one employee

POST

/api/employees

Create an employee

PUT

/api/employees/1

Update an employee

DELETE

/api/employees/1

Delete an employee

The actual behavior depends on how the backend implements each endpoint.

Why Use Spring Boot?

Spring Boot simplifies Java application development by providing auto-configuration, starter dependencies, and an embedded web server.

For REST API development, the spring-boot-starter-web dependency provides the web framework features needed to create controllers and handle HTTP requests.

You can create a project using Spring Initializr:

https://start.spring.io/

Select Java, choose a compatible Spring Boot version, and add the Spring Web dependency.

Create a Simple REST API

Let's create a basic endpoint that returns a welcome message.

Create a controller class:

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

@GetMapping("/api/hello")
public String hello() {
    return "Welcome to my first REST API!";
}

}

Understanding the Code

@RestController

This annotation marks the class as a REST controller. Return values are written to the HTTP response body.

@GetMapping("/api/hello")

This maps HTTP GET requests to the /api/hello endpoint.

hello()

This method returns a simple text response when the endpoint is requested.

Run the Spring Boot application. If it starts successfully on the default port, open:

http://localhost:8080/api/hello

You should see:

Welcome to my first REST API!

Test the API Using Postman

Postman is a useful tool for testing REST APIs without building a frontend first.

Follow these steps:

Open Postman.

Create a new HTTP request.

Select the GET method.

Enter http://localhost:8080/api/hello.

Click Send.

The response body should contain the welcome message.

You can also inspect the HTTP status code, response headers, and request details.

How an Android App Uses a REST API

REST APIs are particularly useful when developing Android applications.

A typical request flow looks like this:

The user opens an Android screen.

The Android application sends an HTTP request to the backend.

The Spring Boot server processes the request.

The server returns a response, often in JSON format.

The Android application reads the response and updates the user interface.

Libraries such as Retrofit can simplify HTTP communication in Android applications.

For example, an HRMS mobile application can use REST APIs to retrieve employee profiles, attendance information, or other employee-related data.

Best Practices for REST API Development

Keep these principles in mind when developing backend APIs:

Use clear and consistent endpoint names.

Choose suitable HTTP methods and status codes.

Validate incoming request data.

Handle errors with meaningful responses.

Keep controller and business logic appropriately separated.

Avoid exposing passwords, private information, or internal server details.

Test successful requests and failure scenarios with Postman.

Use authentication and authorization for protected resources.

For larger applications, a layered architecture with controller, service, and repository components can help keep the code organized and maintainable.

Conclusion

REST APIs are an essential part of modern backend development. Java and Spring Boot provide a practical foundation for creating APIs that connect Android applications, web applications, databases, and other services.

Start with simple GET endpoints, learn how POST and PUT requests work, and then practise building CRUD APIs with proper validation, database integration, and error handling.

Consistent practice with Java, Spring Boot, REST APIs, MySQL, and Postman can help you develop the skills needed to build real-world backend applications.

java #springboot #restapi #beginners #backend