Implementing Annotated Controllers with Spring WebFlux

Spring WebFlux is a powerful framework that provides a non-blocking approach to web development in Java. It leverages reactive programming to create scalable and resilient applications. One of the key features of Spring WebFlux is its support for annotated controllers, which make it easy to map HTTP requests to specific methods.

Setting Up Project Dependencies

To get started with Spring WebFlux, you need to add the necessary dependencies to your project. In this example, we'll be using Maven.

<dependencies>
  <!-- Spring WebFlux -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
  </dependency>
  
  <!-- Other dependencies -->
  ...
</dependencies>

After adding the dependencies, you can create a simple Spring Boot application class to start a web server.

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

Creating Annotated Controllers

Now that the project is set up, let's create an annotated controller. An annotated controller is a class that handles incoming HTTP requests.

@RestController
@RequestMapping("/api")
public class MyController {
  
  @GetMapping("/hello")
  public Mono<String> sayHello() {
    return Mono.just("Hello, World!");
  }
  
  @PostMapping("/user")
  public Mono<User> createUser(@RequestBody User user) {
    // Do something with the user object
    return userRepository.save(user);
  }
  
  @GetMapping("/users")
  public Flux<User> getAllUsers() {
    return userRepository.findAll();
  }
  
  // Other methods...
}

In the example above, we have created a simple controller class called MyController. It has three methods, all of which are annotated with specific HTTP verbs.

The sayHello() method handles HTTP GET requests to the /api/hello endpoint and returns a Mono with the message "Hello, World!".

The createUser() method handles HTTP POST requests to the /api/user endpoint and expects a JSON object in the request body. It saves the user object and returns a Mono with the saved user.

The getAllUsers() method handles HTTP GET requests to the /api/users endpoint and returns a stream of all users from the repository.

Running the Application

With the annotated controller in place, you can now start the Spring WebFlux application and test the endpoints.

$ mvn spring-boot:run

Once the application is running, you can access the endpoints using a tool like cURL or a web browser.

• GET http://localhost:8080/api/hello

  • Response: "Hello, World!"

• POST http://localhost:8080/api/user

  • Request body: JSON User object
  • Response: Saved User object

• GET http://localhost:8080/api/users

  • Response: List of all Users

Conclusion

Using annotated controllers with Spring WebFlux makes it easy to handle HTTP requests and build reactive web applications. We created a simple controller class and mapped various HTTP verbs to methods. By leveraging the power of reactive programming, we can build highly scalable and efficient web applications with Spring WebFlux.