精华内容
下载资源
问答
  • Filter过滤器(超详细)

    万次阅读 多人点赞 2021-01-17 16:03:49
    Filter 过滤器它是 JavaWeb 的三大组件之一。 三大组件分别是:Servlet 程序、Listener 监听器、Filter 过滤器 Filter 过滤器它是 JavaEE 的规范。也就是接口 Filter 过滤器它的作用是:拦截请求,过滤响应。 拦截...

    声明:本文是根据博主学习内容所整理得的笔记,仅作为交流学习使用,需要观看视频的请移步:http://www.atguigu.com/

    1.Filter ?什么是过滤器

    1. Filter 过滤器它是 JavaWeb 的三大组件之一。
      三大组件分别是:Servlet 程序、Listener 监听器、Filter 过滤器
    2. Filter 过滤器它是 JavaEE 的规范。也就是接口
    3. Filter 过滤器它的作用是:拦截请求,过滤响应。

    拦截请求常见的应用场景有:
    1.权限检查 2.日记操作 3.事务管理 ……等等

    2.Filter 初体验

    要求:在你的 web 工程下,有一个 admin 目录。这个 admin 目录下的所有资源(html 页面、jpg 图片、jsp 文件…等等)都必须是用户登录之后才允许访问。

    思考:根据之前我们学过内容。我们知道,用户登录之后都会把用户登录的信息保存到 Session 域中。所以要检查用户是否登录,可以判断 Session 中否包含有用户登录的信息,即可!!!

    a.jsp:

    <body>
        <%
            Object user = session.getAttribute("user");
            // 如果 user = null; 说明 user 还没有登陆
            if (user == null) {
                request.getRequestDispatcher("/login.jsp").forward(request,response);
                return;     // 一般请求转发后,就不允许再执行任何代码,这里就直接return了
            }
        %>
        我是 a.jsp 文件
    </body>
    

    但是在 html 页面当中应该怎么写呢? 需要使用 Filter 过滤器

    Filter 的工作流程图:

    在这里插入图片描述

    Filter 过滤器的使用步骤:

    ​ 1.编写一个类去实现 Filter 接口
    ​ 2.实现过滤方法 doFilter()
    ​ 3.到 web.xml 中去配置 Filter 的拦截路径

    AdminFilter.java(继承了Filter类):

    /**
     * doFilter 方法,专门用来拦截请求,可以做权限检查
     * @param servletRequest
     * @param servletResponse
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        HttpSession session = httpServletRequest.getSession();
        Object user = session.getAttribute("user");
        // 如果 user = null; 说明 user 还没有登陆
        if (user == null) {
            httpServletRequest.getRequestDispatcher("/login.jsp").forward(httpServletRequest,servletResponse);
            return;     // 一般请求转发后,就不允许再执行任何代码,这里就直接return了
        } else {
            // 让程序继续往下访问用户的目标资源
            filterChain.doFilter(servletRequest,servletResponse);
        }
    }
    

    这时候已经有权限检查代码了,但是还不知道要去哪检查,这时候需要去 xml 配置一下检查什么。

    <!--filter标签用于配置一个Filter过滤器-->
    <filter>
        <!--给 filter 起一个别名-->
        <filter-name>Adminfilter</filter-name>
        <!--配置 filter 全类名-->
        <filter-class>com.filter.AdminFilter</filter-class>
    </filter>
    <!--配置 filter 过滤器的拦截路径-->
    <filter-mapping>
        <!--表示当前的拦截路径给哪个filter过滤器使用-->
        <filter-name>Adminfilter</filter-name>
        <!--配置拦截路径
        / 表示请求地址为: http://ip:port/工程路径/ 映射到 IDEA 的 web 目录
        /admin/* 表示请求地址为 http://ip:port/工程路径/admin/*  (admin 下的全部)
        -->
        <url-pattern>/admin/*</url-pattern>
    </filter-mapping>
    

    完整的用户登录和权限检查:

    login.jsp:

    <body>
        这是登陆页面:login.jsp 页面 <br>
        <form action="http://localhost:8080/15_filter/loginServlet" method="get">
            用户名:<input type="text" name="username"/> <br>
            密码:<input type="password" name="password"/> <br>
            <input type="submit" />
        </form>
    </body>
    

    LoginServlet.java:

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html; charset=UTF-8");    //解决响应乱码
    
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        if ("wzg168".equals(username) && "123456".equals(password)) {
            req.getSession().setAttribute("user",username);
            resp.getWriter().write("登录 成功!!!");
        } else {
            req.getRequestDispatcher("/login.jsp").forward(req,resp);
        }
    }
    

    3.Filter 的生命周期

    Filter 的生命周期包含几个方法

    1. 构造器方法

    2. init 初始化方法
      第 1,2 步,在 web 工程启动的时候执行(Filter 已经创建)
      在这里插入图片描述

    3. doFilter 过滤方法
      第 3 步,每次拦截到请求,就会执行(访问 admin 目录下的 a.jsp 页面,访问一次,拦截一次请求)
      在这里插入图片描述

    4. destroy 销毁
      第 4 步,停止 web 工程的时候,就会执行(停止 web 工程,也会销毁 Filter 过滤器)
      在这里插入图片描述

    4.FilterConfig 类

    FilterConfig 类见名知义,它是 Filter 过滤器的配置文件类。
    Tomcat 每次创建 Filter 的时候,也会同时创建一个 FilterConfig 类,这里包含了 Filter 配置文件的配置息。

    FilterConfig 类的作用是获取 filter 过滤器的配置内容

    1. 获取 Filter 的名称 filter-name 的内容
    2. 获取在 Filter 中 wen.xml 配置的 init-param 初始化参数
    3. 获取 ServletContext 对象
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("2.Filter 初始化方法 init(FilterConfig filterConfig)");
    
    //        1. 获取 Filter 的名称 filter-name 的内容 (web-xml 中配置的名称)
            System.out.println("filter-name:" + filterConfig.getFilterName());
    //        2. 获取在 web.xml 中配置的 init-param 初始化参数
            System.out.println("初始化参数username的值是:" + filterConfig.getInitParameter("username"));
            System.out.println("初始化参数url的值是:" + filterConfig.getInitParameter("url"));
    //        3. 获取 ServletContext 对象
            System.out.println(filterConfig.getServletContext());
    
        }
    

    5.FilterChain 过滤器链

    Filter 过滤器
    Chain 链,链条
    FilterChain 就是过滤器链(多个过滤器如何一起工作)

    FilterChain.doFilter() 方法的作用:

    ​ 1.执行下一个Filter过滤器(如果有Filter)
    ​ 2.执行目标资源

    Filter过滤器的执行细节:

    在这里插入图片描述

    Filter1.java:

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filter1前置代码");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("Filter1后置代码");
    }
    

    Filter2.java:

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Filter2前置代码");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("Filter2后置代码");
    }
    

    target.jsp:

    <body>
        <%
            System.out.println("target.jsp页面执行了");
        %>
    </body>
    

    web.xml:

    <filter>
        <filter-name>Filter1</filter-name>
        <filter-class>com.filter.Filter1</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>Filter1</filter-name>
        <url-pattern>/target.jsp</url-pattern>
    </filter-mapping>
    <filter>
        <filter-name>Filter2</filter-name>
        <filter-class>com.filter.Filter2</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>Filter2</filter-name>
        <url-pattern>/target.jsp</url-pattern>
    </filter-mapping>
    

    访问 target.jsp:
    在这里插入图片描述

    可见其执行顺序。

    另外,要是在 xml 中,把 Filter2 放在 Filter1 上面,就会先执行 Filter2,再执行 Filter1。也就是说:在多个 Filter 过滤器执行的时候,他们的优先顺序是由他们在 web.xml 中从上到下配置的顺序决定的!

    补充:
    多个Filter过滤器执行的特点:

    1. 所有filter和目标资源默认都执行同一个线程中
    2. 多个Filter过滤器同时执行的时候,他们都要使用同一个Request对象

    补充1演示:在 Filter1 和 Filter2 的 filterChain.doFilter(servletRequest,servletResponse); 的前后,都使用 Thread.currentThread().getName() 获取线程名,另外 target.jsp 页面中也使用 Thread.currentThread().getName() 获取线程名,运行结果显示:

    在这里插入图片描述

    访问:http://localhost:8080/15_filter/target.jsp
    结果显示,线程相同。

    补充2演示:在 Filter1 和 Filter2 的 filterChain.doFilter(servletRequest,servletResponse); 的前后,都使用servletRequest.getParameter(“username”) 获取 request 对象的 name,target.jsp 中使用 request.getParameter(“username”) 获取 request 对象的 name,运行结果显示:
    在这里插入图片描述

    访问:http://localhost:8080/15_filter/target.jsp?username=12345
    结果显示, request 对象相同。

    6.Filter 的拦截路径

    –精确匹配

    <filter-mapping>
        <filter-name>Filter2</filter-name>
        <url-pattern>/target.jsp</url-pattern>  <!--精确匹配-->
    </filter-mapping>
    

    以上配置的路径,表示请求地址必须为:http://ip:port/工程路径/target.jsp

    –目录匹配

    <filter-mapping>
        <filter-name>Adminfilter</filter-name>
        <url-pattern>/admin/*</url-pattern> <!--目录匹配-->
    </filter-mapping>
    

    以上配置的路径,表示请求地址必须为:http://ip:port/工程路径/admin/*

    –后缀名匹配

    <filter-mapping>
        <filter-name>Filter2</filter-name>
        <url-pattern>*.html</url-pattern>  <!--后缀名匹配-->
    </filter-mapping>
    

    以上配置的路径,表示请求地址必须以.html 结尾才会拦截到

    <filter-mapping>
        <filter-name>Filter2</filter-name>
        <url-pattern>*.do</url-pattern>  <!--后缀名匹配-->
    </filter-mapping>
    

    以上配置的路径,表示请求地址必须以.do 结尾才会拦截到

    <filter-mapping>
        <filter-name>Filter2</filter-name>
        <url-pattern>*.action</url-pattern>  <!--后缀名匹配-->
    </filter-mapping>
    

    以上配置的路径,表示请求地址必须以.action 结尾才会拦截到

    <filter-name>Filter2</filter-name>
    <url-pattern>*.do</url-pattern>  <!--后缀名匹配-->
    
    ```

    以上配置的路径,表示请求地址必须以.do 结尾才会拦截到

    <filter-mapping>
        <filter-name>Filter2</filter-name>
        <url-pattern>*.action</url-pattern>  <!--后缀名匹配-->
    </filter-mapping>
    

    以上配置的路径,表示请求地址必须以.action 结尾才会拦截到

    Filter 过滤器它只关心请求的地址是否匹配,不关心请求的资源是否存在(只看后缀名是否等于,不关心后缀名在现实中是否真的存在)!!!

    展开全文
  • Filter过滤器工作原理

    千次阅读 2019-01-21 10:46:43
    Filter过滤器工作原理 Filter简介 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术之一,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态html文件等进行...

    Filter过滤器工作原理

    Filter简介

    Filter也称之为过滤器,它是Servlet技术中最激动人心的技术之一,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp,
    Servlet, 静态图片文件或静态html文件等进行拦截,从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等
    一些高级功能。
      Servlet API中提供了一个Filter接口,开发web应用时,如果编写的Java类实现了这个接口,则把这个java类称之为过滤器Filter。通过Filter
    技术,开发人员可以实现用户在访问某个目标资源之前,对访问的请求和响应进行拦截,Filter接口源代码:

    //
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package javax.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() {
        }
    }
    
    

    Filter工作原理

    Filter接口中有一个doFilter方法,当我们编写好Filter,并配置对哪个web资源进行拦截后,WEB服务器每次在调用web资源的service方法之前,
    都会先调用一下filter的doFilter方法,因此,在该方法内编写代码可达到如下目的:
    ​ 调用目标资源之前,让一段代码执行。
    ​ 是否调用目标资源(即是否让用户访问web资源)。
    ​ 调用目标资源之后,让一段代码执行。
      web服务器在调用doFilter方法时,会传递一个filterChain对象进来,filterChain对象是filter接口中最重要的一个对象,它也提供了一个
    doFilter方法,开发人员可以根据需求决定是否调用此方法,调用该方法,则web服务器就会调用web资源的service方法,即web资源就会被访问,
    否则web资源不会被访问。

    Spring中的filter过滤器

    在这里插入图片描述

    Spring的web包中中有很多过滤器,这些过滤器无一例外的继承了Filter接口,实现的方式大致可以分为以下几类:

    • 直接实现Filter,这一类过滤器只有CompositeFilter;
    • 继承抽象类GenericFilterBean,该类实现了javax.servlet.Filter,这一类的过滤器只有一个,即DelegatingFilterProxy;
    • 继承抽象类OncePerRequestFilter,该类为GenericFilterBean的直接子类,这一类过滤器包括CharacterEncodingFilter、HiddenHttpMethodFilter、HttpPutFormContentFilter、RequestContextFilter和ShallowEtagHeaderFilter;
    • 继承抽象类AbstractRequestLoggingFilter,该类为OncePerRequestFilter的直接子类,这一类过滤器包括CommonsRequestLoggingFilter、Log4jNestedDiagnosticContextFilter和ServletContextRequestLoggingFilter。

    本文要讲述的,即是GenericFilterBean、OncePerRequestFilter和AbstractRequestLoggingFilter。

    GenericFilterBean

    抽象类GenericFilterBean实现了javax.servlet.Filter、org.springframework.beans.factory.BeanNameAware、org.springframework.context.EnvironmentAware、org.springframework.web.context.ServletContextAware、org.springframework.beans.factory.InitializingBean和org.springframework.beans.factory.DisposableBean五个接口,作用如下:

    ​ (1) Filter,实现过滤器;

    ​ (2) BeanNameAware,实现该接口的setBeanName方法,便于Bean管理器生成Bean;

    ​ (3) EnvironmentAware,实现该接口的setEnvironment方法,指明该Bean运行的环境;

    ​ (4) ServletContextAware,实现该接口的setServletContextAware方法,指明上下文;

    ​ (5) InitializingBean,实现该接口的afterPropertiesSet方法,指明设置属性生的操作;

    ​ (6) DisposableBean,实现该接口的destroy方法,用于回收资源。

    ​ GenericFilterBean的工作流程是:init-doFilter-destory,其中的init和destory在该类中实现,doFilter在具体实现类中实现。init的代码如下:

    /**
    	 * Standard way of initializing this filter.
    	 * Map config parameters onto bean properties of this filter, and
    	 * invoke subclass initialization.
    	 * @param filterConfig the configuration for this filter
    	 * @throws ServletException if bean properties are invalid (or required
    	 * properties are missing), or if subclass initialization fails.
    	 * @see #initFilterBean
    	 */
    	@Override
    	public final void init(FilterConfig filterConfig) throws ServletException {
    		Assert.notNull(filterConfig, "FilterConfig must not be null");
    
    		this.filterConfig = filterConfig;
    
    		// Set bean properties from init parameters.
    		PropertyValues pvs = new FilterConfigPropertyValues(filterConfig, this.requiredProperties);
    		if (!pvs.isEmpty()) {
    			try {
    				BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
    				ResourceLoader resourceLoader = new ServletContextResourceLoader(filterConfig.getServletContext());
    				Environment env = this.environment;
    				if (env == null) {
    					env = new StandardServletEnvironment();
    				}
    				bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, env));
    				initBeanWrapper(bw);
    				bw.setPropertyValues(pvs, true);
    			}
    			catch (BeansException ex) {
    				String msg = "Failed to set bean properties on filter '" +
    					filterConfig.getFilterName() + "': " + ex.getMessage();
    				logger.error(msg, ex);
    				throw new NestedServletException(msg, ex);
    			}
    		}
    
    		// Let subclasses do whatever initialization they like.
    		initFilterBean();
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Filter '" + filterConfig.getFilterName() + "' configured for use");
    		}
    	}
    
    

    该方法来自于javax.servlet.Filter,即过滤器的初始化,它的主要工作集中于以下几行代码:

    // 从properties文件中获取值,这里是web.xml  
    PropertyValues pvs = new FilterConfigPropertyValues(filterConfig, this.requiredProperties);  
    // 设置bean适配器  
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);  
    // 设置上下文,这里的servletContext的设定继承自ServletContextAware的setter  
    ResourceLoader resourceLoader = new ServletContextResourceLoader(filterConfig.getServletContext());  
    // 将上下文信息和环境信息设置到bean适配器中,这里的environment来自于EnvironmentAware的setter  
    bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.environment));  
    // 初始化bean适配器  
    initBeanWrapper(bw);  
    // 将从properties中获取的资源放置到bean适配器  
    bw.setPropertyValues(pvs, true);  
    // 初始化bean  
    initFilterBean();  
    

    其中initFilterBean方法在两个位置起作用,一处是上文所述的init方法,另一处是afterPropertiesSet方法,在调用该方法前,需要保证用于Filter的所有的bean都已被设置,该方法由子类实现。

    ​ GenericFilterBean中包含一个内部私有类FilterConfigPropertyValues,主要用于将web.xml中定义的init-param的值取出。

    OncePerRequestFilter

    ​ 抽象类oncePerRequestFilter继承自GenericFilterBean,它保留了GenericFilterBean中的所有方法并对之进行了扩展,在oncePerRequestFilter中的主要方法是doFilter,代码如下:

    /** 
         * This <code>doFilter</code> implementation stores a request attribute for 
         * "already filtered", proceeding without filtering again if the 
         * attribute is already there. 
         * @see #getAlreadyFilteredAttributeName 
         * @see #shouldNotFilter 
         * @see #doFilterInternal 
         */  
        public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)  
                throws ServletException, IOException {  
      
            if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {  
                throw new ServletException("OncePerRequestFilter just supports HTTP requests");  
            }  
            HttpServletRequest httpRequest = (HttpServletRequest) request;  
            HttpServletResponse httpResponse = (HttpServletResponse) response;  
                    // 调用GenericFilterBean的getFilterName方法返回已过滤的属性名  
            String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();  
            if (request.getAttribute(alreadyFilteredAttributeName) != null || shouldNotFilter(httpRequest)) {  
                // 未调用该过滤器或已过滤  
                filterChain.doFilter(request, response);  
            }  
            else {  
                // 进行过滤  
                request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);  
                try {  
                    doFilterInternal(httpRequest, httpResponse, filterChain);  
                }  
                finally {  
                    // Remove the "already filtered" request attribute for this request.  
                    request.removeAttribute(alreadyFilteredAttributeName);  
                }  
            }  
        }  
    

    在doFilter方法中,doFilterInternal方法由子类实现,主要作用是规定过滤的具体方法。

    AbstractRequestLoggingFilter

    AbstractRequestLoggingFilter继承了OncePerRequestFilter并实现了其doFilterInternal方法,该方法代码如下:

    /** 
         * Forwards the request to the next filter in the chain and delegates down to the subclasses to perform the actual 
         * request logging both before and after the request is processed. 
         * 
         * @see #beforeRequest 
         * @see #afterRequest 
         */  
        @Override  
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
                throws ServletException, IOException {  
            if (isIncludePayload()) {  
                            // 若日志中包含负载,则重置request  
                request = new RequestCachingRequestWrapper(request);  
            }  
                    // 过滤前执行的方法  
            beforeRequest(request, getBeforeMessage(request));  
            try {  
                            // 执行过滤  
                filterChain.doFilter(request, response);  
            }  
            finally {  
                            // 过滤后执行的方法  
                afterRequest(request, getAfterMessage(request));  
            }  
        }  
    

    doFilter方法中的beforeRequest和afterRequest方法由子类实现,RequestCachingRequestWrapper为AbstractRequestLoggingFilter的内部内,主要作用是重置request。

    区别

    我们在使用过滤器时,通常没必要知道GenericFilterBean、OncePerRequestFilter和AbstractRequestLoggingFilter,但不防碍我们了解这几个类,就上文所述,

    AbstractRequestLoggingFilter继承自OncePerRequestFilter

    OncePerRequestFilter继承自GenericFilterBean

    所以我们知道,genericFilterBean是任何类型的过滤器的一个比较方便的超类,

    这个类主要实现的就是从web.xml文件中取得init-param中设定的值,然后对Filter进行初始化(当然,其子类可以覆盖init方法)

    OncePerRequestFilter继承自GenericFilterBean,那么它自然知道怎么去获取配置文件中的属性及其值,所以其重点不在于取值,而在于确保在接收到一个request后,每个filter只执行一次*它的子类只需要关注Filter的具体实现即doFilterInternal*。

    AbstractRequestLoggingFilter是对OncePerRequestFilter的扩展,它除了遗传了其父类及祖先类的所有功能外,还在doFilterInternal中决定了在过滤之前和之后执行的事件,它的子类关注的是beforeRequest和afterRequest。

    总体来说,这三个类分别执行了Filter的某部分功能,当然,具体如何执行由它们的子类规定,若你需要实现自己的过滤器,也可以根据上文所述继承你所需要的类。

    展开全文
  • Filter 过滤器的介绍及使用

    千次阅读 2020-08-28 15:43:51
    文章目录Filter过滤器一、Filter过滤器的介绍二、Filter过滤器的使用三、Filter过滤器的生命周期四、FilterConfig类五、FilterChain过滤器链六、Filter的拦截路径 一、Filter过滤器的介绍 Filter过滤器是JavaWeb三...

    Filter过滤器

    MySql的语法看这篇就够了,传送地址:MySql必知必会
    JSP的使用看这篇就够了,传送地址:JSP必知必会

    一、Filter过滤器的介绍

    1. Filter过滤器是JavaWeb三大组件之一,其余组件是:Servlet程序、Listener监听器
    2. Filter过滤器是JavaEE规范,也就是一个接口
    3. Filter过滤器的作用是:拦截请求、过滤响应

    二、Filter过滤器的使用

    1. Filter过滤器的使用步骤:

    (1) 编写一个类实现Filter接口 (导入的包为:javax.servlet.Filter)

    (2) 实现三个方法:
    ①实现过滤方法doFilter(),此方法中的:
    filterChain.doFilter(servletRequest,servletResponse);
    只有执行此方法,才可以访问拦截路径中的资源,若未执行此方法则代表拦截
    ②实现init()方法
    ③实现destroy()方法

    (3) 到web.xml中配置Filter的拦截路径

    1. Filter过滤器的工作流程:
      在这里插入图片描述

    2. 案例:在web目录下有一个Admin目录,此目录下的所有资源都必须用户登录之后才可访问,
      若没有登录,则跳转到登录页面

    分析: 用户登录之后会把登录信息保存到Session域中,所以检查用户是否登录,可以判断Session 中是否包含用户的登录信息即可

    代码演示(1):创建LoginServlet程序

    public class LoginServlet implements Filter {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
            HttpSession session = httpServletRequest.getSession();
            Object user = session.getAttribute("user");
            //如果等于null,说明还没有登录
            if (user == null) {   httpServletRequest.getRequestDispatcher("/login.jsp").forward(servletRequest,servletResponse);
            } else {
                //登录成功,可以访问Admin目录下的目标资源
                filterChain.doFilter(servletRequest,servletResponse);
            }
        }
        @Override
        public void init(FilterConfig filterConfig) throws ServletException { }
        @Override
        public void destroy() { }
    }
    
    

    代码演示(2):在web.xml中编写配置

    <!--  Filter标签用于配置一个Filter过滤器,用法与Servlet标签一致  -->
    <filter>
        <filter-name>LoginServlet</filter-name>
        <filter-class>com.qizegao.Filter.LoginServlet</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>LoginServlet</filter-name>
        <!--  url标签用于配置拦截路径,也就是访问哪些资源需要被拦截  -->
        <!--  /表示工程路径,映射到web目录  -->
        <!--  /*代表指定目录下的所有文件  -->
        <url-pattern>/Admin/*</url-pattern>
    </filter-mapping>
    
    

    运行结果:
    直接在浏览器输入:http://localhost:8080/MyTest/Admin/a.jsp,跳转到login.jsp,无法访问a.jsp

    注意:
    1.Filter过滤器也支持注解,在首行加@WebFilter(“拦截路径”),则无需web.xml文件
    2.浏览器不能直接访问实现Filter接口的类,只需访问拦截路径,就会自动的触发doFilter方法

    三、Filter过滤器的生命周期

    1.构造器方法
    2.init初始化方法
    3.doFilter方法 (其中有chain.doFilter方法)
    4.destroy方法
    其中:① 1和2在web工程启动的时候执行(即在创建Filter过滤器)
    ② 第三步,符合拦截路径的请求发送到服务器的时候,自动的执行,若请求不属于拦截
    路径,则不会执行
    ③ 第四步,停止web工程的时候执行(停止web工程,也会销毁Filter过滤器)

    四、FilterConfig类

    1.FilterConfig类是Filter过滤器的配置文件类,每次创建Filter的时候,也会创建一个FilterConfig
    类,其中包含了Filter配置文件的配置信息

    2.FilterConfig类的作用是获取Filter过滤器的配置文件内容:
    (1) 获取Filter的名称,即web.xml文件中标签的值:
    filterConfig.getFilterName();
    (2) 获取web.xml文件中标签的值(写在filter标签中,可写多个),如:
    在这里插入图片描述
    (3) 获取ServletContext对象:filterConfig.getServletContext()

    五、FilterChain过滤器链

    作用:解决多个过滤器如何一起工作
    在这里插入图片描述

    注意:

    1. 上述两个Filter拦截的资源路径相同,代表一定会执行两个Filter过滤器的doFilter方法, 但因为手动注释不一定执行其中的chain.doFilter方法
    2. 如果两个Filter拦截资源不同,且拦截资源符合Filter1,不符合Filter2,则会执行Filter1 的doFilter方法,且执行其中的chain.doFilter方法时,不会去执行Filter2的doFilter方法, 直接去访问资源,之后执行Filter1的后置代码(在chain.doFilter之后的均是后置代码)
    3. 如果请求的资源不符合过滤器1和2的拦截路径,两个doFilter方法都不执行
    4. 前置代码、chain.doFilter方法、后置代码都在doFilter方法中

    六、Filter的拦截路径

    1.精确匹配

    <url-pattern>/target.jsp</url-pattern>
    

    表示请求的地址必须为http://ip:port/工程路径/target.jsp,才可以触发doFilter方法

    2.目录匹配

    <url-pattern>/admin/*</url-pattern>
    

    表示请求的地址必须为http://ip:port/工程路径/admin/目录下所有的文件,才可以触发doFilter方法

    3.后缀名匹配

    <url-pattern>*.html</url-pattern>
    

    表示请求地址必须以.html结尾才可以触发doFilter方法

    <url-pattern>*.jsp</url-pattern>
    

    表示请求地址必须以.jsp结尾才可以触发doFilter方法

    注意:Filter过滤器只关心请求的地址是否符合拦截路径,不会关心请求的资源是否存在

    代码演示:FilterChain过滤器链的使用
    (1) 在Admin目录下创建a.jsp
    在这里插入图片描述

    (2) 创建两个Filter过滤器

    public class Filter1 implements Filter {
        public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
            System.out.println("Filter1的前置代码执行");
            chain.doFilter(req, resp);
            System.out.println("Filter1的后置代码执行");
        }
    }
    
    
    public class Filter2 implements Filter {
        public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
            System.out.println("Filter2的前置代码执行");
            chain.doFilter(req, resp);
            System.out.println("Filter2的后置代码执行");
        }
    }
    
    

    (3) 在web.xml中编写配置
    在这里插入图片描述

    运行结果:
    在浏览器地址栏输入:http://localhost:8080/MyTest/Admin/a.jsp
    控制台输出:
    在这里插入图片描述

    展开全文
  • Filter过滤器的例子与注解配置

    千次阅读 2020-08-04 10:48:59
    Filter过滤器链 概念 当访问服务器的资源时,过滤器可以将请求拦截下来,完成一些特殊的功能 作用 一般用于完成通过的操作。比如登录验证,统一编码处理,敏感字符过滤等等 创建 创建web项目 ...

    概念

    作用

    创建

    创建web项目

    定义类实现Servlet接口,实现其抽象方法

    配置Filter

    原理

    注解配置

    过滤器放行

    Filter的生命周期

    Filter的拦截路径

    Filter的拦截方式

    Filter的过滤器链


     

    概念

    • 当访问服务器的资源时,过滤器可以将请求拦截下来,完成一些特殊的功能

    作用

    一般用于完成通过的操作。比如登录验证,统一编码处理,敏感字符过滤等等

    创建

    创建web项目

    定义类实现Servlet接口,实现其抽象方法

    注意实现的是servlet包下的Filter

    package com.lingaolu.filter;
    
    import javax.servlet.*;
    import java.io.IOException;
    
    /**
     * @author 林高禄
     * @create 2020-08-04-9:42
     */
    public class Demo1 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("demo1过滤器进来了......");
        }
    
        @Override
        public void destroy() {
    
        }
    }
    

    配置Filter

    在项目的web.xml文件 中配置,(原理在下面说)

    启动访问index.jsp

    控制台输出

    为什么index.jsp页面看不到内容,因为被我们的拦截器给拦截,说明我们的拦截器成功了

    原理

    项目启动的时候会把配置文件web.xml解析,把相关东西装进容器

    1、我们访问的是这个地址:http://localhost/filterWeb/index.jsp,找到虚拟目录filterWeb

    2、接着拦截的路径进行匹配/*,也就是配置里的<url-pattern>/*</url-pattern>内容,会映射找到<filter-name>demo1</filter-name>的内容demo1

    3、接着根据demo1找到<filter></filter>标签里的内容,根据<filter-name>demo1</filter-name>对应找到<filter-class>com.lingaolu.filter.Demo1</filter-class>,这样就找到了我们的Demo1类,

    4、通过反射创建实例,然后会执行doFilte方法,这是规范,所以要实现Filter类并且实现相关的方法

    注解配置

    通过上面我们了解了Filter拦截器的创建与在web.xml的配置,但是配置有点繁琐,所以我们介绍一下注解配置

    我们创建新的类Demo2.同样实现Filter接口

    可以使用注解配置,然后我们的web.xml不需要写任何配置,也就是这个文件你删掉也可以

    接着在我们Demo2类名上加上注解@WebFilter("/*"),其中"/*"是你定义的拦截路径

    ctrl+鼠标左键查看一下 WebFilter

     

    我们先把xml配置的demo1的拦截器配置给注释掉,免得影响我们的demo2

    启动访问index.jsp

     看控制台输出

    是不是很方便,比在xml配置方便多了,所以以后我们写使用注解配置,也不需要创建web.xml文件了。

    这里我们可以快捷的创建过滤器

    模板可以自己定义

    过滤器放行

    上面我们的例子里面index.jsp页面被拦截了,所以没有出现任何内容,对于满足某些条件的连接,我们还是要放行的,比如登录的用户等等,将来可以做登录验证等等,满足条件的就放行,

    • 如果全部都拦截,那么这个项目就没意义
    • 如果全部都放行,那么拦截就可能没什么意义
    • 将来做一些判断,满足某些条件的放行
    filterChain.doFilter(servletRequest,servletResponse);
    

    启动访问index.jsp,有内容了,是因为我们放行了

    控制台输出

    Filter的生命周期

    Filter过滤器的生命周期

    Filter的拦截路径配置

    Filter过滤器的拦截路径配置

    Filter的拦截方式

    Filter的拦截方式配置

    Filter的过滤器链

    Filter的过滤器链 

    展开全文
  • SpringBoot项目写filter过滤器

    千次阅读 2020-04-21 14:27:24
    filter过滤器主要是为了防止用户未登录就访问里面的页面,他可以做到用户访问里面页面的时候给他转发或者重定向到 二、实现 创建一个filter文件夹,里面创建一个LoginFilter类。 package com.lmj.filter; import ...
  • Vue中的filter过滤器是使用方法

    万次阅读 多人点赞 2019-06-28 15:02:32
    在Vue中filter过滤器是一个非常强大的功能。 个人觉得称它为加工车间会更加贴切一些。 过滤器可以用来筛选出符合条件的,丢弃不符合条件的; 加工车间既可以筛选,又可以对筛选出来的进行加工。 一、filter的作用是...
  • Java Filter过滤器(idea)

    千次阅读 2019-05-28 00:05:52
    注意xml配置顺序:监听器-过滤器-servlet
  • 过滤器(Filter) 过滤器实际上就是对web资源进行拦截,做一些处理后再交给下一个过滤器或servlet处理。通常都是用来拦截request进行处理的,也可以对返回的response进行拦截处理 springboot项目中实现过滤器的两种...
  • Filter过滤器|敏感词汇过滤

    千次阅读 2020-02-12 23:27:09
    文章目录一、需求及分析二、过滤器三、xml配置四、测试sevlet 一、需求及分析 (1)对录入的数据进行敏感词汇过滤。 (2)敏感词汇参考 敏感词汇.txt文档 (3)如果是敏感词汇,替换为"***"。 分析:使用代理模式对...
  • filter 过滤器 token 校验

    千次阅读 2019-04-25 09:43:25
    Filter 过滤器方法: import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.commons.lang.StringUtils; import org.springframework.beans.factory.annotation.Autowired; import org....
  • springboot-filter过滤器

    千次阅读 2018-05-06 16:01:29
    本节介绍spring filter过滤器使用,一般做乱码处理、权限控制等操作,可以预先在过滤中加载,以下是过滤器的基本操作创建项目在pom.xml中引入依赖包&lt;?xml version="1.0" encoding="UTF-8"...
  • 咱们先说说 “Filter”,顾名思义 过滤器,在我们平时的工作中也是一员猛将。 在之前的文章中我也介绍了在Spring中类似的HandlerInterceptor的使用方法。 com.alibaba.dubbo.rpc.Filter它换了个马甲,干的依然是守门...
  • Filter过滤器执行流程

    千次阅读 2020-01-21 09:25:57
    在上一篇博客我们进行了Filter的入门讲解,这里我们讲解Filter的执行流程,从下图可以大致了解到,当客户端发送请求的时候,会经过过滤器,然后才能到我们的servlet,当我们的servlet处理完请求之后,我们的response...
  • Filter过滤器的拦截方式配置

    千次阅读 2020-08-05 12:09:34
    Filter的介绍 拦截方式配置 Filter拦截方式的配置是dispatcherTypes属性 一共有5中方式 REQUEST:默认值。浏览器直接请求资源 FORWARD:转发访问资源 INCLUDE:包含访问资源 ERROR:错误跳转资源...
  • 遇见的问题: 前台把参数通过报文或者使用表单、ajax...在一个Filter中将 HttpServletRequest 里的所有参数都取出来分别进行过滤然后再放回到该HttpServletRequest 中行不行呢?通过测试后发现是不行的,因为HttpS...
  • C#中如何运用Filter过滤器

    千次阅读 2019-04-04 14:47:21
    //LogService.WriteNormalLog(actionName, request, "", $"{controllerName}/{actionName}", LogCategory.GetRequest.GetEnumDesc(), filter1: TraceId); } /// /// 执行后 /// /// <param name="filter...
  • Vue方法中使用Filter过滤器

    千次阅读 2019-08-07 09:41:42
    1.全局过滤器 // filter.js export function dataFilter(val) { console.log("全局过滤",val) } // main.js 需要在main.js中引入过滤器函数 import Vue from 'vue'; // 引入Vue import filters from './f...
  • Filter过滤器链(多个过滤器)

    千次阅读 2020-01-21 13:57:47
    当有多个过滤器的时候,执行顺序很重要,在注解开发中,其执行顺序跟其类名的字符串有关,小的先执行,这里演示,一个是AFilter另一个是BFilter,如果是web.xml配置,那就是配置在上面的先执行 搞清楚了谁先执行,...
  • Spring Boot Filter过滤器 实现登录

    千次阅读 2019-11-08 11:51:41
    Spring Boot Filter过滤器 实现登录 Filter类 package com.citi.test; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import...
  • python--filter过滤器

    千次阅读 2018-07-27 15:54:41
    filter(function,Iterable),有两个参数,第一个参数为一个函数,该函数施加于Iterable中所有元素,若返回值为True,则保留,反之则舍弃。返回值为generator类型 例如:找出给定序列的所有偶数,1,2,3,4,5,6,7...
  • Filter过滤器及其作用介绍

    万次阅读 2018-05-06 21:23:16
    一、过滤器Filter 1.filter的简介 filter是对客户端访问资源的过滤,符合条件放行,不符合条件不放行,并且可以对目 标资源访问前后进行逻辑处理 2.Filter的API详解 (1)filter生命周期及其与生命周期相关的...
  • javaweb项目Filter过滤器详解

    千次阅读 2017-11-18 13:56:18
    Filter也称之为过滤器,它是Servlet技术中比较激动人心的技术,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截,从而实现一些特殊的功能。...
  • Filter过滤器,不过滤特定资源

    千次阅读 2017-08-17 10:27:41
    Filter过滤器,不过滤特定资源 不多说废话: 一 web.xml     WXBackStageFilter  com.ccic.wechat.filter.WXBackStageFilter    logonString  /index.jsp;login.do      includeString  
  • Filter过滤器应用场景及其使用

    千次阅读 2018-05-12 23:03:49
    过滤器Filter作用 过滤器可以再请求和响应之前做一部分预处理,有效的过滤掉不需要的内容,而且过滤器可以被复用,节省了大量的复用代码,提高了java的代码执行效率 过滤器Filter作用场景 防止未登录就进入...
  • Filter过滤器是什么?? 开发人员可以实现用户在访问某个目标资源之前,对访问的请求和响应进行拦截。简单说,就是可以实现web容器对某资源的访问前截获进行相关的处理,还可以在某资源向web容器返回响应前进行...
  • Filter过滤器拦截路径配置

    千次阅读 2020-01-21 12:05:24
    具体资源路径拦截:@WebFilter("/index.jsp") //这是指访问index.jsp的时候会经过过滤器 具体目录拦截:@WebFilter("/user/*") //这是指访问user目录下的所有资源时会经过过滤器 具体后缀名拦截:@WebFilter("*....
  • Filter过滤器链执行顺序

    千次阅读 2019-05-24 20:53:43
    Web应用允许多个过滤器来过滤页面请求——联想现实生活中的例子是最好理解的啦!比如:为了获得更加干净的水,可能需要多个过滤器来进行过滤。 这个时候就分为两种情况了 1:多个过滤器过滤的URL不同,那么此时的多...
  • vue+filter过滤器(多参数)传参 - 代码篇 传1个参数 //html {{aa | filterAa}} //js filters:{ filterAa(aa){ // 这额aa就是过滤器传入的参数 } } 传2个参数 //html {{aa | filterAa(bb)}} //js filters:{ ...
  • 对于一个web工程的filter过滤器注解方式配置后的优先级问题,很多教程写到按filter名字排序的顺序来进行过滤,最近发现了个小问题,分享一下。 我是用的tomcat发布工程, 对于注解配置的filter**分系统**(猜的)...
  • Filter过滤器代码演示及详解

    千次阅读 2017-07-15 10:55:13
     Filter也称之为过滤器,它是Servlet技术中最激动人心的技术之一,WEB开发人员通过Filter技术,对web服务器管理的所有web资源:例如Jsp, Servlet, 静态图片文件或静态html文件等进行拦截,从而实现一些特殊的功能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 356,728
精华内容 142,691
关键字:

filter过滤器