JavaWeb学习-过滤器

已于 2022-11-26 18:50:01 修改
阅读量1k 收藏 2
点赞数 4
分类专栏： 服务端-JavaWeb 文章标签： servlet
于 2022-11-26 18:12:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/listeningdu/article/details/128054899
版权

基本介绍 

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

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

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

我们使用过滤器，也就是说，不止请求会经过过滤器，我们的响应也会经过过滤器。

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

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

使用过滤器(Filter) 

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

创建过滤器(Fliter)

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

import javax.servlet.*;
import java.io.IOException;
 
public class MyFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 
    }
}

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

使用过滤器(Filter)

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

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
 
@WebFilter("/*")
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进行过滤");
    }
}

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

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

游览器输出 

控制台输出 

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

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

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

注解方式

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

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

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

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

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

      说明：如果我们仅仅需要配置一个拦截路径，那么我们可以直接简写@WebLister("拦截路径")，如@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 javax.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个阶段，分别是初始化，拦截和过滤，销毁。

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

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

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
 
@WebFilter("/*")
public class LifeCycleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //这个方法就是初始化方法，在Filter创建时调用
        System.out.println("调用了init()方法");
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //这个方法就是过滤和拦截的方法，当请求和拦截匹配时调用
        System.out.println("调用了doFilter()方法");
    }
 
    @Override
    public void destroy() {
        //这个方法就是销毁方法，在Filter销毁前调用
        System.out.println("调用了destroy()方法");
    }
}

启动服务器控制台输出

进行拦截时控制台输出  

关闭服务器控制台输出 


 

       都和我们预想的一样，到此，我们就成功验证了Filter的生命周期。 

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

FilterConfig

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

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

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

FilterConfig实例运用

        我们在init方法中使用FilterConfig来读取配置的数据库的信息，然后输出。

java代码

import javax.servlet.*;
import java.io.IOException;
import java.util.Enumeration;
 
public class MyFilterConfig implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        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 {
    }
 
    @Override
    public void 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>

启动服务器，控制台输出

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

FilterChain 

        一样，我们还是先来查看源代码以及类图

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

        Tomcat在调用过滤器时，默认就会传入Request和Response，这个参数封装了请求和响应，我们直接使用就行。ServletResquest和ServletResponse可以直接强转成HttpServletRequest和HttpServletResponse，然后使用相应的方法。

 将ServletRequest转成HttpServletRequest

FilterChain应用实例

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

第一个Filter

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
 
@WebFilter("/*")
public class Filter01 implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器01对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器01对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

 第二个过滤器

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
 
@WebFilter("/*")
public class Filter02 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器02对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器02对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

    启动服务器，然后我们游览器输入http://localhost:8080/filter/abc（filter是我配置的web工程路径）来进行访问，查看控制台输出。 

    我们可以看见Filter01先进行过滤，然后交给Filter02，然后访问资源，然后Filter02对响应进行过滤，然后Filter01对响应进行过滤。图示如下：

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

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

  • 如果我们是在web.xml中配置的过滤器，那么过滤器的执行顺序就是<filter-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.Filter03</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.Filter01</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.Filter02</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>filter02</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

Filter01

import javax.servlet.*;
import java.io.IOException;
 
public class Filter01 implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器01对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器01对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

Filter02

import javax.servlet.*;
import java.io.IOException;
 
public class Filter02 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器02对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器02对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

Filter03

import javax.servlet.*;
import java.io.IOException;
 
public class Filter03 implements Filter{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器03对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器03对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

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

 

  发现执行顺序果然是这样，另外2个的验证大家感兴趣可以自己验证，我这里就不验证了，如果嫌麻烦，那么记住就行了。 

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

        我们学了那么多，现在来做一个实例，我们写一个评论页面，可以进行评论，如果评论中含有我们定义的敏感词汇，那么我们就进行过滤，使用**来进行代替。

代码实现

jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>评论</title>
</head>
<body>
<h1>输入评论内容</h1>
<form action="${pageContext.request.contextPath}/comment" method="post">
    <textarea name="message" cols="30" rows="10"></textarea>
    <input type="submit" value="提交">
</form>
<p >${requestScope.get("name")}<span style="color: red">${requestScope.get("comment")}</span></p>
</body>
</html>

 Filter代码

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
@WebFilter(servletNames = {"comment"},initParams = {@WebInitParam(name = "sensitiveWord", value = "zz")})
public class CommentFilter implements Filter {
 
    private List<String> sensitiveWords = new ArrayList<>();
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //得到敏感词汇
        String word = filterConfig.getInitParameter("sensitiveWord");
        //加入集合
        sensitiveWords.add(word);
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //设置编码
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=utf-8");
        //得到评论
        String message = servletRequest.getParameter("message");
        for (String sensitiveWord : sensitiveWords) {
            //对所有敏感词汇进行过滤
            if (message.contains(sensitiveWord)){
                //替换敏感词汇
                message = message.replace(sensitiveWord, "**");
            }
        }
        //存入request域
        servletRequest.setAttribute("comment",message);
        //放行
        filterChain.doFilter(servletRequest,servletResponse);
    }
 
    @Override
    public void destroy() {
    }
}

Servlet代码

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
import java.util.HashSet;
 
@WebServlet(name = "comment",value = "/comment")
public class CommentServlet extends HttpServlet {
 
    //记录评论敏感词汇的ip
    private HashSet<String> hashSet = new HashSet<>();
 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String message = request.getParameter("message");
        String comment = (String) request.getAttribute("comment");
        if (message.equals(comment)){
            System.out.println("没有敏感词汇.....");
            //设置名字
            request.setAttribute("name","good boy：");
        }else {
            //有敏感词汇，记录IP
            String localAddr = request.getLocalAddr();
            System.out.println(localAddr);
            hashSet.add(localAddr);
            //设置名字
            request.setAttribute("name","bad boy：");
        }
        //转发到comment.jsp页面
        request.getRequestDispatcher("/comment.jsp").forward(request,response);
    }
 
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

 代码验证

        我们输入http://localhost:8080/filter/comment.jsp，来访问jsp页面.

 

总结 

        通过上面的学习，相信大家对Filter的掌握肯定也上了一个台阶，但是理论知识的掌握并不能代码大家已经真正学会了，打开编译器，开始练习吧，技术就就是靠一行行代码堆起来的！！！


原文链接：https://blog.csdn.net/m0_51545690/article/details/123677340

虫儿飞..
关注
专栏目录
JavaWeb过滤器(Filter)详解，是时候该把过滤器彻底搞懂了(万字说明)
sebeefe的博客
07-29 691
过滤器，顾名思义就是对事物进行过滤的，在Web中的过滤器，当然就是对请求进行过滤，我们使用过滤器，就可以对请求进行拦截，然后做相应的处理，实现许多特殊功能。如登录控制，权限管理，过滤敏感词汇等.通过上面的学习，相信大家对Filter的掌握肯定也上了一个台阶，但是理论知识的掌握并不能代码大家已经真正学会了，打开编译器，开始练习吧，技术就就是靠一行行代码堆起来的！！！先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。httpshttpshttps。...
JavaWeb过滤器
胡根得 天行健，君子以自强不息。
01-15 1278
1、过滤器概述 　　过滤器是JavaWeb三大组件之一，与Servlet很相似，不它过滤器是用来拦截请求的，而不是处理请求的。当用户请求某个Servlet时，会先执行部署在这个请求上的Filter，如果Filter“放行”，那么会继承执行用户请求的Servlet；如果Filter不“放行”，那么就不会执行用户请求的Servlet。 　　其实可以这样理解，当用户请求某个Servlet时，
JavaWeb之过滤器
最新发布
gege_0606的博客
09-29 860
当客户端发送请求时，Servlet容器根据配置将请求交给符合条件的过滤器。过滤器是Java Servlet规范中定义的组件，用于在请求到达Servlet之前或响应返回客户端之前，对请求或响应进行拦截和处理。：如果需要排除某些路径，可以在过滤器中添加条件判断，或者在配置中精确指定需要过滤的路径。这个过滤器将在初始化时读取一个配置参数，并在处理请求时打印过滤器的名称和上下文路径。是过滤器链对象，允许过滤器将请求和响应传递给下一个过滤器或目标资源。方法是过滤器的核心，它包含了对请求和响应的处理逻辑。
javaweb过滤器
mikou168的博客
07-04 293
1、过滤器三部分：过滤源（用户请求）——&gt;过滤规则——&gt;过滤结果2、过滤器不处理结果，只做辅助性操作3、定义：过滤器是一个【服务器端】的组件，它可以【截取用户端的请求和响应信息】，并对这些信息过滤。4.过滤器的工作原理原理：用户发送请求到过滤器，过滤器将用户请求发送到web资源，web资源将响应发送到过滤器，过滤器将响应发送给用户。5.过滤器的生命周期1.在web容器启动时依据web....
myAutoLoginWeb.rar JavaWeb-过滤器Filter学习(三)实现用户的自动登录与IP黑名单过滤
01-09
JavaWeb-过滤器Filter学习(三)实现用户的自动登录与IP黑名单过滤JavaWeb-过滤器Filter学习(三)实现用户的自动登录与IP黑名单过滤JavaWeb-过滤器Filter学习(三)实现用户的自动登录与IP黑名单过滤JavaWeb-过滤器Filter...
JavaWeb13-过滤器与监听器.rar
03-29
JSP+servlet+javabean学习 里面有ＰＤＦ文件对该章节的详细讲解，培训老师才讲的到的，非常详细......资源内容如下： JavaWeb02-request与response.rar JavaWeb03-会话跟踪cookie与...JavaWeb13-过滤器与监听器.rar
javaweb520-JavaWeb-master.zip
02-06
13. **Web.xml配置**：这是JavaWeb应用的部署描述符，用于配置Servlet、过滤器、监听器等组件。 以上就是JavaWeb开发的一些核心知识点。这个压缩包中的"JavaWeb"目录可能包含了项目的源代码、配置文件、资源文件等...
Javaweb--狂神版
12-26
"狂神版"很可能指的是由某位知名讲师或专家整理的一套JavaWeb学习资源，这个压缩包可能包含了一个完整的JavaWeb项目实例——SMBMS。 SMBMS（Small and Medium Business Management System）可能是小型和中型企业...
JavaWeb--- Filter（过滤器）学习
qq_42847094的博客
07-26 1605
Filter（过滤器） 处理中文乱码 登录验证…… 1、xml依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/
（重点）JavaWeb（入门篇18）过滤器Filter实现Servlet乱码问题案例
半亩方糖
06-18 275
一、过滤器Filter实现Servlet乱码问题案例 1. 实现功能， 添加一个过滤器，实现所有访问 /filter/* 映射下的Servlet都 解决中文乱码问题 2.核心代码 注意一定要转释放不然其他Servlet拿不到请求。 servletRequest.setCharacterEncoding("utf-8"); servletResponse.setCharacterEncoding("utf-8"); servletResponse.setContentType("text/html;chars
JavaWeb——过滤器
HL031125的博客
05-24 1235
过滤器是软件应用中常见的一种功能，用于从大量数据或信息中筛选出符合特定条件的子集或结果。它们在不同的上下文中有着广泛的应用，从数据处理到用户界面呈现，都能发挥重要作用。
【JavaWeb】之过滤器
小新要变强的博客
10-23 3760
JavaWeb基础Filter过滤器相关知识详细介绍~
JavaWeb三大组件之一Filter(过滤器)
yahid的博客
06-04 2382
拦截所有访问web资源的请求或者响应(servlet、Jsp页面、HTML页面)，从而实现我们自己的业务逻辑，这些逻辑可以是实现访问权限的控制、过滤敏感词、压缩响应等功能。过滤器是"链接"在容器的处理过程中的，它会在servlet处理器之前访问进入的请求，并且在响应信息返回客服端之前访问这些响应信息。这样就可以动态的修改请求和响应中的内容。创建web项目： 或者像这样建立web项目： 添加Tomcat服务器： 如果没有SmartTomcat，只有Tomcat像下面图片中这样： 则选择Tomcat里面的
Java Web之过滤器（Filter）
Garry
10-12 1530
过滤器(Filter) 过滤器实际上就是对web资源进行拦截，做一些处理后再交给下一个过滤器或servlet处理 通常都是用来拦截request进行处理的，也可以对返回的response进行拦截处理 大概流程图如下 应用场景 自动登录 统一设置编码格式 访问权限控制 敏感字符过滤等 创建Filter 在Servl...
JavaWeb过滤器入门与实战应用
过滤器学习笔记一深入解析了JavaWeb中的过滤器机制，这是Web开发中的一个重要组成部分，主要用于控制和增强HTTP请求的流程。过滤器是一种拦截器，它不同于Servlet，其主要任务是拦截请求，而不是处理请求本身。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值