Concurrency in Spring Webflux

package com.concurrencyspring.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * The User class is a JPA entity representing the 'user' table in the database.
 * It uses Lombok annotations to generate boilerplate code like getters, setters, constructors, etc.
 */
@Data // Lombok annotation to generate getters, setters, toString, equals, and hashcode methods
@AllArgsConstructor // Lombok annotation to generate a constructor with all arguments
@NoArgsConstructor // Lombok annotation to generate a no-argument constructor
@Entity // Specifies that the class is an entity and is mapped to a database table
public class User {

    @Id // Specifies the primary key of the entity
    @GeneratedValue(strategy = GenerationType.AUTO) // Provides specification for the primary key generation strategy
    private Long id; // The primary key field

    private String name; // The 'name' column in the 'user' table

    private String email; // The 'email' column in the 'user' table
}

package com.concurrencyspring.repository;

import com.concurrencyspring.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * UserRepository is an interface that extends JpaRepository to provide CRUD operations for User entities.
 * This interface will be automatically implemented by Spring Data JPA.
 */
@Repository // Indicates that the interface is a Spring Data repository
public interface UserRepository extends JpaRepository<User, Long> {
    // JpaRepository provides methods for CRUD operations and more
    // User is the type of the entity to handle
    // Long is the type of the entity's identifier
}

package com.concurrencyspring.service;

import com.concurrencyspring.model.User;
import com.concurrencyspring.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

import java.util.Optional;

/**
 * Service class for managing User entities.
 * Provides methods for retrieving and saving users.
 */
@Service // Indicates that this class is a Spring service component
public class UserService {

    @Autowired // Marks a constructor, field, setter method, or config method to be autowired by Spring's dependency injection facilities
    private UserRepository userRepository;

    /**
     * Retrieves a user by its ID.
     *
     * @param id the ID of the user to retrieve
     * @return an Optional containing the user if found, or empty if not found
     */
    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    /**
     * Saves a user entity.
     *
     * @param user the user entity to save
     * @return the saved user entity
     */
    public User saveUser(User user) {
        return userRepository.save(user);
    }
}

package com.concurrencyspring.controller;

import com.concurrencyspring.model.User;
import com.concurrencyspring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

/**
 * UserController is a REST controller for managing User entities.
 * Provides endpoints for retrieving and creating users.
 */
@RestController // Indicates that this class is a REST controller
@RequestMapping("/users") // Maps requests to /users
public class UserController {

    @Autowired // Marks a constructor, field, setter method, or config method to be autowired by Spring's dependency injection facilities
    private UserService userService;

    /**
     * Retrieves a user by its ID.
     *
     * @param id the ID of the user to retrieve
     * @return a Mono containing the user if found, or empty if not found
     */
    @GetMapping("/{id}") // Maps GET requests to /users/{id}
    public Mono<User> getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    /**
     * Creates a new user.
     *
     * @param user the user entity to create
     * @return a Mono containing the created user entity
     */
    @PostMapping // Maps POST requests to /users
    public Mono<User> createUser(@RequestBody User user) {
        return userService.saveUser(user);
    }
}

package com.concurrencyspring;

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

@SpringBootApplication
public class ConcurrencySpringApplication {

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

}