JAVA EE: FilterConfig

Showing posts with label FilterConfig. Show all posts

Thursday, 24 April 2014

Servlets : Filter Config Demo

Level Up Your Java Web Skills!

Subscribe to Ram N Java for hands-on, practical Java Servlets walkthroughs, backend architecture guides, and clear code demonstrations!

🔔 Subscribe to Ram N Java

What is FilterConfig in Java Servlets?

In Java web applications, the FilterConfig interface is part of the javax.servlet package. It is an object used by the servlet container to pass configuration information and initialization parameters to a filter during startup.

Just like ServletConfig provides initialization parameters to a servlet, FilterConfig supplies filter-specific parameters configured inside deployment descriptor files (such as web.xml) or annotations, allowing your filter to remain dynamic without hardcoding values in Java code.

How FilterConfig Works During Initialization

When the web application starts up, the web container creates an instance of your filter and invokes its init(FilterConfig filterConfig) method exactly once.

getInitParameter(String name): Retrieves the value of a specific initialization parameter configured for this filter.
getInitParameterNames(): Returns an Enumeration containing the names of all initialization parameters defined for the filter.
getFilterName(): Returns the name of the filter as specified in the deployment configuration.
getServletContext(): Returns a reference to the ServletContext, enabling access to application-wide resources.

public void init(FilterConfig filterConfig) throws ServletException {

        // Reading init parameter configured in web.xml

        String constructionMode = filterConfig.getInitParameter("construction");

        System.out.println("Under Construction Mode: " + constructionMode);

    }

Why Use FilterConfig?

Configuration Flexibility: Change operational parameters (such as site maintenance flags, encoding schemes, or logging levels) in web.xml without modifying or recompiling Java code.
Scoped Exclusively to the Filter: Initialization parameters defined in <filter> are private to that filter and cannot be accessed by other servlets or filters.
Access to ServletContext: Allows your filter to interact with application-level data and event logging easily.

Recommended Related Tutorials

Learn more about Servlet Filters and configuration with these tutorials from Ram N Java:

Click here to watch in Youtube : https://www.youtube.com/watch?v=uiEBhrkRx3I

Click the below Image to Enlarge

Servlets : Filter Config Demo

FilterConfigDemo Project Dir Structure

Servlets : Filter Config Demo

MyFilter.java

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class MyFilter implements Filter
{
 FilterConfig config;

 public void init(FilterConfig config) throws ServletException
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" init method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");

  this.config = config;
 }

 public void doFilter(ServletRequest req, ServletResponse resp,
         FilterChain chain) throws IOException, ServletException
 {

  PrintWriter out = resp.getWriter();

  String filterName = config.getFilterName();

  System.out.println("Filter Name : " + filterName + "\n");

  String isConstruction = config.getInitParameter("construction");

  if (isConstruction.equals("yes"))
  {
   out.print("This page is under construction");
  }
  else
  {
   /** sends request to next resource */
   chain.doFilter(req, resp);
  }

 }

 public void destroy()
 {
  // add code to release any resource
  System.out
          .println("------------------------------------------------------");
  System.out.println(" destroy method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }
}

HelloServlet.java

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet
{
 private static final long serialVersionUID = 1L;

 public void init() throws ServletException
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" Init method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }

 public void doGet(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException
 {

  System.out.println(" doGet method is called in "
          + this.getClass().getName() + "\n\n");
  System.out
          .println("------------------------------------------------------");

  response.setContentType("text/html");
  PrintWriter out = response.getWriter();

  out.print("<br>welcome to helloservlet<br>");

 }

 public void destroy()
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" destroy method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }

}

web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 metadata-complete="true" version="3.0">
 <display-name>FilterConfigDemo</display-name>
 <description>
        This is a simple web application with a source code organization
        based on the recommendations of the Application Developer's Guide.
    </description>
 <servlet>
  <servlet-name>HelloServlet</servlet-name>
  <servlet-class>HelloServlet</servlet-class>
 </servlet>
 <servlet-mapping>
  <servlet-name>HelloServlet</servlet-name>
  <url-pattern>/hello</url-pattern>
 </servlet-mapping>
 <filter>
  <filter-name>myfilter</filter-name>
  <filter-class>MyFilter</filter-class>
  <init-param>
   <param-name>construction</param-name>
   <param-value>yes</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>myfilter</filter-name>
  <url-pattern>/hello</url-pattern>
 </filter-mapping>
</web-app>

index.html

<!DOCTYPE HTML><html lang="en"><head>
<meta charset="UTF-8">
<title>FilterConfigDemo</title>
</head>
<body>
<p>
<h3>FilterConfigDemo</H3>
<p></p>
<ul>
<li><a href="hello">FilterConfigDemo</a></li>

</ul>
</body></html>

Environment Used

JDK version :1.6.0_30
Tomcat version : 7.0.50

To Download FilterConfigDemoApp Project Click the below link

https://sites.google.com/site/javaee4321/servlets/FilterConfigDemoApp.zip?attredirects=0&d=1

See also:

Servlets Tutorial

All Design Patterns Links

Wednesday, 23 April 2014

Servlets : Filter Config

Master Java Backend Development!

Subscribe to Ram N Java for beginner-friendly coding walkthroughs, servlet architecture lessons, and hands-on Java guides!

🔔 Subscribe to Ram N Java

What is FilterConfig in Java Servlets?

In Java web applications, the FilterConfig interface belongs to the javax.servlet package. It acts as a configuration carrier used by the servlet container to pass initialization values and environment references to a filter during its startup phase.

Just as ServletConfig is dedicated to individual servlets, FilterConfig supplies filter-specific parameters defined in configuration files like web.xml or through annotations. This allows developers to adjust filter behaviors without altering the underlying compiled Java code.

Core Methods of the FilterConfig Interface

The web container automatically supplies a FilterConfig reference to the filter's init(FilterConfig filterConfig) method. Key methods available on this interface include:

getInitParameter(String name): Returns the value of the named initialization parameter, or null if it doesn't exist.
getInitParameterNames(): Returns an Enumeration<String> containing all initialization parameter names defined for the filter.
getFilterName(): Returns the name assigned to the filter in the deployment descriptor.
getServletContext(): Returns a reference to the global ServletContext object, providing access to application-wide resources and attributes.

@Override

    public void init(FilterConfig filterConfig) throws ServletException {

        // Retrieve custom init-param defined in web.xml

        String mode = filterConfig.getInitParameter("maintenanceMode");

        System.out.println("Filter initialized with mode: " + mode);

    }

Key Advantages of Using FilterConfig

Code Reusability: Deploy the same filter class across multiple URL patterns with differing configurations.
Configurable at Runtime: Modify settings like encoding, debug flags, or thresholds directly in deployment descriptors without recompilation.
Encapsulated Parameters: Initialization values defined within a <filter> tag remain isolated to that filter instance.