Java Servlet API and Filters - Rishan Solutions

Java Servlets are Java classes that handle HTTP requests and responses in a web server environment. They are an integral part of the Java EE (Enterprise Edition) specification and are used to build dynamic web applications. The Java Servlet API provides a set of classes and interfaces that enable developers to create servlets that interact with web clients, such as browsers.

Filters in Java Servlets are used to intercept requests and responses, enabling developers to modify or enhance them before they reach a servlet or the client. Filters are typically used for tasks such as logging, authentication, and modifying request/response data.

1. Java Servlet API Overview

The Servlet API provides a number of classes and interfaces that facilitate the creation and management of web applications in Java. The key components in the Servlet API are:

1.1. Servlet Interface

The Servlet interface is the core of the Servlet API. It defines the basic methods that every servlet must implement.

init(): Initializes the servlet. It is called once when the servlet is loaded into memory.
service(): Handles client requests. This method is invoked for each request to the servlet.
destroy(): Called when the servlet is about to be destroyed, typically when the server is shutting down or when the servlet is being removed.

public class MyServlet extends HttpServlet {
    @Override
    public void init() throws ServletException {
        // Initialization code
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // Handle GET request
    }

    @Override
    public void destroy() {
        // Cleanup code
    }
}

1.2. HttpServlet Class

The HttpServlet class is a commonly used subclass of the GenericServlet class. It is specifically designed to handle HTTP requests (GET, POST, etc.). By extending HttpServlet, developers only need to implement the doGet() or doPost() methods rather than overriding the service() method.

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.getWriter().write("Hello, World!");
    }
}

1.3. ServletConfig and ServletContext

ServletConfig: Provides initialization parameters for a servlet. It allows the servlet to retrieve configuration data from the web container.
ServletContext: Represents the web application as a whole. It allows servlets to access shared resources, such as files, and can be used for communication between servlets.

ServletConfig config = getServletConfig();
String param = config.getInitParameter("myParam");

ServletContext context = getServletContext();
context.setAttribute("sharedData", data);

1.4. HttpServletRequest and HttpServletResponse

HttpServletRequest: Represents the request from the client. It provides methods to access request parameters, headers, session data, etc.
HttpServletResponse: Represents the response sent back to the client. It allows setting response status codes, content types, and writing output to the response body.

String name = request.getParameter("name");
response.setContentType("text/html");
response.getWriter().write("<h1>Hello, " + name + "</h1>");

2. Filters in Java Servlets

Filters are objects that can intercept and modify the request before it reaches a servlet, or the response before it is sent back to the client. Filters provide a flexible mechanism for cross-cutting concerns in web applications. Some typical use cases for filters are:

Logging and Monitoring: Track request processing times, log request data, or monitor usage patterns.
Authentication and Authorization: Check user credentials and roles before allowing access to specific resources.
Request/Response Modifications: Modify the request data before it reaches the servlet, or modify the response data before sending it to the client (e.g., compression, character encoding).

2.1. Filter Interface

The Filter interface provides the methods for implementing a filter:

init(): Initializes the filter. This method is called once when the filter is created.
doFilter(): Intercepts the request and response. It allows modification of the request, passing control to the next filter or servlet in the chain.
destroy(): Cleans up any resources used by the filter before it is destroyed.

public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Initialization code
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // Pre-processing logic
        System.out.println("Request received");
        
        // Pass request and response to the next filter or servlet
        chain.doFilter(request, response);

        // Post-processing logic
        System.out.println("Response sent");
    }

    @Override
    public void destroy() {
        // Cleanup code
    }
}

FilterChain: The FilterChain object is used to pass the request and response to the next filter or servlet in the chain using the doFilter() method.

2.2. Filter Configuration

Filters are configured in the web.xml deployment descriptor or via annotation-based configuration in newer versions of Java EE (Servlet 3.0+).

web.xml Configuration:

<filter>
    <filter-name>MyFilter</filter-name>
    <filter-class>com.example.MyFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>MyFilter</filter-name>
    <url-pattern>/protected/*</url-pattern>
</filter-mapping>

Annotation-based Configuration (Servlet 3.0+):

@WebFilter(urlPatterns = "/protected/*")
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // Filter logic
        chain.doFilter(request, response);
    }
}

In this example, MyFilter is applied to all requests matching the /protected/* URL pattern.

3. Chain of Filters

Filters can be chained together. When multiple filters are configured for a URL pattern, they are executed in the order they are defined in the configuration. Each filter can modify the request and response, and the FilterChain passes the request to the next filter or servlet in the chain.

If a filter does not call chain.doFilter(), the request processing will stop, and the response will not proceed to the next filter or servlet.

4. Common Use Cases for Filters

Logging and Monitoring:
- Track request execution time and log request/response details.
- Example: Log the time taken to process a request.
long startTime = System.currentTimeMillis(); chain.doFilter(request, response); long endTime = System.currentTimeMillis(); System.out.println("Request processing time: " + (endTime - startTime) + " ms");
Authentication and Authorization:
- Ensure that only authenticated users can access certain resources.
- Example: Check if a user is logged in before accessing protected resources.
String username = request.getParameter("username"); if (username == null) { response.sendRedirect("login.jsp"); } else { chain.doFilter(request, response); }
Character Encoding:
- Set the character encoding for requests and responses to ensure proper handling of non-ASCII characters.
request.setCharacterEncoding("UTF-8"); response.setCharacterEncoding("UTF-8"); chain.doFilter(request, response);
Compression:
- Compress the response before sending it to the client to reduce bandwidth usage.
- Example: Compress response content using GZIP.

5. Advantages of Filters

Separation of Concerns: Filters allow developers to handle tasks like authentication, logging, and monitoring separately from the business logic in servlets.
Reusability: Filters can be reused across different servlets and URLs without having to duplicate code.
Performance: Filters can improve performance by allowing preprocessing and postprocessing of requests and responses (e.g., caching, compression).