Spring Boot 4 Microservices & REST APIs: Your Getting Started Guide (Part 1/5)

Spring Boot 4 Microservices & REST APIs: Your Getting Started Guide (Part 1/5)

Hello, aspiring developers and seasoned pros alike! Welcome to CoddyKit's exciting new series: "Spring Boot 4 Microservices & REST APIs." In an era where agility, scalability, and resilience are paramount for software systems, microservices have emerged as a dominant architectural pattern. When combined with the unparalleled productivity of Spring Boot – which, by its fourth major iteration, continues to redefine rapid application development – you get a powerhouse combination for building modern, distributed systems.

This five-part series will guide you through the journey of mastering Spring Boot 4 for microservices. We'll start from the very basics, explore best practices, troubleshoot common pitfalls, dive into advanced techniques, and peek into the future of this dynamic ecosystem.

In this first post, we’ll lay the foundational bricks. We’ll demystify microservices, understand why Spring Boot is the ideal companion for them, and then roll up our sleeves to build our very first Spring Boot 4 microservice with a simple REST API. Let's dive in!

What Exactly Are Microservices?

Microservices represent an architectural style that structures an application as a collection of small, independent, and loosely coupled services. Each service runs in its own process and communicates with lightweight mechanisms, often an HTTP resource API.

Key characteristics and benefits include:

• Independence: Services can be developed, deployed, and scaled independently.
• Focus: Each service is responsible for a single, well-defined business capability.
• Technology Diversity: Different services can use different technologies best suited for their specific needs.
• Resilience: The failure of one service is less likely to impact the entire system.

This contrasts with monolithic applications, where all components are tightly coupled into a single unit, often leading to challenges in scalability, maintenance, and agility as the application grows.

Why Spring Boot for Microservices?

Spring Boot has become the de-facto standard for building Java-based microservices, and Spring Boot 4 continues to enhance this experience. Here's why it's a perfect match:

• Rapid Development: Spring Boot’s "opinionated" approach drastically reduces boilerplate code and configuration, allowing you to get a service up and running in minutes.
• Embedded Servers: It bundles embedded servers (Tomcat, Jetty, Undertow), enabling standalone, self-contained JARs that simplify deployment.
• Auto-configuration: Intelligently configures your application based on classpath dependencies, minimizing manual setup.
• Production Readiness: Provides out-of-the-box features like health checks, metrics, and externalized configuration, vital for microservices in production.
• Robust REST Support: Building powerful and flexible RESTful APIs is straightforward with Spring Web.

Getting Started: Your First Spring Boot 4 Microservice

Enough talk, let's build! We'll create a simple "Hello World" microservice with a REST endpoint.

Prerequisites

Before you begin, ensure you have JDK 17 or newer, Maven or Gradle, and an IDE (IntelliJ IDEA, Eclipse with Spring Tools 4, or VS Code) installed.

Project Setup with Spring Initializr

The easiest way to start a Spring Boot project is by using the Spring Initializr. It's a web-based tool that generates a basic project structure for you.

1. Open your web browser and navigate to https://start.spring.io/.
2. Configure your project:
   • Project: Maven Project, Language: Java, Spring Boot: Select the latest stable version (e.g., 3.x.x, for this series we'll imagine 4.0.0-SNAPSHOT).
   • Group: com.coddykit, Artifact: hello-service.
   • Dependencies: Add Spring Web and optionally Lombok.
3. Click the "Generate" button, download the ZIP, and import the project into your IDE.

Creating a Simple REST API Endpoint

Your generated project includes a main application class (e.g., HelloServiceApplication.java). Now, create a new Java class named HelloController.java in a new package called controller (e.g., com.coddykit.helloservice.controller).

package com.coddykit.helloservice.controller;

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

@RestController // Marks this class as a REST controller
@RequestMapping("/api/v1/hello") // Base path for all endpoints in this controller
public class HelloController {

    @GetMapping // Handles GET requests to /api/v1/hello
    public String sayHello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello, %s! Welcome to CoddyKit's Spring Boot 4 Microservices.", name);
    }
}

The @RestController annotation indicates that the class is a controller where every method returns a domain object directly to the web response body. @RequestMapping defines the base URI path, and @GetMapping maps HTTP GET requests. @RequestParam binds a query parameter to a method parameter.

Running and Testing Your Microservice

To run your application, right-click on HelloServiceApplication.java in your IDE and select "Run...". Spring Boot will start on port 8080 by default. Open your web browser or a tool like Postman and navigate to:

• http://localhost:8080/api/v1/hello
• http://localhost:8080/api/v1/hello?name=Coddy

You should see your personalized greeting! Congratulations, you've just built and run your first Spring Boot 4 microservice!

Building a Product Service: CRUD Operations

Let's expand our knowledge by creating a simple "Product" microservice that manages a list of products. We'll implement basic CRUD (Create, Read, Update, Delete) operations. For simplicity, we'll store products in an in-memory list.

1. Product Model

First, let's define our Product data structure. Create a new package named model (e.g., com.coddykit.helloservice.model) and add Product.java. We'll use Lombok annotations for brevity:

package com.coddykit.helloservice.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data // Generates getters, setters, toString, equals, hashCode
@NoArgsConstructor // Generates a no-argument constructor
@AllArgsConstructor // Generates a constructor with all fields
public class Product {
    private String id;
    private String name;
    private double price;
    private String description;
}

2. Product Controller

Next, create a new Java class named ProductController.java in the com.coddykit.helloservice.controller package:

package com.coddykit.helloservice.controller;

import com.coddykit.helloservice.model.Product;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;

@RestController
@RequestMapping("/api/v1/products")
public class ProductController {

    private final List<Product> products = new ArrayList<>();
    private final AtomicLong counter = new AtomicLong();

    public ProductController() {
        // Initialize with some dummy data
        products.add(new Product("P001", "Laptop Pro", 1200.00, "High-performance laptop"));
        products.add(new Product("P002", "Mechanical Keyboard", 150.00, "Gaming keyboard"));
    }

    @GetMapping // GET /api/v1/products
    public List<Product> getAllProducts() {
        return products;
    }

    @GetMapping("/{id}") // GET /api/v1/products/{id}
    public ResponseEntity<Product> getProductById(@PathVariable String id) {
        return products.stream()
                .filter(p -> p.getId().equals(id))
                .findFirst()
                .map(ResponseEntity::ok)
                .orElseGet(() -> ResponseEntity.notFound().build());
    }

    @PostMapping // POST /api/v1/products
    public ResponseEntity<Product> addProduct(@RequestBody Product newProduct) {
        String newId = "P" + String.format("%03d", counter.incrementAndGet());
        newProduct.setId(newId);
        products.add(newProduct);
        return new ResponseEntity<>(newProduct, HttpStatus.CREATED);
    }

    @PutMapping("/{id}") // PUT /api/v1/products/{id}
    public ResponseEntity<Product> updateProduct(@PathVariable String id, @RequestBody Product updatedProduct) {
        Optional<Product> existingProductOpt = products.stream()
                .filter(p -> p.getId().equals(id))
                .findFirst();

        if (existingProductOpt.isPresent()) {
            Product existingProduct = existingProductOpt.get();
            existingProduct.setName(updatedProduct.getName());
            existingProduct.setPrice(updatedProduct.getPrice());
            existingProduct.setDescription(updatedProduct.getDescription());
            return ResponseEntity.ok(existingProduct);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}") // DELETE /api/v1/products/{id}
    public ResponseEntity<Void> deleteProduct(@PathVariable String id) {
        boolean removed = products.removeIf(p -> p.getId().equals(id));
        return removed ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
    }
}

Here, @PathVariable extracts values from the URI path, and @RequestBody deserializes the HTTP request body into a Java object. ResponseEntity<T> allows fine-grained control over the HTTP response, including status codes (e.g., 200 OK, 201 Created, 404 Not Found, 204 No Content).

Testing the Product Service

Restart your HelloServiceApplication. Now you can interact with your Product microservice using tools like Postman, Insomnia, or cURL:

• GET All Products:

  GET http://localhost:8080/api/v1/products

• GET Product by ID:

  GET http://localhost:8080/api/v1/products/P001

• Add a Product (POST):

  POST http://localhost:8080/api/v1/products
  Content-Type: application/json
  
  {
      "name": "External Monitor",
      "price": 300.00,
      "description": "27-inch 4K monitor"
  }

• Update a Product (PUT):

  PUT http://localhost:8080/api/v1/products/P001
  Content-Type: application/json
  
  {
      "id": "P001",
      "name": "Laptop Pro Max",
      "price": 1350.00,
      "description": "Ultimate high-performance laptop"
  }

• Delete a Product (DELETE):

  DELETE http://localhost:8080/api/v1/products/P002

Conclusion

Phew! You've just taken your first significant steps into the world of Spring Boot 4 Microservices and REST APIs. In this introductory guide, we've covered:

• The core concepts and benefits of microservices architecture.
• Why Spring Boot is an exceptional framework for building these services.
• How to set up a new Spring Boot project using Spring Initializr.
• How to create and test simple REST API endpoints using @RestController, @GetMapping, @PostMapping, @PutMapping, and @DeleteMapping.
• The basics of creating a data model with Lombok and handling HTTP requests and responses.

This is just the beginning! In the next post of this series, we'll dive deeper into best practices and essential tips for building robust, maintainable, and scalable Spring Boot microservices. Get ready to refine your skills and make your microservices truly shine.

Keep coding, and see you in the next one!