Intercepting Filter Design Pattern in Java

Back to: Java Design Patterns

Intercepting Filter Design Pattern in Java

In this article, I am going to discuss Intercepting Filter Design Pattern in Java with Examples. Please read our previous article where we discussed Transfer Object Design Pattern in Java. In this article, we will explore the Intercepting Filter Design Pattern in Java, its advantages, disadvantages, and practical applications in software development.

What is Intercepting Filter Design Pattern?

In software development, cross-cutting concerns, such as logging, authentication, and data validation, often permeate throughout an application. Managing these concerns can become complex and lead to code duplication. The Intercepting Filter design pattern provides a systematic approach to address cross-cutting concerns by introducing filters that intercept and process requests and responses.

The Intercepting Filter design pattern focuses on intercepting requests and responses in a system to apply common processing or manipulations. It introduces filters that intercept incoming requests before they reach the core processing logic. These filters can modify or enhance the requests and responses, adding functionality such as authentication, logging, or input validation.

Components of Intercepting Filter Design Pattern

The Intercepting Filter Design Pattern consists of the following components:

• Filter: Filters encapsulate specific cross-cutting concerns and intercept requests and responses. They perform processing or manipulation tasks and can be chained together to create a pipeline of filters.
• Filter Chain: The Filter Chain represents the collection of filters that are applied sequentially to intercept requests and responses. Each filter in the chain has the ability to modify or enrich the request or response data before passing it to the next filter or the core processing logic.
• Target: The Target represents the core processing logic or the component that the request is ultimately forwarded to after passing through the filter chain.

Example to Understand Intercepting Filter Design Pattern in Java

To illustrate the Intercepting Filter design pattern in a real-world context, let’s consider a web application that requires logging functionality for tracking user actions and system events. The Intercepting Filter pattern can be employed to create a Logging Filter that intercepts requests and responses to log relevant information.

In this example, the Logging Filter acts as an intermediary between the client and the core processing logic of the web application. When a request is received, the Logging Filter intercepts it, and logs details such as the request method, URL, client IP address, and timestamp. It then passes the request to the next filter or the core processing logic.

Similarly, when a response is generated, the Logging Filter intercepts it and logs details such as the response status code, response time, and any relevant data. The Logging Filter encapsulates the logging functionality, ensuring that all requests and responses are logged consistently and uniformly.

By using the Intercepting Filter pattern, the web application benefits from centralized and standardized logging. The Logging Filter eliminates the need to include logging code in every component or module, reducing code duplication and improving code maintainability. It also provides a flexible and modular approach to adding or modifying logging functionality without affecting the core processing logic.

Overall, the Intercepting Filter pattern simplifies the implementation of logging functionality in the web application, enabling consistent and efficient logging of user actions and system events. The UML Diagram of this example is given below using Intercepting Filter Design Pattern.

Implementing Intercepting Filter Design Pattern in Java

Step 1: Create a new directory to store all the class files of this project.

Step 2: Open VS Code and create a new project, called interceptingfilter.

Step 3: In the project, create a new file called Filter.java. Add the following code to the file:

public interface Filter
{
    public void execute(String request);    
}

This is the interface that will be implemented by other classes.

Step 4: In the project, create two new files called AuthFilter.java and DebugFilter.java. Both of these classes implement the Filter interface. Add the following code to the files:

AuthFilter.java

public class AuthFilter implements Filter
{
    @Override
    public void execute(String request)
    {System.out.println("Authenticating: " + request);}   
}

DebugFilter.java

public class DebugFilter implements Filter
{
    @Override
    public void execute(String request)
    {System.out.println("Logging: " + request);}
}

Step 5: In the project, create a new file called Target.java. Add the following code to Target.java:

public class Target
{
    public void execute(String request)
    {System.out.println("Executing: " + request);}
}

Step 6: In the project, create a new file called FilterChain.java. This file will store the list of filters. It also executes those filters (before a target is to be executed). Add the following code to FilterChain.java:

import java.util.ArrayList;
import java.util.List;

public class FilterChain
{
    private List<Filter> filters = new ArrayList<Filter>();
    private Target t;

    public void addFilter (Filter f)
    {filters.add(f);}

    public void execute (String request)
    {
        for (Filter f : filters)
            f.execute(request);
        
        t.execute(request);
    }

    public void setT(Target t) {
        this.t = t;
    }
}

Step 7: In the project, create a new file called FilterManager.java. This class will manage the filter chain class. Add the following code to FilterManager.java:

public class FilterManager
{
    private FilterChain fc;
    
    public FilterManager(Target t)
    {
        fc = new FilterChain();
        fc.setT(t);
    }

    public void setFilter(Filter f)
    {fc.addFilter(f);}

    public void filter (String request)
    {fc.execute(request);}
}

Step 8: In the project, create a new file called Client.java. This class represents the client. Add the following code to Client.java:

public class Client
{
    private FilterManager fm;

    public void setFm(FilterManager fm)
    {this.fm = fm;}
    
    public void sendRequest (String request)
    {fm.filter(request);}
}

Step 9: In the project, create a new file called InterceptingFilterPatternDemo.java. This class contains the main() function. Add the following code to InterceptingFilterPatternDemo.java:

public class InterceptingFilterPatternDemo
{
    public static void main(String[] args)
    {
        FilterManager fm = new FilterManager(new Target());
        fm.setFilter(new AuthFilter());
        fm.setFilter(new DebugFilter());

        Client c = new Client();
        c.setFm(fm);
        c.sendRequest("LOGIN PAGE");
    }
}

Step 10: Compile and execute the application. Ensure compilation is successful. Verify that the program works as expected.

Congratulations! You now know how to implement Intercepting Filter Design Pattern in Java!

UML Diagram of Intercepting Filter Design Pattern:

Now, let us see the Intercepting Filter Design Pattern UML Diagram Components with our Example so that you can easily understand the UML Diagram.

The classes can be described as follows:

1. Filter: This is the interface that will be implemented by concrete filters.
2. ConcreteFilter: This class implements the functions defined in the Filter interface.
3. Target: This class represents the target that needs to be executed.
4. FilterChain: This class contains the list of filters that need to execute before the target is executed.
5. FilterManager: This class acts as a manager for the FilterChain class.
6. Client: This class represents the client.
7. DriverClass: This class contains the main() function and is responsible for the simulation of the program.

Advantages of Intercepting Filter Design Pattern in Java:

The followings are the advantages of using the Intercepting Filter Design Pattern in Java:

• Separation of Concerns: The Intercepting Filter pattern promotes the separation of concerns by encapsulating cross-cutting functionality within individual filters. Each filter focuses on a specific concern, such as authentication or logging, allowing for modular and maintainable code.
• Reusability: Filters can be reused across different parts of the application or even in different applications. They provide a modular way to address common cross-cutting concerns, reducing code duplication and improving overall code reuse.
• Flexibility and Extensibility: The Intercepting Filter pattern offers flexibility and extensibility. New filters can be easily added to the filter chain to introduce new functionalities or modify existing ones. The modular nature of filters allows for easy customization and adaptation to changing requirements.
• Code Decoupling: By intercepting requests and responses, the Intercepting Filter pattern decouples the core processing logic from the cross-cutting concerns. The core logic does not need to be aware of the specific filters being applied, promoting loose coupling and improving code maintainability.
• Dynamic Configuration: The filter chain can be dynamically configured based on runtime conditions or configuration files. This allows for runtime customization and adaptation of the filtering behavior without modifying the core logic.

Disadvantages of Intercepting Filter Design Pattern in Java:

The followings are the disadvantages of using the Intercepting Filter Design Pattern in Java:

• Increased Complexity: Introducing the Intercepting Filter pattern adds an additional layer of complexity to the system. Managing the filter chain, ensuring proper order and execution of filters, and coordinating the flow of requests and responses require careful design and implementation.
• Performance Overhead: The Intercepting Filter pattern can introduce performance overhead, especially when a large number of filters are involved or when complex processing is performed within each filter. The additional processing and potential data manipulation can impact the system’s performance, and developers should carefully consider performance implications.
• Order Dependency: The order in which filters are applied within the filter chain can be crucial. Some filters may rely on the output or modifications made by previous filters. Managing the order and dependencies between filters can be challenging and may require careful planning and coordination.

In the next article, I am going to discuss Dependency Injection Design Pattern in Java with Examples. Here, in this article, I try to explain Intercepting Filter Design Pattern in Java with Examples. I hope you understood the need for and use of the Intercepting Filter Design Pattern in Java.