Step-by-Step Guide to Creating RESTful APIs in Spring Boot ~ Coding Workspace

To create RESTful APIs in Java using Spring Boot for Android apps, we will walk through a detailed example, focusing only on the Java (Spring Boot) side of things. We'll build a simple User Management API, where we can create, read, update, and delete users.

Step-by-Step Guide to Creating RESTful APIs in Spring Boot

1. Create a Spring Boot Project

First, you need to set up a Spring Boot project. You can generate the skeleton using Spring Initializr or manually create the project in your IDE.

Here are the dependencies you’ll need:

Spring Web: For creating REST APIs.
Spring Data JPA: For database interaction.
H2 Database (or any other DB of your choice): For persistence (for simplicity, we’ll use H2 in-memory DB).

Generate the project, download the ZIP, unzip it, and open it in your IDE.

2. Project Structure

After setting up your project, the structure will look something like this:

src/
 └── main/
      ├── java/
      │    └── com/
      │         └── example/
      │             └── usermanagement/
      │                  ├── UserApplication.java
      │                  ├── controller/
      │                  │    └── UserController.java
      │                  ├── model/
      │                  │    └── User.java
      │                  ├── repository/
      │                  │    └── UserRepository.java
      │                  └── service/
      │                       └── UserService.java
      └── resources/
           ├── application.properties

3. Set Up the Database (H2 for this example)

In src/main/resources/application.properties, configure the H2 database:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

This configuration sets up an in-memory H2 database that will automatically be cleared when the application stops.

4. Model Class (`User.java`)

Create the User entity class that will represent the users in the database.

package com.example.usermanagement.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Default constructor
    public User() {}

    // Constructor with fields
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

5. Repository Class (`UserRepository.java`)

The UserRepository will interact with the database to perform CRUD operations. This interface extends JpaRepository for built-in CRUD functionality.

package com.example.usermanagement.repository;

import com.example.usermanagement.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    // Custom query methods can go here (if needed)
}

6. Service Class (`UserService.java`)

The UserService class contains the business logic. It uses the repository to interact with the database.

package com.example.usermanagement.service;

import com.example.usermanagement.model.User;
import com.example.usermanagement.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User user) {
        if (userRepository.existsById(id)) {
            user.setId(id);
            return userRepository.save(user);
        }
        return null;
    }

    public boolean deleteUser(Long id) {
        if (userRepository.existsById(id)) {
            userRepository.deleteById(id);
            return true;
        }
        return false;
    }
}

7. Controller Class (`UserController.java`)

The UserController class exposes the RESTful API endpoints to the clients (in this case, the Android app).

package com.example.usermanagement.controller;

import com.example.usermanagement.model.User;
import com.example.usermanagement.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    // Get all users
    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    // Get a user by id
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userService.getUserById(id);
        return user.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }

    // Create a new user
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User createdUser = userService.createUser(user);
        return new ResponseEntity<>(createdUser, HttpStatus.CREATED);
    }

    // Update an existing user
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        User updatedUser = userService.updateUser(id, user);
        return updatedUser != null ? ResponseEntity.ok(updatedUser) : ResponseEntity.notFound().build();
    }

    // Delete a user by id
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        return userService.deleteUser(id) ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
    }
}

8. Main Application Class (`UserApplication.java`)

This is the entry point of the Spring Boot application.

package com.example.usermanagement;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class UserApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class, args);
    }
}

9. Run the Application

To run your Spring Boot application, use the following command:

mvn spring-boot:run

This will start the application, and the RESTful API will be available at http://localhost:8080/api/users.

Example API Requests

Get all users:
GET http://localhost:8080/api/users
Get user by ID:
GET http://localhost:8080/api/users/{id}

Create a new user:
POST http://localhost:8080/api/users
Request body:

{
  "name": "John Doe",
  "email": "john.doe@example.com"
}

Update a user:
PUT http://localhost:8080/api/users/{id}
Request body:

{
  "name": "Johnathan Doe",
  "email": "johnathan.doe@example.com"
}

Delete a user:
DELETE http://localhost:8080/api/users/{id}

Summary

This example shows how to build a RESTful API using Spring Boot to handle basic CRUD operations for user management. Any frontend, including Android apps, can consume the API by making HTTP requests to the specified endpoints. You can expand this by adding authentication, validation, and more complex business logic as needed.

Coding Workspace

All programing code in one workspace