Java Filter（过滤器）

已于 2024-04-15 08:17:16 修改
阅读量826 收藏 12
点赞数 13
文章标签： java 开发语言 spring boot
于 2024-04-14 15:10:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a51514865/article/details/137745362
版权

基本介绍

过滤器，顾名思义就是对事物进行过滤的，在Web中的过滤器，当然就是对请求进行过滤，我们使用过滤器，就可以对请求进行拦截，让后做相应的处理，实现许多特殊功能。如登录控制，权限控制，过滤敏感词汇等。

过滤器原理

当我们使用过滤器时，过滤器会对浏览器的请求进行过滤，过滤器可以动态的分为3个部分，1.放行之前的代码，2.放行，3.放行后的代码，这3个部分分别会发挥不同作用。

  • 第一部分代码会对浏览器请求进行一次过滤，然后继续执行
  • 第二部分代码就是将浏览器请求放行，如果还有过滤器，那么就继续交给下一个过滤器
  • 第三部分代码就是对返回的Web资源再次进行过滤处理

我们使用过滤器，也就是说，不支请求会经过过滤器，我们的相应也会经过过滤器。
在这里插入图片描述

过滤器(Filter)接口

我们学习过滤器，肯定就要先看一下官方给我们提供的过滤器接口。下面我们使用idea来查看Filter的源码

package jakarta.servlet;

import java.io.IOException;

public interface Filter {
    default void init(FilterConfig filterConfig) throws ServletException {
    }

    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;

    default void destroy() {
    }
}

[!NOTE]

我们通过官方提供的过滤器可以看出来过滤器(Filter)使用起来还是比较简单的，下面我们就来学习如何使用过滤器(Filter)

使用过滤器(Filter)

我们使用过滤器肯定要导入相应的jar包才行，Filter就在servlet-api.jar中，我们将该jar包放到WEB-INF下的lib目录下面，然后加入项目。

创建过滤器(Filter)

[!NOTE]

我们创建Filter，只需要继承Filter接口就行

public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        
    }
}

[!NOTE]

Filter接口有3个方法，但是只有一个方法没有实现，我们只需要实现这个方法就行。我们可以发现上面的代码实现了doFilter方法，这个方法即使我们写过滤器的地方，具体逻辑就是和上面介绍的过滤器原理一样的。

使用过滤器(Filter)

  1. 我们先来感受一下如何使用Filter，细节我们后面慢慢说明。我们在上面创建的类中写入以下代码，并且加入一个WebFilter注解

    import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns = "/*")
public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("对request进行过滤");
        //放行
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("对response进行过滤");
    }
}

  2. 如果是SpringBoot项目则需要再启动类上添加@SevletComponentScan注解

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan(basePackages = "com.jesse.springbootmybatis.filter")
public class SpringbootMybatisApplication {}

  3. 如果是Spring项目则需要在web.xml文件中添加配置

    <filter>
  <filter-name>myFilter</filter-name>
  <filter-class>com.clucky.filter.MyFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>myFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

[!NOTE]

我们简单介绍上面的代码，@WebFilter(urlPatterns = "/*")表示对所有请求的进行过滤，而在doFilter中的放行代码，也就是filterChain.doFilter(servletRequest, servletResponse);这行代码就是对拦截进行放行，细节我们后面讲，现在先这么理解就行。

启动服务，然后我们在浏览器输入http://localhost:8080/filter/random，注意，filter是我们自己配置的web工程路径，后面的random随便输入的。我们下面来查看浏览器和控制台输出

浏览器输出：

在这里插入图片描述

控制台输出：
在这里插入图片描述

[!NOTE]

现在，我们就已经可以得出两个结论了，过滤器并不会判断资源是否存在，而只会对配置拦截路径进行拦截。拦截不仅会对请求进行拦截，而且还对响应进行拦截。

配置过滤器(Filter)拦截路径

配置Filter的拦截路径有2中方式，一种是注解，一种是xml方式，我们分别进行讲解。

注解方式

如果使用注解来进行配置，那么我们就需要使用@WebFilter，我们不说废话，直接看该注解的源码。

package jakarta.servlet.annotation;

import jakarta.servlet.DispatcherType;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebFilter {
    String description() default "";

    String displayName() default "";

    WebInitParam[] initParams() default {};

    String filterName() default "";

    String smallIcon() default "";

    String largeIcon() default "";

    String[] servletNames() default {};

    String[] value() default {};

    String[] urlPatterns() default {};

    DispatcherType[] dispatcherTypes() default {DispatcherType.REQUEST};

    boolean asyncSupported() default false;
}

里面的配置项还是有很多的，下面我们对常用的配置项进行说明：

  • filterName: 该filter的名字
  • initParams: 初始化参数
  • displayName: filter显示名称
  • servletNames: 指定对哪些sevlet进行过滤
  • asyncSupported: 是否支持异步模式
  • urlPatterns: 指定拦截路径
  • value: 指定拦截路径

[!CAUTION]

urlPatterns和value是一样的。urlPatterns和value只能配置一个，不能两个都配置，两个都配置会报错。

对于使用@WebFilter，里面有多个参数使用 ， 进行分隔。

@WebFilter(urlPatterns = "/*", filterName = "myFilter")
public class MyFilter implements Filter {}

[!TIP]

说明：如果我们仅仅需要配置一个拦截路径，那么我们可以直接简写@WebFilter("/filter/*")，如：@WebFilter("/*")就是拦截所有请求

xml方式

xml方式可以说是和Servlet使用xml配置方式一样了，这里就不废话，直接配置一个

<filter>
  <filter-name>myFilter</filter-name>
  <filter-class>com.clucky.filter.MyFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>myFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

这个就是xml配置方式，只不过吧注解换成了xml标签配置，里面属性都是一样的，这个和Servlet的配置方式基本一样，这里就不在赘述了。

过滤器(Filter)生命周期

我们都知道Servlet有一个生命周期，当然Filter也有一个生命周期，下面我们就来探讨一下Filter的生命周期。

Filter的生命周期和Servlet也十分相似，如果大家对Servlet的生命周期不怎么熟悉，那么可以看一下Servlet生命周期。

我们创建一个类，实现Filter的所有方法。

import jakarta.servlet.*;

import java.io.IOException;

public class LifeCycleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

    }

    @Override
    public void destroy() {
        
    }
}

理论说明

Filter有3个阶段，分别是初始化、拦截和过滤、销毁

  1. init（初始化阶段）: 当服务器启动时，我们的服务器(Tomcat)就会读取配置文件，扫描注解，然后来创建我们的Filter。
  2. doFilter（拦截和过滤阶段）: 只要请求资源的路径和拦截的路径相同，那么过滤器就会对请求进行过滤，这个阶段在服务器运行过程中会一直循环。
  3. destroy（销毁阶段）: 当Tomcat（服务器）关闭时，服务器创建的Filter也会随之销毁

代码演示

Filter的三个阶段就对应着Filter的3个方法，init方法会在Filter创建时调用，doFilter方法会在请求和拦截匹配时调用，destroy方法会在Filter销毁时调用。我们来对这些方法进行编写验证。

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;

@WebFilter(urlPatterns="/filter")
public class LifeCycleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter   ----->   init");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filter   ----->   doFilter");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("Filter   ----->   destroy");
    }
}

控制台输出：
在这里插入图片描述

[!NOTE]

上面的代码和控制台输出验证了我们对Filter生命周期的预想。

FilterConfig和FilterChain说明

FilterConfig和FilterChain这2个对象是由Tomcat（服务器）在创建和调用Filter对象时所传入的，这2个对象十分有用，FilterConfig对象可以读取我们配置的初始参数，FilterChain可以实现多个Filter之间的连接。

FilterConfig

老规矩，我们要学习一个对象，首先查看源代码

package jakarta.servlet;

import java.util.Enumeration;

public interface FilterConfig {
    String getFilterName();

    ServletContext getServletContext();

    String getInitParameter(String var1);

    Enumeration<String> getInitParameterNames();
}

里面的方法有4个，下面我们分别进行讲解

  • getFilterName(): 获取Filter的名称
  • getServletContext(): 获取ServletContext
  • getInitparamter(String var1): 获取配置的初始参数的值
  • getInitParamterNames(): 获取配置的所有参数名称

FilterConfig实例运用

我们在Filter.init()方法中使用FilterConfig来读取配置的数据库的信息，让后输出

java代码

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;
import java.util.Enumeration;

@WebFilter(urlPatterns="/filter")
public class LifeCycleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter   ----->   init");
        System.out.println("-----------获取全部key:value------------");
        //得到所有配置参数的名字
        Enumeration<String> names = filterConfig.getInitParameterNames();
        while (names.hasMoreElements()) {
            //得到每一个名字
            String name = names.nextElement();
            System.out.println(name+" = "+filterConfig.getInitParameter(name));
        }
        System.out.println("-----------end.....------------");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filter   ----->   doFilter");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("Filter   ----->   destroy");
    }
}

xml配置

<filter>
  <filter-name>myFilterConfig</filter-name>
  <filter-class>com.clucky.filter.MyFilterConfig</filter-class>
  <init-param>
    <param-name>driver</param-name>
    <param-value>com.mysql.jdbc.Driver</param-value>
  </init-param>
  <init-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/equip_employ_manage?serverTimezone=GMT</param-value>
  </init-param>
  <init-param>
    <param-name>username</param-name>
    <param-value>root</param-value>
  </init-param>
  <init-param>
    <param-name>password</param-name>
    <param-value>root</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>myFilterConfig</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

控制台输出

img

[!NOTE]

我们使用FilterConfig提供的方法就成功实现了功能，FilterConfig就是用来读取配置文件的。

FilterChain

我们在Filter.doFilter()方法中可以找到这个对象，还是先看源代码

package jakarta.servlet;

import java.io.IOException;

public interface FilterChain {
    void doFilter(ServletRequest var1, ServletResponse var2) throws IOException, ServletException;
}

[!NOTE]

我们查看源码，可以发现FilterChain就只有一个方法，其实这个方法即使用来对拦截进行放行的，如果有多个拦截器，那么就会继续调用下一个Filter进行拦截。doFilter()方法需要传入一个参数，一个是ServletRequest，一个是ServletResponse参数，这个直接传入进行。

Tomcat在调用过滤器时，默认就会传入Request和Response，这个参数封装了请求和响应，我们直接使用就行。

ServletRequest和ServletResponse可以直接转成HttpServletRequest和HttpServletResponse，然后使用相应的方法。

将ServletRequest和ServletResponse转成HttpServletRequest和HttpServletResponse

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
  HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;
}

FilterChain应用实例

我们前面一直都是一个Filter，现在我们来配置2个Filter，通过FilterChain来进行多个过滤

第一个Filter

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;

@WebFilter(urlPatterns = "/filter")
public class MyFilter01 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter01.doFilter()   --->   对request进行过滤");
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("MyFilter01.doFilter()   --->   对response进行过滤");
    }
}

第二个Filter

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;

@WebFilter(urlPatterns = "/filter")
public class MyFilter02 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter02.doFilter()   --->   对request进行过滤");
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("MyFilter02.doFilter()   --->   对response进行过滤");
    }
}

控制台输出
在这里插入图片描述

[!NOTE]

我们可以看见MyFilter01先进行过滤，然后交给MyFilter02,然后访问资源，然后MyFilter02对相应进行过滤，然后MyFilter01对响应进行过滤。图示如下：
在这里插入图片描述

[!NOTE]

我们先使用MyFilter01对请求进行过滤，那么很自然的，我们就是使用Filter02先对响应进行过滤

多个Filter的执行顺序

上面我们配置了2个过滤器，那么我们怎么知道那个过滤器先执行呢？其实大家可以直接使用代码进行验证，培养独立思考的习惯，这里我就直接给出答案了。

  • 如果我们是在web.xml中配置的过滤器，那么过滤器的执行顺序就是<fiter-mapping>在web配置的顺序，配置在上面那么就会先执行。
  • 如果我们是使用@WebFilter进行配置的，那么执行顺序就是字符比较顺序来执行，例如有2个过滤器AFilter和BFilter，那么AFilter就会先执行
  • 如果注解和xml混用，那么在web.xml中配置的会先执行

执行顺序验证

我这里就验证第一条，也就是web.xml中配置的顺序和<filter-mapping>顺序一样，其他大家感兴趣自己验证。

xml配置顺序 3 —> 1 —> 2

    <filter>
        <filter-name>filter03</filter-name>
        <filter-class>com.clucky.filter.MyFilter03</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>filter03</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter>
        <filter-name>filter01</filter-name>
        <filter-class>com.clucky.filter.MyFilter01</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>filter01</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter>
        <filter-name>filter02</filter-name>
        <filter-class>com.clucky.filter.MyFilter02</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>filter02</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

MyFilter01

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;

@WebFilter(urlPatterns = "/filter")
public class MyFilter01 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter01.doFilter()   --->   对request进行过滤");
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("MyFilter01.doFilter()   --->   对response进行过滤");
    }
}

MyFilter02

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;

@WebFilter(urlPatterns = "/filter")
public class MyFilter02 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter02.doFilter()   --->   对request进行过滤");
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("MyFilter02.doFilter()   --->   对response进行过滤");
    }
}

MyFilter03

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;

import java.io.IOException;

@WebFilter(urlPatterns = "/filter")
public class MyFilter03 implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter03.doFilter()   --->   对request进行过滤");
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("MyFilter03.doFilter()   --->   对response进行过滤");
    }
}

[!NOTE]

我们启动服务器，浏览器访问，然后查看控制台输出是不是我们配置的3 -> 1 -> 2的顺序

img

Filter应用实例(实现敏感词汇过滤)

我们学了那么多，现在来做一个实例，可以根据ip地址统计当前ip访问filter几次

代码实现

Filter代码

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;

@WebFilter(urlPatterns = "/filter")
public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("对request进行过滤");
        //强转成HttpServletRequest
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        //通过HttpServletRequest拿到ip
        String ip = request.getRemoteAddr();
        //通过HttpServletRequest拿到Session
        HttpSession session = request.getSession();
        //通过Session拿到当前ip访问服务的次数
        Integer count = (Integer) session.getAttribute("count");
        //判断是否第一次访问，如果是则返回1，不是则返回登录次数自增1
        count = count == null ? 1 : ++count;
        //写入到Session中
        session.setAttribute("count", count);
        //在控制台输出访问次数
        System.out.println("ip:" + ip + "访问次数：" + count);
        //放行
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("对response进行过滤");
    }
}

SpringBoot 启动类代码

@SpringBootApplication
@ServletComponentScan(basePackages = "com.jesse.springbootmybatis.filter")
public class SpringbootMybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisApplication.class, args);
    }

}

[!IMPORTANT]

前往别忘了在启动类上加上要扫描的包路径，不然Filter不生效

验证

[!NOTE]

我们输入http://localhost:8080/filter和http://127.0.0.1:8080/filter来访问服务

控制台输出
在这里插入图片描述

总结

[!IMPORTANT]

鉴于Filter会对所有请求进行拦截，实际应用场景还是对暴露的地址进行拦截。

感谢

这篇文档是在学习过程中看到CSDN中秃头披风侠.的JavaWeb过滤器(Filter)详解，是时候该把过滤器彻底搞懂了(万字说明)感觉写的很好，我自己就跟着整理了一份。

小呆哥哥
关注
  • 13
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java 过滤器filter防sql注入的实现代码
09-01
下面小编就为大家带来一篇java 过滤器filter防sql注入的实现代码。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java请求跨域处理过滤器
08-14
Java请求跨域处理过滤器
2024年最新java中的过滤器 --Filter，java面试高频知识点
最新发布
2401_83977626的博客
05-08 903
各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取NG开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**需要这份系统化的资料的朋友，可以点击这里获取。
Java Filter 过滤器详细介绍及实例代码
09-01
Filter也称之为过滤器，它是Servlet技术中最实用的技术，本文章WEB开发人员通过Filter技术，对web服务器管理的所有web资源进行拦截，从而实现一些特殊的功能,本文章将向大家介绍Java 中的 Filter 过滤器，需要的朋友可以参考一下
深入了解Java中的Filter过滤器
08-25
Filter也称之为过滤器，WEB开发人员通过Filter技术，对web服务器管理的所有web资源：从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。下面我们来简单学习一下吧
java filter过滤器
04-01
 过滤器Filter也具有生命周期：init()->doFilter()->destroy()，由部署文件中的filter元素驱动。在servlet2.4中，过滤器同样可以用于请求分派器，但须在web.xml中声明，<dispatcher>INCLUDE或FORWARD或REQUEST或ERROR</dispatcher>该元素位于filter-mapping中。
java过滤器（Filter）
热门推荐
爪哇人的博客
10-19 3万+
filter也称之为过滤器，它是javaWeb三大组件之一（Servlet程序、Listener监听器、Filter过滤器）既可以对请求进行拦截，也可以对响应进行处理。权限检查，日记操作、拦截请求、过滤操作、对请求字符设置编码。要想介绍filter，就必须介绍Filter中的三个方法。/*** web应用启动时，web服务器将创建Filter的实例对象，并调用init方法，读取web.xml的配置，完成对象的初始化功能，
Java中的过滤器Filter
m0_68988603的博客
05-07 1万+
一：Filter简介 二：关于Filter （一）如何使用Filter进行过滤 （二）过滤器链 (FilterChain) （三）Filter的配置 1.通过web.xml文件配置 2.通过注解配置 （四）Filter的生命周期 （五）中文乱码过滤器 三：测试案例 1.单个过滤器 2.多个过滤器
JavaWEB必知必会-Filter(过滤器)
黄乔国PHP
02-14 1431
filter是对客户端访问资源的过滤，符合条件放行,不符合条件不放行，并且可以对目标资源访问前后进行逻辑处理.
[Java]过滤器（Filter）
m0_71229255的博客
04-19 9790
当浏览器发送请求给服务器的时候，先执行过滤器，然后才访问Web的资源。服务器响应Response，从Web资源抵达浏览器之前，也会途径过滤器。 过滤器的用途：过滤一些敏感的字符串【规定不能出现敏感字符串】、避免中文乱码【规定Web资源都使用UTF-8编码】、权限验证【规定只有带Session或Cookie的浏览器，才能访问web资源】等等等。
Filter过滤器（Java学习笔记）
m0_59803718的博客
03-23 977
Filter:概率，配置，路径，生命周期，配置FilterConfig,Filter-Chain过滤链。Filter的基本使用
java过滤器的执行顺序_Java Filter过滤器（拦截路径的配置+拦截方式的配置+生命周期+多个过滤器的先后执行顺序）...
weixin_39723655的博客
02-12 2371
Java Filter过滤器+Listen监听器啥是过滤器顾名思义即过滤掉一些东西，比如我们经历的高考中考都是过滤器，他过滤掉一些在学习这一方面不是很好的人，而那些成绩好的人则升入高中，大学。但是java中的过滤器与生活中的过滤器的作用是相差无几的，即按照制定的一些规则来控制一些对象Filer的作用：过滤器是出于客户端与服务器端之间的一道过滤网，在访问资源之前，通过一系列的过滤器对请求进行修改，判...
java filter过滤器 读取配置文件的值
xm的博客
05-26 2135
1.获取application.properties的值 如userId=1 2.一般实体中采用@Value既可获取 @Value("userIdl") private String userId; 但是在filter中,需要用上下文对象来获取 filter的生命周期如下： web应用程序启动时，web服务器将创建Filter的实例对象 并调用其init方法，完成对象的初始化功能 从而为后续的用户请求作好拦截的准备工作 filter对象只会创建一次，init方法也只会执行一次 也就是程序刚刚启动的时.
Java之过滤器Filter
weixin_43790613的博客
02-04 4235
文章目录介绍实现利用过滤器解决的实际问题请求乱码处理非法请求拦截 介绍 过滤器是一种对象，它对资源的请求(servlet或静态内容)或来自资源的响应执行过滤任务，或者两者都执行，在一个web应用中，可以开发编写多个Filter，这些Filter组合起来组合成一个Filter链。若是一个过滤器链，先配置先执行，执行顺序是根据类名的的排序（请求时的执行顺序），响应时以相反的顺序执行， 过滤器在doFilter方法中执行过滤。 每个Filter都可以访问一个FilterConfig对象，它可以从中获取它的初始化参
Java Filter过滤器（idea）
qq_41296702的博客
05-28 3039
注意xml配置顺序：监听器-过滤器-servlet
JavaWeb经典_15_Filter 过滤器
qq_52922453的博客
05-25 1354
对象，只能为当前线程关联一个数据，如果要为当前线程关联多个数据，就需要使用多个ThreadLocal 对象实例。它可以给当前线程关联一个数据（可以是普通变量，可以是对象，也可以是数组，集合）方法中，随机生成一个变量（线程要关联的数据），然后以当前线程名为。过滤器它只关心请求的地址是否匹配，不关心请求的资源是否存在！的作用，它可以解决多线程的数据安全问题。标签配置，服务器出错之后，自动跳转的页面。标签配置，服务器出错之后，自动跳转的页面。，说明 之前使用过连接，操作过数据库。中否包含有用户登录的信息即可！
Java体系知识之过滤器Filter
qq_45464872的博客
12-02 709
Java体系知识之过滤器Filter 1 技术简介 2 过滤器使用步骤（重点） 2.1 使用步骤 2.2 案例 3 过滤器执行过程（重点） 3.1 内容概述 3.2 案例 4 过滤器生命周期 4.1
Java过滤器Filter讲解（Java基础）
程宇寒
05-12 2629
Java过滤器Filter讲解
【JavaWeb】 三大组件之过滤器 Filter
dandelionl_的博客
08-02 2053
过滤器（Filter）是Java Web应用中的一种组件，它在请求到达Servlet或JSP之前或者响应送回客户端之前，对请求和响应进行预处理和后处理操作。通过使用过滤器，可以对请求进行过滤，拦截请求，修改请求参数，在请求被处理之前进行一些预处理操作；同时也可以对响应进行过滤，对响应内容进行修改，添加一些额外的处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值