Sean Robertson

Sean Robertson

1565318712

An Introduction to Spring WebClient Filters

1. Request Filters

A filter can intercept, examine, and modify a client request (or response). Filters are very suitable for adding functionality to every single request since the logic stays in one place. Use cases include monitoring, modifying, logging, and authenticating client requests, just to mention a few.

A request has an ordered chain of zero or more filters.

In Spring Reactive, filters are instances of the functional interface ExchangeFilterFunction. The filter function has two parameters: the ClientRequest to modify and the next ExchangeFilterFunction.

Usually, a filter function returns by calling the next one in the filter chain:

ExchangeFilterFunction filterFunction = (clientRequest, nextFilter) -> {
    LOG.info("WebClient fitler executed");
    return nextFilter.exchange(clientRequest);
};

2. WebClient Filtering

After implementing a request filter, we have to “attach” it to the WebClient instance. This can be only done while creating the WebClient.

So then, let’s see how to create a WebClient. The first option is to invoke WebClient.create() with or without a base URL:

WebClient webClient = WebClient.create();

This, unfortunately, doesn’t allow to add a filter. The second option, then, is the one we’re looking for.

By using the WebClient.builder() we’re able to add filters:

WebClient webClient = WebClient.builder()
  .filter(filterFunction)
  .build();

3. A Custom Filter

Let’s start with a filter that counts the HTTP GET requests sent by the client.

The filter examines the request method and increases a “global” counter in case of a GET request:

ExchangeFilterFunction countingFunction = (clientRequest, nextFilter) -> {
    HttpMethod httpMethod = clientRequest.method();
    if (httpMethod == HttpMethod.GET) {
        getCounter.incrementAndGet();
    }
    return nextFilter.exchange(clientRequest);
};

The second filter we’ll define appends a version number to the request URL path. We utilize the ClientRequest.from() method to create a new request object from the current one and set the modified URL.

Subsequently, we continue executing the filter chain with the new modified request object:

ExchangeFilterFunction urlModifyingFilter = (clientRequest, nextFilter) -> {
    String oldUrl = clientRequest.url().toString();
    URI newUrl = URI.create(oldUrl + "/" + version);
    ClientRequest filteredRequest = ClientRequest.from(clientRequest)
      .url(newUrl)
      .build();
    return nextFilter.exchange(filteredRequest);
};

Next, let’s define a filter to log the methods of sent requests along with their URLs. These details are available in the request object.

All we have to do then is to print to some output stream:

ExchangeFilterFunction loggingFilter = (clientRequest, nextFilter) -> {
    printStream.print("Sending request " + clientRequest.method() + " " + clientRequest.url());
    return nextFilter.exchange(clientRequest);
};

4. A Standard Filter

Finally, we look into basic authentication, a very common use case of request filtering. The helping class ExchangeFilterFunctions offers the basicAuthentication() filter function which takes care of adding the authorization header to the request. As a result, we don’t need to define a filter for it:

WebClient webClient = WebClient.builder()
  .filter(ExchangeFilterFunctions.basicAuthentication(user, password))
  .build();

5. Conclusion

In this short article, we have explored filtering WebFlux clients in Spring. The code example can be found in the GitHub project.

Thanks for reading

If you liked this post, share it with all of your programming buddies!

Follow us on Facebook | Twitter

Further reading

Spring & Hibernate for Beginners (includes Spring Boot)

Spring Framework Master Class - Learn Spring the Modern Way!

Master Microservices with Spring Boot and Spring Cloud

Spring Boot and OAuth2: Getting the Authorization Code

An Introduction to Spring Boot

How to build GraphQL APIs with Kotlin, Spring Boot, and MongoDB?

Build a Rest API with Spring Boot using MySQL and JPA

Angular 8 + Spring Boot 2.2: Build a CRUD App Today!

Spring Boot vs. Spring MVC vs. Spring: How Do They Compare?

Top 4 Spring Annotations for Java Developer in 2019


#java #spring-boot

What is GEEK

Buddha Community

An Introduction to Spring WebClient Filters
Were  Joyce

Were Joyce

1620781140

Spring WebClient vs RestTemplate — Comparison and Features

Introduction

Spring 5 introduced a new reactive web client called WebClient. In this post, I will show when and how we can use Spring WebClient vs RestTemplate. I will also describe what features WebClient offers.

What is RestTemplate?

What is WebClient?

Spring WebClient vs RestTemplate

Example of how to use WebClient in a Spring Boot Application

What Else Is There in Spring WebClient?

Conclusion

References

#webclient #spring-boot #resttemplate #spring-framework #spring

Were  Joyce

Were Joyce

1620720872

Spring vs Spring BooDifference Between Spring and Spring Boot

As an extension of the Spring Framework, Spring Boot is widely used to make development on Spring faster, more efficient and convenient. In this article, we will look at some of the parameters were using Spring Boot can drastically reduce the time and effort required in application development.

What is Spring?

Spring Boot

Difference between Spring and Spring Boot

Advantages of Spring Boot over Spring

Conclusion

#full stack development #spring #spring and spring boot #spring boot

Were  Joyce

Were Joyce

1623559620

Spring Native turns Spring apps into native executables

Spring Native beta release leverages GraalVM to compile Spring Java and Kotlin applications to native images, reducing startup time and memory overhead compared to the JVM.

Spring Native, for compiling Spring Java applications to standalone executables called native images, is now available as a beta release. Native images promise faster startup times and lower runtime memory overhead compared to the JVM.

Launched March 11 and available on start.spring.io, the Spring Native beta compiles Spring applications to native images using the GraalVM multi-language runtime. These standalone executables offer benefits including nearly instant startup (typically fewer than 100ms), instant peak performance, and lower memory consumption, at the cost of longer build times and fewer runtime optimizations than the JVM.

#spring native turns spring apps into native executables #spring native #spring #native executables #spring apps

Were  Joyce

Were Joyce

1623424020

Spring Framework Tutorial

What is the spring framework in Java?

The spring framework is one of the most versatile frameworks in java which is used to bring down the complexity of the development of enterprise-grade applications. The first production release of the spring framework was in March 2004 and since then, this robust and open-source framework has gained tremendous popularity, so much so that it is often referred to by developers all around the world as the “framework of frameworks”. Spring is a loosely coupled, open-source application framework of java. It is lightweight and the inversion of the control container for the Java platform. A large number of Java applications use the core features of the spring framework. In addition to that, extensions have also been developed to allow developers to develop Web Applications on top of the Java Enterprise Edition platform.

#spring #spring-framework #java #spring framework tutorial #why should one learn about the spring framework? #what is the spring framework in java?

Were  Joyce

Were Joyce

1620736200

Introduction to Spring Boot and JDBCTemplate: Refactoring to SpringData JPA

Introduction to Spring Boot and JDBCTemplate: Refactoring to SpringData JPA.

Refactoring is the process of modifying a software system without changing its desirable behavior. It was necessary to have an application integrated with the relational database using the Spring JDBC Template in the first parts. The Spring JDBC Template is a powerful tool that facilitates productivity. However, there is a way to simplify the code even further with Spring Data JPA. The purpose of this post is to refactor the project to use Spring Data JPA.

Spring Data JPA, part of the larger Spring Data family, makes it easy to implement JPA-based repositories easily. This module deals with enhanced support for JPA-based data access layers. It makes it easier to build Spring-powered applications that use data access technologies.

A safe code refactoring requires the use of tests to ensure that the compartment is not changed. The use of tests, fortunately, is adopted as a minimum standard, including several methodologies such as TDD that preach the creation of tests at the beginning of the development process.

#java #tutorial #spring #spring data #java tutorial #spring tutorial #spring data jpa