Building Your First Microservice

Let's build a simple "User Management" microservice using Spring Boot, one of the most popular frameworks for building microservices in Java. This example will show how to create a basic RESTful API for user management.

1. Setting Up Your Development Environment

Before we dive into the code, make sure you have the following installed:

• Java 11 or later
• Maven (a build automation tool)
• Spring Boot (a framework for creating microservices)
• IDE (e.g., IntelliJ IDEA, VSCode)

2. Create a Spring Boot Application

To create a Spring Boot application, you can use Spring Initializr (https://start.spring.io/) to generate the project template.

Choose the following settings:

• Project: Maven Project
• Language: Java
• Spring Boot version: Latest stable version
• Dependencies: Spring Web, Spring Boot DevTools, and Spring Data JPA (for database access)

Once you generate the project, unzip it and open it in your IDE.

3. Create a User Entity

In the src/main/java directory, create a new class called User.java. This class will represent our User entity.

package com.example.userservice.model;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    private Long id;
    private String name;
    private String email;

    // Constructors, Getters, and Setters
    public User() {}

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

    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;
    }
}        

This simple User class will represent a user with an id, name, and email.

4. Create a User Repository

Next, create a repository interface that will allow us to interact with the database. Create a file named UserRepository.java in the same package.

package com.example.userservice.repository;

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

public interface UserRepository extends JpaRepository<User, Long> {
    // We can add custom queries here if needed
}        

This interface extends JpaRepository, which provides methods like save(), findById(), findAll(), and delete(), saving us from writing boilerplate SQL queries.

5. Create the User Service

Now, we need to create a service class that will handle business logic. Create a file named UserService.java.

package com.example.userservice.service;

import com.example.userservice.model.User;
import com.example.userservice.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 void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}        

This service class uses the repository to fetch, create, and delete user records from the database.

6. Create the User Controller

The controller will expose the RESTful API. Create a file named UserController.java in the controller package.

package com.example.userservice.controller;

import com.example.userservice.model.User;
import com.example.userservice.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

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

    @Autowired
    private UserService userService;

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

    @GetMapping("/{id}")
    public Optional<User> getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

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

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}        

This controller exposes a set of CRUD operations:

• GET /users: Retrieve all users.
• GET /users/{id}: Retrieve a user by ID.
• POST /users: Create a new user.
• DELETE /users/{id}: Delete a user by ID.

7. Running the Application

Once the code is in place, run the application using your IDE or with Maven:

mvn spring-boot:run        

The application will start up, and you can test the API endpoints using Postman or cURL.

Conclusion

You’ve just created a simple User Management Microservice using Spring Boot. This microservice provides basic CRUD operations for managing users, and it can be easily scaled and deployed independently in a microservices-based architecture.

Microservices offer a powerful and scalable way to build modern applications by breaking them down into smaller, more manageable services. As your application grows, you can build additional microservices for different functionalities (e.g., payment service, order service) and manage each one independently.

If you're just starting with microservices, building simple projects like this one is a great way to understand the concepts and get hands-on experience.