clientID

clientSecret

Gain insights into building e-commerce apps using Spring Boot and reactive programming. Learn about WebFlux, MongoDB, hypermedia APIs, RSockets, OpenID, and testing methodologies.

tarball.tar.gz

Run spring

ch1 run

ch1 run-test

PoliteRestaurant

PoliteRestaurant-copy

sdk-copy

operations with spring boot

operations with spring boot-dockerbuild

operations with spring boot-spring-boot:build-image

operations with spring boot-run

operations with spring boot-prepare_package

ch1 run-blockhound

rserver-run

rserver-rclient-run

9_quick

9_repo

9_custom_config

9_method_security

rserver-rclient-run-marvah

operations with spring boot-run-old-for-creating-API

operations with spring boot-run-old-for-creating-API-copy-faizan-way-correct

operations with spring boot-prepare_package-tmux-test

rserver-rclient-run-copy

rserver-rclient-run-copy-testing

rserver-rclient-run-copy-testing-copy

9_custom_config-added_user

9_oauth

packge-command

operations with spring boot clean package

9_oauth-copy-test

ch1 run-reactor tools

ch1 run-copy-watcher

rserver-rclient-run-copy-testing-channel-curl

search

In this course, you will learn about the Spring Boot framework and build an e-commerce web application using reactive programming. You will find that some of the newest ideas in Spring Boot are applied to some well-seasoned favorite problems that Java developers have experience with.

The course approaches these old problems with new concepts and more efficient tools. You’ll learn reactive programming, WebFlux, and the basic project structure of a Spring Boot application. Next, you’ll cover data access with MongoDB, developer tools, and testing applications with Spring Boot. Then, you’ll learn the operational features, building hypermedia APIs, reactive streams, messaging,  RSockets, and OpenID, all from the most pragmatic standpoints.

After finishing the course, you'll be able to build state of the art web applications using Spring Boot and MongoDB. You'll also learn the art of writing test cases, become proficient in building APIs, and much more.

Build E-Commerce Apps with Reactive Programming in Spring Boot

With everything in place, it’s time to determine what our system will do. We’re talking about an asynchronous message solution. A simple thing to implement would be receiving a request for a new `Item` object at a web controller and forwarding the information as a message through RabbitMQ. A service would be elsewhere, listening for messages. That service could then write the new `Item` to MongoDB.

This is a very simple concept we can use over and over. We can also adapt it to our needs. It’s easy to swap out the web controller with something else. Perhaps a message was also transmitted via RabbitMQ. Or, perhaps someone directly invoking the API.



# Defining a test class
Let’s return to the initial problem. Namely, a web controller that turns synchronous web requests into asynchronous messages. This time, we’ll choose a test-first approach.

Spring Boot Test, JUnit 5, and Testcontainers put this at our fingertips:


@SpringBootTest //1
@AutoConfigureWebTestClient //2
@Testcontainers //3
@ContextConfiguration //4
public class RabbitTest {

    @Container static RabbitMQContainer container = new RabbitMQContainer(); //5
    @Autowired WebTestClient webTestClient; //6
    @Autowired ItemRepository repository; //7
    @DynamicPropertySource //8
    static void configure(DynamicPropertyRegistry registry) {
        registry.add("spring.rabbitmq.host", container::getContainerIpAddress);
        registry.add("spring.rabbitmq.port", container::getAmqpPort);
    }
    ...
}

RabbitTest.java

Here's a breakdown of the code above:

1. In **line 1**, `@SpringBootTest` is Spring Boot’s annotation to enable all kinds of stuff
including autoconfiguration, property support, and possibly an embedded
container. By default, it uses a mock environment.
2. In **line 2**, `@AutoConfigureWebTestClient` is the annotation to apply if we wish to
use Spring Boot’s `WebTestClient`, a test variant of `WebClient`.
3. In **line 3**, `@Testcontainers` is a JUnit 5 annotation that hooks our test cases into
Testcontainers, allowing it to operate.
4. In **line 4**, `@ContextConfiguration` is a Spring annotation that loads the named
class before running any tests.
5. In **line 7**, we create a Test container `RabbitMQContainer`, which properly manages an instance of RabbitMQ for our test.
6. **Line 8**, is where `WebTestClient` gets injected automatically.
7. In **line 9**, we inject a copy of the `ItemRepository` for result verification.

8. In **line 10**, `@DynamicPropertySource` dynamically adds properties to the
environment using Java 8 `Supplier` calls. This uses the
`container::getContainerIpAddress` and `container::getAmqpPort` method handles to delegate to Testcontainers and grab the host name and port after Testcontainers has spun up the RabbitMQ broker. This lets us grab connection details from Testcontainers and assign them to the Spring Boot properties needed by Spring AMQP.

As we gear up to write our test case, there’s something to be aware of. That is, there’s no `RabbitVerifier`. Project Reactor provides a very handy `StepVerifier` to help us test out asynchronous flows. There’s even a way to simulate delays. But to test out RabbitMQ scenarios, we’ll have to put `Thread.sleep()` calls into our tests.

> __Note:__ While the Spring team generally recommends using constructor injection for production components, it’s okay to use field injection for test classes, given that they operate on a different lifecycle.

Notice, also, that there isn’t any mention of what Spring project should be used to solve this test case. That’s because we’re solving this with a test-first approach. We don’t discuss a solution until we have a clearly defined problem.


# Testing AMQP messaging 

Before we start drafting that web controller, we need to layout how the controller will handle things.  It should:

1. Accept an HTTP `POST` with the payload to create a new `Item` object.
2. Turn the payload into a suitable message.
3. Publish the payload to the broker.


On the receiving end, we’ll need to:
1. Listen for new messages.
2. Pull a message down.
3. Save a message in MongoDB. Also, we need to be sure that either we or the framework is subscribing. Then, we craft a test case (and expect it to fail if it’s run right away).


Learn how to write a test class for RabbitMQ.


Crafting a Test Case

Learn how to write a test class for RabbitMQ.

Getting Started

Building a Web App with Spring Boot

Data Access with Spring Boot

Developer Tools for Spring Boot

Testing with Spring Boot

Operations with Spring Boot

Building APIs with Spring Boot

Messaging with Spring Boot

RSocket with Spring Boot

Securing Our Application with Spring Boot

Epilogue

Appendix

Crafting a Test Case