In this tutorial, you will learn how to build CRUD REST APIs using Spring Boot, Spring WebFlux, and MongoDB NoSQL database.
Before implementing this tutorial, make sure that you have installed MongoDB on your machine and MongoDB instance is running.
You may also be interested in Testing Spring WebFlux Reactive CRUD Rest APIs using WebTestClient.
Spring WebFlux Overview
Reactive MongoDB Driver
1. Create Spring Boot Application
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.0.1</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>net.javaguides</groupId>
<artifactId>springboot-webflux-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-webflux-demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
2. Project Structure
3. Configure MongoDB
spring.data.mongodb.uri=mongodb://localhost:27017/ems
4. Create Domain Class
package net.javaguides.springbootwebfluxdemo.entity;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Document(value = "employees")
public class Employee {
@Id
private String id;
private String firstName;
private String lastName;
private String email;
}
5. Creating Repository - EmployeeRepository
package net.javaguides.springbootwebfluxdemo.repository;
import net.javaguides.springbootwebfluxdemo.entity.Employee;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
public interface EmployeeRepository extends ReactiveCrudRepository<Employee, String> {
}
6. Create EmployeeMapper - Map Entity to Dto and Vice Versa
package net.javaguides.springbootwebfluxdemo.mapper;
import net.javaguides.springbootwebfluxdemo.dto.EmployeeDto;
import net.javaguides.springbootwebfluxdemo.entity.Employee;
public class EmployeeMapper {
public static EmployeeDto mapToEmployeeDto(Employee employee){
return new EmployeeDto(
employee.getId(),
employee.getFirstName(),
employee.getLastName(),
employee.getEmail()
);
}
public static Employee mapToEmployee(EmployeeDto employeeDto){
return new Employee(
employeeDto.getId(),
employeeDto.getFirstName(),
employeeDto.getLastName(),
employeeDto.getEmail()
);
}
}
7. Create Service Layer
EmployeeService Interface
package net.javaguides.springbootwebfluxdemo.service;
import net.javaguides.springbootwebfluxdemo.dto.EmployeeDto;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface EmployeeService {
Mono<EmployeeDto> saveEmployee(EmployeeDto employeeDto);
Mono<EmployeeDto> getEmployee(String employeeId);
Flux<EmployeeDto> getAllEmployees();
Mono<EmployeeDto> updateEmployee(EmployeeDto employeeDto, String employeeId);
Mono<Void> deleteEmployee(String employeeId);
}
EmployeeServiceImpl class
package net.javaguides.springbootwebfluxdemo.service.impl;
import lombok.AllArgsConstructor;
import net.javaguides.springbootwebfluxdemo.dto.EmployeeDto;
import net.javaguides.springbootwebfluxdemo.entity.Employee;
import net.javaguides.springbootwebfluxdemo.mapper.EmployeeMapper;
import net.javaguides.springbootwebfluxdemo.repository.EmployeeRepository;
import net.javaguides.springbootwebfluxdemo.service.EmployeeService;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Service
@AllArgsConstructor
public class EmployeeServiceImpl implements EmployeeService {
private EmployeeRepository employeeRepository;
@Override
public Mono<EmployeeDto> saveEmployee(EmployeeDto employeeDto) {
Employee employee = EmployeeMapper.mapToEmployee(employeeDto);
Mono<Employee> savedEmployee = employeeRepository.save(employee);
return savedEmployee
.map((employeeEntity) -> EmployeeMapper.mapToEmployeeDto(employeeEntity));
}
@Override
public Mono<EmployeeDto> getEmployee(String employeeId) {
Mono<Employee> employeeMono = employeeRepository.findById(employeeId);
return employeeMono.map((employee -> EmployeeMapper.mapToEmployeeDto(employee)));
}
@Override
public Flux<EmployeeDto> getAllEmployees() {
Flux<Employee> employeeFlux = employeeRepository.findAll();
return employeeFlux
.map((employee) -> EmployeeMapper.mapToEmployeeDto(employee))
.switchIfEmpty(Flux.empty());
}
@Override
public Mono<EmployeeDto> updateEmployee(EmployeeDto employeeDto, String employeeId) {
Mono<Employee> employeeMono = employeeRepository.findById(employeeId);
return employeeMono.flatMap((existingEmployee) -> {
existingEmployee.setFirstName(employeeDto.getFirstName());
existingEmployee.setLastName(employeeDto.getLastName());
existingEmployee.setEmail(employeeDto.getEmail());
return employeeRepository.save(existingEmployee);
}).map((employee -> EmployeeMapper.mapToEmployeeDto(employee)));
}
@Override
public Mono<Void> deleteEmployee(String employeeId) {
return employeeRepository.deleteById(employeeId);
}
}
8. Create Controller Layer - Reactive REST APIs
package net.javaguides.springbootwebfluxdemo.controller;
import lombok.AllArgsConstructor;
import net.javaguides.springbootwebfluxdemo.dto.EmployeeDto;
import net.javaguides.springbootwebfluxdemo.service.EmployeeService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@RestController
@RequestMapping("api/employees")
@AllArgsConstructor
public class EmployeeController {
private EmployeeService employeeService;
@PostMapping
@ResponseStatus(value = HttpStatus.CREATED)
public Mono<EmployeeDto> saveEmployee(@RequestBody EmployeeDto employeeDto){
return employeeService.saveEmployee(employeeDto);
}
@GetMapping("{id}")
public Mono<EmployeeDto> getEmployee(@PathVariable("id") String employeeId){
return employeeService.getEmployee(employeeId);
}
@GetMapping
public Flux<EmployeeDto> getAllEmployees(){
return employeeService.getAllEmployees();
}
@PutMapping("{id}")
public Mono<EmployeeDto> updateEmployee(@RequestBody EmployeeDto employeeDto,
@PathVariable("id") String employeeId){
return employeeService.updateEmployee(employeeDto, employeeId);
}
@DeleteMapping("{id}")
@ResponseStatus(value = HttpStatus.NO_CONTENT)
public Mono<Void> deleteEmployee(@PathVariable("id") String employeeId){
return employeeService.deleteEmployee(employeeId);
}
}
Comments
Post a Comment
Leave Comment