Building Custom Microservice Filters with Java and Math

Kartik Chandra Mandal November 12, 2024

 

For register Single custom filter

Creating a custom filter in microservices using Java with advanced mathematical formulas can help fine-tune traffic control, load balancing, and other service-specific requirements. Here's a practical implementation that includes a custom filter class in Java, using a scoring formula to prioritize or throttle incoming requests. This example can be integrated into a Spring Cloud Gateway or Spring Boot application.

Scenario

We'll design a filter that calculates a "priority score" based on user subscription level, request rate, and service load to control access dynamically. The filter will:

  1. Throttle requests if the priority score is low.
  2. Delay processing if the score is moderate.
  3. Allow immediate access for high scores.

Mathematical Formula for Priority Score

Here's a sample formula to calculate the priority score:

$$priorityScore=\frac{subscriptionLevel×baseWeight}{requestRate+serviceLoad}$$

Where:

Ø  subscriptionLevel: Integer value based on user level (e.g., 1 for Basic, 3 for Premium).

Ø  baseWeight: A constant multiplier, say 10.

Ø  requestRate: Number of requests by the user in a short interval (e.g., 10 seconds).

Ø  serviceLoad: Dynamic load metric representing current service usage (e.g., requests per second).

Implementing the Filter in Java (Spring Boot)

Below is a custom filter in Java using Spring Boot, which calculates the priority score and determines access based on that score.

Custom Filter Class

  1. Create a filter in Spring Boot using OncePerRequestFilter.
  2. Calculate the priority score using the formula above.
  3. Decide the course of action based on the calculated score.

Code Example

java

import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;

import javax.servlet.Filter;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

 

@Component

public class CustomMathFilter implements Filter {

 

    private static final int BASE_WEIGHT = 10;

 

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

            throws IOException, ServletException {

 

        HttpServletRequest httpRequest = (HttpServletRequest) request;

        HttpServletResponse httpResponse = (HttpServletResponse) response;

 

        // Simulating request rate and service load

        int requestRate = getRequestRateForUser(httpRequest); // Example function

        int serviceLoad = getCurrentServiceLoad(); // Example function

        int subscriptionLevel = getUserSubscriptionLevel(httpRequest); // Example function

 

        // Calculate priority score based on our formula

        double priorityScore = calculatePriorityScore(subscriptionLevel, requestRate, serviceLoad);

 

        // Apply actions based on priority score

        if (priorityScore < 1) {

            // Block request

            httpResponse.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);

            httpResponse.getWriter().write("Request rate too high. Please try again later.");

        } else if (priorityScore < 2) {

            // Delay request

            try {

                Thread.sleep(1000); // Delay processing by 1 second

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

            }

            chain.doFilter(request, response);

        } else {

            // Allow request immediately

            chain.doFilter(request, response);

        }

    }

 

    // Priority score calculation method

    private double calculatePriorityScore(int subscriptionLevel, int requestRate, int serviceLoad) {

        return (double) (subscriptionLevel * BASE_WEIGHT) / (requestRate + serviceLoad);

    }

 

    // Dummy method to simulate retrieving user subscription level

    private int getUserSubscriptionLevel(HttpServletRequest request) {

        String userId = request.getHeader("user-id");

        return getUserSubscriptionLevelFromDb(userId); // Replace with actual retrieval logic

    }

 

    // Dummy method to simulate request rate per user

    private int getRequestRateForUser(HttpServletRequest request) {

        String userId = request.getHeader("user-id");

        return getRequestCountInLast10Seconds(userId); // Replace with actual tracking logic

    }

 

    // Dummy method to simulate current service load

    private int getCurrentServiceLoad() {

        return getCurrentRequestsPerSecond(); // Replace with actual load calculation

    }

 

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {}

 

    @Override

    public void destroy() {}

}

 

Explanation of Code

Ø  calculatePriorityScore: Computes the priority score based on subscription level, request rate, and current service load.

Ø  Decision Logic:

ü  Low score (< 1): Rejects the request with a 429 Too Many Requests error.

ü  Moderate score (1 ≤ score < 2): Delays processing by 1 second.

ü  High score (≥ 2): Allows immediate processing.

Ø  Helper Methods (getUserSubscriptionLevel, getRequestRateForUser, getCurrentServiceLoad): Simulates retrieval of dynamic values like user subscription, request rate, and load. Replace these with actual implementations or database queries as needed.

Adding the Filter to Spring Boot Configuration

To make the filter active, you may add it to the filter chain configuration in your Spring Boot application.

java

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

 

@SpringBootApplication

public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);

    }

}

 

Testing and Tuning

  1. Load Testing: Test the filter under different simulated loads to ensure it performs as expected and handles request rates gracefully.
  2. Monitoring: Use logging or monitoring tools to observe filter decisions and identify any need for formula adjustments.

UML Sequence Diagram for Filter Process

The following UML sequence describes the flow through the custom filter logic based on the calculated score:

Building Custom Microservice Filters with Java and Math
Building Custom Microservice Filters with Java and Math


Summary

This custom filter:

  1. Calculates a priority score using mathematical operations.
  2. Controls request access dynamically based on calculated metrics.
  3. Improves responsiveness and manages load by selectively throttling or delaying requests.

This setup is particularly useful for microservices handling high traffic where dynamic access control is essential for maintaining stable performance.

 

 

For register multiple custom filters

To register multiple custom filters as beans in a Spring Boot application, you can configure each filter individually and define the order in which they are executed. Here’s how you can set up and register multiple filters:

1. Define Each Custom Filter as a Spring Bean

Each filter should be implemented as a separate class, implementing either the javax.servlet.Filter interface or extending OncePerRequestFilter (a Spring-specific filter base class that guarantees a single execution per request).

Example of Custom Filter 1: CustomMathFilter

java

import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;

import javax.servlet.Filter;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

 

@Component

public class CustomMathFilter implements Filter {

 

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

            throws IOException, ServletException {

        // Custom filtering logic for mathematical calculations

        chain.doFilter(request, response);

    }

 

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {}

 

    @Override

    public void destroy() {}

}

 

Example of Custom Filter 2: CustomAuthFilter

java

import org.springframework.stereotype.Component;

import javax.servlet.FilterChain;

import javax.servlet.Filter;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

 

@Component

public class CustomAuthFilter implements Filter {

 

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

            throws IOException, ServletException {

        // Custom authentication logic

        chain.doFilter(request, response);

    }

 

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {}

 

    @Override

    public void destroy() {}

}

 

2. Register the Filters as Beans and Define Order

In Spring Boot, you can specify the order of filters using @Order. Filters with lower order values will execute first.

java

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.Ordered;

 

@Configuration

public class FilterConfig {

 

    @Bean

    public FilterRegistrationBean<CustomMathFilter> mathFilterRegistration() {

        FilterRegistrationBean<CustomMathFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new CustomMathFilter());

        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE); // Execute first

        return registrationBean;

    }

 

    @Bean

    public FilterRegistrationBean<CustomAuthFilter> authFilterRegistration() {

        FilterRegistrationBean<CustomAuthFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new CustomAuthFilter());

        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE + 1); // Execute second

        return registrationBean;

    }

}

 

Explanation

Ø  mathFilterRegistration registers CustomMathFilter as a bean with the highest precedence.

Ø  authFilterRegistration registers CustomAuthFilter to execute right after CustomMathFilter.

Ø  Order Management: Ordered.HIGHEST_PRECEDENCE ensures that the filters execute in the desired sequence.

3. Testing the Filters

When you start the Spring Boot application, the filters will automatically apply to all incoming requests in the specified order. You can verify their execution by adding logging statements inside each filter’s doFilter method.

Real Example: Setting Up Math-Related Filters in Spring Boot

Let's create two custom filters:

  1. AdditionFilter: Adds two numbers passed as query parameters and forwards the result.
  2. MultiplicationFilter: Multiplies the result from AdditionFilter by another factor passed in the request.

Each filter will be registered as a Spring bean and ordered in sequence to process the request flow.

Step 1: Create the Filters

AdditionFilter: Performs Addition Based on Query Parameters

This filter will add two numbers (a and b) that are passed in the query parameters of the request and store the result in an attribute for further processing.

Java

import org.springframework.stereotype.Component;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import java.io.IOException;

 

@Component

public class AdditionFilter implements Filter {

 

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

            throws IOException, ServletException {

       

        // Retrieve numbers a and b from query parameters

        String aParam = request.getParameter("a");

        String bParam = request.getParameter("b");

       

        try {

            int a = Integer.parseInt(aParam);

            int b = Integer.parseInt(bParam);

            int sum = a + b;

           

            // Store the sum as a request attribute for the next filter

            request.setAttribute("sum", sum);

        } catch (NumberFormatException e) {

            throw new ServletException("Invalid input for addition. Please provide integer values for 'a' and 'b'.");

        }

 

        chain.doFilter(request, response); // Pass control to the next filter

    }

 

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {}

 

    @Override

    public void destroy() {}

}

 

 

MultiplicationFilter: Multiplies the Sum by a Factor

This filter retrieves the sum attribute set by AdditionFilter and multiplies it by a factor query parameter.

java

import org.springframework.stereotype.Component;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import java.io.IOException;

 

@Component

public class MultiplicationFilter implements Filter {

 

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)

            throws IOException, ServletException {

       

        Integer sum = (Integer) request.getAttribute("sum");

        String factorParam = request.getParameter("factor");

       

        if (sum == null) {

            throw new ServletException("Addition result not found. Ensure AdditionFilter is applied.");

        }

 

        try {

            int factor = Integer.parseInt(factorParam);

            int result = sum * factor;

 

            // Set the final result as a request attribute

            request.setAttribute("result", result);

        } catch (NumberFormatException e) {

            throw new ServletException("Invalid input for multiplication. Please provide an integer value for 'factor'.");

        }

 

        chain.doFilter(request, response); // Pass control to the next component

    }

 

    @Override

    public void init(FilterConfig filterConfig) throws ServletException {}

 

    @Override

    public void destroy() {}

}

 

Step 2: Register the Filters as Beans in Spring Boot

Now, register the filters and set their order so that AdditionFilter runs before MultiplicationFilter.

java

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.Ordered;

 

@Configuration

public class FilterConfig {

 

    @Bean

    public FilterRegistrationBean<AdditionFilter> additionFilterRegistration() {

        FilterRegistrationBean<AdditionFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new AdditionFilter());

        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE); // First filter to run

        return registrationBean;

    }

 

    @Bean

    public FilterRegistrationBean<MultiplicationFilter> multiplicationFilterRegistration() {

        FilterRegistrationBean<MultiplicationFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new MultiplicationFilter());

        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE + 1); // Runs after AdditionFilter

        return registrationBean;

    }

}

 

Step 3: Access the Final Result in the Controller

Create a simple Spring REST controller to access the final result after both filters have processed the request.

java

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestAttribute;

import org.springframework.web.bind.annotation.RestController;

 

@RestController

public class MathController {

 

    @GetMapping("/calculate")

    public String calculate(@RequestAttribute("result") Integer result) {

        return "Final result after addition and multiplication is: " + result;

    }

}

 

How It Works

  1. The request first passes through AdditionFilter, which calculates the sum of parameters a and b and stores it as a request attribute.
  2. MultiplicationFilter then retrieves this sum and multiplies it by the factor parameter.
  3. The controller accesses the final result attribute and returns it as a response.

Example Request

Assume you run the application and send a request as follows:

bash

GET http://localhost:8080/calculate?a=2&b=3&factor=4

 

Ø  Addition Filter: Adds a (2) and b (3) → sum = 5

Ø  Multiplication Filter: Multiplies sum (5) by factor (4) → result = 20

Response:

Plain text

Final result after addition and multiplication is: 20

 

This setup demonstrates a chain of custom filters, where each filter performs a mathematical operation, passing results to the next filter in sequence. This modular approach is powerful for processing complex mathematical or logical operations in microservices.

 

For more information, visit

Ø  Microservices: Custom Filters for Debouncing, Throttling, Rate Limits & Backoff

Ø  Mastering Debouncing, Throttling, Rate Limiting, and Exponential Backoff.

Ø  Custom Filters in Microservices

Ø  Spring Cloud Gateway uses a RewritePath filter

Post a Comment

0 Comments

Post a Comment