Building a RESTful API is an essential skill in modern web development, and leveraging AI tools like ChatGPT can significantly speed up the development process. This article walks you through creating a RESTful API using Spring Boot, Gradle, and deploying it to Heroku, with detailed coding examples.

Setting Up the Project

Before diving into the code, ensure you have the necessary prerequisites installed:

• Java (JDK 17+ recommended)
• Gradle
• Spring Boot
• Heroku CLI
• Git

To set up a new Spring Boot project using Gradle, run:

spring init --name=restful-api --type=gradle -d web restful-api
cd restful-api

This initializes a Spring Boot project with the necessary Gradle configurations.

Configuring build.gradle

Modify the build.gradle file to include the required dependencies:

plugins {
    id 'org.springframework.boot' version '3.0.0'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

This setup ensures that Spring Boot and its dependencies are properly configured for web development.

Creating the Model Class

Create a simple model class representing a resource. In this case, let’s create a User model:

package com.example.restfulapi.model;

public class User {
    private Long id;
    private String name;
    private String email;

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

This class will serve as the foundation for the API’s response data.

Creating the Controller

The controller will handle API requests and return responses:

package com.example.restfulapi.controller;

import com.example.restfulapi.model.User;
import org.springframework.web.bind.annotation.*;
import java.util.*;

@RestController
@RequestMapping("/api/users")
public class UserController {
    private List<User> users = new ArrayList<>(List.of(
            new User(1L, "John Doe", "john@example.com"),
            new User(2L, "Jane Doe", "jane@example.com")
    ));

    @GetMapping
    public List<User> getUsers() {
        return users;
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return users.stream().filter(user -> user.getId().equals(id)).findFirst()
                .orElseThrow(() -> new RuntimeException("User not found"));
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        users.add(user);
        return user;
    }
}

This controller exposes three endpoints:

• GET /api/users to fetch all users
• GET /api/users/{id} to fetch a specific user
• POST /api/users to create a new user

Running the Application

To start the Spring Boot application, run:

./gradlew bootRun

You should see the application running at http://localhost:8080/api/users.

Testing the API

You can test the API using curl or Postman:

curl -X GET http://localhost:8080/api/users

To create a new user:

curl -X POST -H "Content-Type: application/json" \
     -d '{"id":3, "name":"Alice", "email":"alice@example.com"}' \
     http://localhost:8080/api/users

Deploying to Heroku

First, initialize a Git repository:

git init
git add .
git commit -m "Initial commit"

Then, create a Procfile in the project root:

echo "web: java -jar build/libs/restful-api-0.0.1-SNAPSHOT.jar" > Procfile

Build the project:

./gradlew build

Create a Heroku app and deploy:

heroku create restful-api-demo
heroku buildpacks:set heroku/jvm
heroku deploy:jar build/libs/restful-api-0.0.1-SNAPSHOT.jar

Your API will be live at https://restful-api-demo.herokuapp.com/api/users.

Conclusion

Creating a RESTful API using Spring Boot, Gradle, and deploying it to Heroku is a powerful and efficient way to develop scalable web services. With the help of ChatGPT, developers can accelerate their workflow by generating boilerplate code, debugging issues, and improving documentation.

Spring Boot simplifies RESTful API development by providing built-in support for web applications, while Gradle makes dependency management seamless. Hosting the API on Heroku ensures easy scalability and accessibility without the need for extensive server management.

By following this guide, you have built a functional API from scratch, configured it properly, and successfully deployed it to a live environment. This setup can be extended further by integrating databases, adding authentication, and implementing more complex business logic.

The combination of AI-powered coding assistance, modern frameworks, and cloud deployment platforms makes API development faster, more efficient, and highly maintainable. Whether you’re an experienced developer or a beginner, leveraging these tools can significantly boost your productivity and allow you to focus on building innovative solutions.