Spring WebFlux Reactive CRUD REST API Example

package com.gfg.springreactivecrudapp.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 * Represents a User entity.
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Document
public class User {

    @Id
    private String id;
    private String name;
    private String qualification;
    private String gender;
    private int age;
}

package com.gfg.springreactivecrudapp.repository;

import com.gfg.springreactivecrudapp.model.User;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.stereotype.Repository;

/**
 * Repository interface for User entities.
 */
@Repository
public interface UserRepository extends ReactiveCrudRepository<User, String> {
}

package com.gfg.springreactivecrudapp.configuration;

import com.gfg.springreactivecrudapp.model.User;
import com.gfg.springreactivecrudapp.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * Handler class to handle HTTP requests related to User entities.
 */
@Component
public class UserHandler {

    @Autowired
    private UserRepository userRepository;

    /**
     * Retrieve all users.
     */
    public Mono<ServerResponse> getAllUsers(ServerRequest request) {
        Flux<User> users = userRepository.findAll();
        return ServerResponse.ok().body(users, User.class);
    }

    /**
     * Retrieve a user by ID.
     */
    public Mono<ServerResponse> getUserById(ServerRequest request) {
        String userId = request.pathVariable("id");
        Mono<User> userMono = userRepository.findById(userId);
        return userMono.flatMap(user -> ServerResponse.ok().bodyValue(user))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    /**
     * Create a new user.
     */
    public Mono<ServerResponse> createUser(ServerRequest request) {
        Mono<User> userMono = request.bodyToMono(User.class);
        return userMono.flatMap(user -> userRepository.save(user))
                .flatMap(savedUser -> ServerResponse.ok().bodyValue(savedUser));
    }

    /**
     * Update an existing user.
     */
    public Mono<ServerResponse> updateUser(ServerRequest request) {
        String userId = request.pathVariable("id");
        Mono<User> userMono = request.bodyToMono(User.class);
        return userMono.flatMap(user -> {
                    user.setId(userId);
                    return userRepository.save(user);
                }).flatMap(savedUser -> ServerResponse.ok().bodyValue(savedUser))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    /**
     * Delete a user by ID.
     */
    public Mono<ServerResponse> deleteUser(ServerRequest request) {
        String userId = request.pathVariable("id");
        return userRepository.deleteById(userId)
                .then(ServerResponse.ok().build())
                .switchIfEmpty(ServerResponse.notFound().build());
    }
}

package com.gfg.springreactivecrudapp.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;
import static org.springframework.web.reactive.function.server.RequestPredicates.*;

/**
 * Configures the routes for handling HTTP requests related to users.
 */
@Configuration
public class UserRouter {

    @Autowired
    private UserHandler userHandler;

    /**
     * Defines the routes for handling user-related HTTP requests.
     */
    @Bean
    public RouterFunction<ServerResponse> userRoutes() {
        return RouterFunctions
                .route(GET("/users"), userHandler::getAllUsers)
                .andRoute(GET("/users/{id}"), userHandler::getUserById)
                .andRoute(POST("/users"), userHandler::createUser)
                .andRoute(PUT("/users/{id}"), userHandler::updateUser)
                .andRoute(DELETE("/users/{id}"), userHandler::deleteUser);
    }
}

package com.gfg.springreactivecrudapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.mongodb.repository.config.EnableReactiveMongoRepositories;

/**
 * Main class to start the Spring Reactive CRUD application.
 */
@SpringBootApplication
@EnableReactiveMongoRepositories
public class SpringReactiveCrudAppApplication {

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

}