精华内容
下载资源
问答
  • java过滤器Filter

    万次阅读 多人点赞 2019-07-31 19:08:31
    Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序,主要的用途是过滤字符编码、做一些业务逻辑判断如是否有权限访问页面等。其工作原理是,只要你在web.xml文件配置好要拦截的客户端请求,它...

    一、简介

    Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序,主要的用途是过滤字符编码、做一些业务逻辑判断如是否有权限访问页面等。其工作原理是,只要你在web.xml文件配置好要拦截的客户端请求,它都会帮你拦截到请求,此时你就可以对请求或响应 (Request、Response)统一设置编码,简化操作;同时还可进行逻辑判断,如用户是否已经登陆、有没有权限访问该页面等等工作。它是随你的 web应用启动而启动的,只初始化一次,以后就可以拦截相关请求,只有当你的web应用停止或重新部署的时候才销毁,以下通过代码示例来了解它 的使用。

    二、实例

    package test.filter; 
    import ...; 
    /**
     * 介绍过滤器的使用,以设置编码为例
     */
    public class MyFilter implements Filter { 
      private FilterConfig config = null; 
      private boolean isFilter = false;
      
      public void destroy() { 
       System.out.println("MyFilter准备销毁..."); 
      } 
      
      public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain chain) throws IOException, ServletException { 
       // 强制类型转换 
       HttpServletRequest request = (HttpServletRequest)arg0; 
       HttpServletResponse response = (HttpServletResponse)arg1; 
       // 获取web.xm设置的编码集,设置到Request、Response 中   
       request.setCharacterEncoding(config.getInitParameter("charset"));   
       response.setContentType(config.getInitParameter("contentType"));   
       response.setCharacterEncoding(config.getInitParameter("charset"));   
       // 将请求转发到目的地继续执行
       chain.doFilter(request, response);
      } 
      
      public void init(FilterConfig arg0) throws ServletException { 
       this.config = arg0; 
       if(isFilter){
          System.out.println("MyFilter初始化..."); 
       }
      } 
      
      private void setIsFilter(boolean isFilter){
    	this.isFilter = isFilter;
      }
    }

    然后在web. xml中配置该过滤器:

     <filter>
     	<filter-name>MyFilter</filter-name>
     	<filter-class>test.filter.MyFilter</filter-class>
     	<init-param>
     		<param-name>isFilter</param-name>
     		<param-value>true</param-value>
     	</init-param>
     </filter>
     <filter-mapping>
     	<filter-name>MyFilter</filter-name>
     	<url-pattern>/*</url-pattern>
     	<dispatcher>REQUEST</dispatcher> <!-- 没有配置dispatcher就是默认request方式的 -->
     	<dispatcher>FORWARD</dispatcher>
     	<dispatcher>ERROR</dispatcher>
     	<dispatcher>INCLUDE</dispatcher>
     </filt

    三、详细介绍

    在doFilter方法中通常都做些什么呢,下面列举一下:

    1、通过控制对chain.doFilter的方法的调用,来决定是否需要访问目标资源。

    比如,可以在用户权限验证等等。判断用户是否有访问某些资源的权限,有权限放行,没权限不执行chain.doFilter方法。
    2、在调用chain.doFilter方法之前,做些处理来达到某些目的。
    比如,解决中文乱码的问题等等。可以在doFilter方法前,执行设置请求编码与响应的编码。甚至可以对request接口进行封装装饰来处理get请求方式的中文乱码问题(重写相应的request.getParameter方法)。
    3、在调用chain.doFilter方法之后,做些处理来达到某些目的。
    比如对整个web网站进行压缩。在调用chain.doFilter方法之前用类A对response对象进行封装装饰,重写getOutputStream和重写getWriter方法。在类A内部中,将输出内容缓存进ByteArrayOutputStream流中,然后在chain.doFilter方法执行后,获取类A中ByteArrayOutputStream流缓存数据,用GZIPOutputStream流进行压缩下。

    Filter不仅可以通过url-pattern来指定拦截哪些url匹配的资源。而且还可以通过servlet-name来指定拦截哪个指定的servlet(专门为某个servlet服务了,servlet-name对应Servlet的相关配置)。

    filter-mapping标签中dispatcher指定过滤器所拦截的资源被Servlet 容器调用的方式,可以是REQUEST,INCLUDE,FORWARD和ERROR之一,默认REQUEST。用户可以设置多个<dispatcher> 子元素用来指定 Filter 对资源的多种调用方式进行拦截。

    REQUEST:

    当用户直接访问页面时,Web容器将会调用过滤器。如果目标资源是通过RequestDispatcher的include()或forward()方法访问或ERROR情况时,那么该过滤器就不会被调用。

    INCLUDE:

    如果目标资源是通过RequestDispatcher的include()方法访问时,那么该过滤器将被调用。除此之外,该过滤器不会被调用。

    FORWARD:

    如果目标资源是通过RequestDispatcher的forward()方法访问时,那么该过滤器将被调用,除此之外,该过滤器不会被调用。

    ERROR:

    如若在A.jsp页面page指令中指定了error属性=examError.jsp,那么A.jsp中若出现了异常,会跳转到examError.jsp中处理。而在跳转到examError.jsp时,若过滤器配置了ERROR的dispather那么则会拦截,否则不会拦截。

    四、高级配置(允许代理注入spring bean)

    web.xml中配置过滤器DelegatingFilterProxy:

     

    <filter>
        <filter-name>permission</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
        <init-param>
            <param-name>targetFilterLifecycle</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
     <filter-mapping>
        <filter-name>permission</filter-name>
        <url-pattern>*.htm</url-pattern>
    </filter-mapping>

    在spring bean配置中加入:

    <bean id="permission" class="你的bean"></bean>

    bean的id必须和filter-name一样。如果想不一样,可以这样配置:

    <filter>
        <filter-name>permission</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
         <init-param>
            <param-name>targetFilterLifecycle</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>targetBeanName</param-name>
            <param-value>test</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>permission</filter-name>
        <url-pattern>*.htm</url-pattern>
    </filter-mapping>

    在spring bean配置中加入:

    <bean id="test" class="你的bean"></bean>

    以上你的spring bean必须实现Filter接口。

    那这样子做是为了什么呢?

    答:这样做就可以将DelegatingFilterProxy所代理的filter作为spring的bean,受到spring的管理,也就是通过Spring容器来管理filter的生命周期,还有就是如果filter中需要一些Spring容器的实例,可以通过spring直接注入,另外读取一些配置文件这些便利的操作都可以通过Spring来配置实现。

    其中如果设置"targetFilterLifecycle"为True,则Filter.init()和Filter.destroy()有效;若为false,则这两个方法失效。

    如果大家有用到shiro(一个强大且易用的Java安全框架,执行身份验证、授权、密码学和会话管理等)的话,通常就会用到这个DelegatingFilterProxy了!

     

    展开全文
  • java过滤器不起作用的原因

    千次阅读 2016-03-18 10:25:58
    导致过滤器不起作用的原因,目前我碰到的有两种:一个是过滤器的顺序问题,一个是过滤文件类型。   先说说过滤器的顺序问题。 在项目里面,要是用SSH框架的话,web.xml文件中除了自己写的过滤器以外,还会有...

    在应用中,有时候会用到过滤器,也有时候命名写好了配好了过滤器信息,可是过滤器就是不起作用。

    导致过滤器不起作用的原因,目前我碰到的有两种:一个是过滤器的顺序问题,一个是过滤文件类型。

     

    先说说过滤器的顺序问题。

    在项目里面,要是用SSH框架的话,web.xml文件中除了自己写的过滤器以外,还会有struts、Hibernate等的过滤器,这样子经常就会出现题目当中说的问题(尤其是过滤器过滤的是同一种类型,如.actioon)。

    如:原来的过滤器顺序是这样子的:

    <filter>
    	<filter-name>struts2</filter-name>
    	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
    	<filter-name>struts2</filter-name>
    	<url-pattern>*.action</url-pattern>
    </filter-mapping>
    
    <filter>
    	<filter-name>UserFilter</filter-name>
    	<filter-class>com.wjl.MyFilter</filter-class>
    </filter>
    <filter-mapping>
    	<filter-name>UserFilter</filter-name>
    	<url-pattern>*.action</url-pattern>
    </filter-mapping>

     这个时候的过滤器可能会不起作用,因为请求的时候先走了struts的过滤器,自己写的过滤器就不执行了。但是要是换个顺序,也就是如下的顺序,让请求先走自己的过滤器再走struts的过滤器,这样子自己的过滤器就起作用了。

    <filter>
    	<filter-name>UserFilter</filter-name>
    	<filter-class>com.wjl.MyFilter</filter-class>
    </filter>
    <filter-mapping>
    	<filter-name>UserFilter</filter-name>
    	<url-pattern>*.action</url-pattern>
    </filter-mapping>
    <filter>
    	<filter-name>struts2</filter-name>
    	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
    	<filter-name>struts2</filter-name>
    	<url-pattern>*.action</url-pattern>
    </filter-mapping>

     

    再说说过滤类型导致的不起作用。

    在web.xml配置文件里面,很多地方是可以连续使用多个文件的,用逗号隔开就好,如:

    <context-param>
    	<description>配置spring配置文件的路径</description>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>/WEB-INF/classes/daosql.xml,/WEB-INF/classes/pageContorl.xml,/WEB-INF/classes/base.xml</param-value>
    </context-param>

    这个时候的<param-value >就可以放好多参数,用逗号隔开就好,而且每个都起作用。

    由上面那种类似的例子就容易联想到在过滤器里面使用同样的方法配置多个过滤类型,如:

    <filter-mapping>
    	<filter-name>UserFilter</filter-name>
    	<url-pattern>*.action,*.jsp</url-pattern>
    </filter-mapping>

    但实际上这样子是不对的。这样配置后,无论是action还是jsp都不会走过滤器。还是得把他们拆开才能用。拆开之后两者类型都走过滤器。

    <filter>
    	<filter-name>UserFilter</filter-name>
    	<filter-class>com.wjl.MyFilter</filter-class>
    </filter>
    <filter-mapping>
    	<filter-name>UserFilter</filter-name>
    	<url-pattern>*.action</url-pattern>
    </filter-mapping>
    <filter-mapping>
    	<filter-name>UserFilter</filter-name>
    	<url-pattern>*.jsp</url-pattern>
    </filter-mapping
    展开全文
  • Java 过滤器作用

    万次阅读 2012-02-17 17:45:04
    在 J2EE 探索者 系列文章的最后一篇中,作者 Kyle Gabhart 将向您介绍 Servlet 过滤器体系结构,定义过滤器的许多应用,并指导您完成典型过滤器实现的三个步骤。他还会透露 bean 的一些激动人心的变化,预计刚发布...
    Servlet API 很久以前就已成为企业应用开发的基石,而 Servlet 过滤器则是对 J2EE 家族的相对较新的补充。在 J2EE 探索者 系列文章的最后一篇中,作者 Kyle Gabhart 将向您介绍 Servlet 过滤器体系结构,定义过滤器的许多应用,并指导您完成典型过滤器实现的三个步骤。他还会透露 bean 的一些激动人心的变化,预计刚发布的 Java Servlet 2.4 规范会引入这些变化。

    Servlet 过滤器是可插入的 Web 组件,它允许我们实现 Web 应用程序中的预处理和后期处理逻辑。过滤器支持 servlet 和 JSP 页面的基本请求处理功能,比如日志记录、性能、安全、会话处理、XSLT 转换,等等。 过滤器最初是随 Java Servlet 2.3 规范发布的,最近定稿的 2.4 规范对它进行了重大升级。在这 J2EE 探索者 系列文章的最后一篇中,我将向您介绍 Servlet 过滤器的基础知识 —— 比如总体的体系结构设计、实现细节,以及在 J2EE Web 应用程序中的典型应用,还会涉及一些预计最新的 Servlet 规范将会提供的扩展功能。

    Servlet 过滤器是什么?
    Servlet 过滤器是小型的 Web 组件,它们拦截请求和响应,以便查看、提取或以某种方式操作正在客户机和服务器之间交换的数据。过滤器是通常封装了一些功能的 Web 组件,这些功能虽然很重要,但是对于处理客户机请求或发送响应来说不是决定性的。典型的例子包括记录关于请求和响应的数据、处理安全协议、管理会话属性, 等等。过滤器提供一种面向对象的模块化机制,用以将公共任务封装到可插入的组件中,这些组件通过一个配置文件来声明,并动态地处理。

    Servlet 过滤器中结合了许多元素,从而使得过滤器成为独特、强大和模块化的 Web 组件。也就是说,Servlet 过滤器是:

    声明式的:过滤器通过 Web 部署描述符(web.xml)中的 XML 标签来声明。这样允许添加和删除过滤器,而无需改动任何应用程序代码或 JSP 页面。

    动态的:过滤器在运行时由 Servlet 容器调用来拦截和处理请求和响应。

    灵活的:过滤器在 Web 处理环境中的应用很广泛,涵盖诸如日志记录和安全等许多最公共的辅助任务。过滤器还是灵活的,因为它们可用于对来自客户机的直接调用执行预处理和后期处 理,以及处理在防火墙之后的 Web 组件之间调度的请求。最后,可以将过滤器链接起来以提供必需的功能。

    模块化的:通过把应用程序处理逻辑封装到单个类文件中,过滤器从而定义了可容易地从请求/响应链中添加或删除的模块化单元。

    可移植的:与 Java 平台的其他许多方面一样,Servlet 过滤器是跨平台和跨容器可移植的,从而进一步支持了 Servler 过滤器的模块化和可重用本质。

    可重用的:归功于过滤器实现类的模块化设计,以及声明式的过滤器配置方式,过滤器可以容易地跨越不同的项目和应用程序使用。

    透明的:在请求/响应链中包括过滤器,这种设计是为了补充(而不是以任何方式替代)servlet 或 JSP 页面提供的核心处理。因而,过滤器可以根据需要添加或删除,而不会破坏 servlet 或 JSP 页面。
    所以 Servlet 过滤器是通过一个配置文件来灵活声明的模块化可重用组件。过滤器动态地处理传入的请求和传出的响应,并且无需修改应用程序代码就可以透明地添加或删除它 们。最后,过滤器独立于任何平台或者 Servlet 容器,从而允许将它们容易地部署到任何相容的 J2EE 环境中。

    在接下来的几小节中,我们将进一步考察 Servlet 过滤器机制的总体设计,以及实现、配置和部署过滤器所涉及的步骤。我们还将探讨 Servlet 过滤器的一些实际应用,最后简要考察一下模型-视图-控制器(MVC)体系结构中包含的 Servlet 过滤器,从而结束本文的讨论。

    Servlet 过滤器体系结构
    正如其名称所暗示的,Servlet 过滤器 用于拦截传入的请求和/或传出的响应,并监视、修改或以某种方式处理正在通过的数据流。过滤器是自包含、模块化的组件,可以将它们添加到请求/响应链中, 或者在无需影响应用程序中其他 Web 组件的情况下删除它们。过滤器仅只是改动请求和响应的运行时处理,因而不应该将它们直接嵌入 Web 应用程序框架,除非是通过 Servlet API 中良好定义的标准接口来实现。

    Web 资源可以配置为没有过滤器与之关联(这是默认情况)、与单个过滤器关联(这是典型情况),甚至是与一个过滤器链相关联。那么过滤器究竟做什么呢? 像 servlet 一样,它接受请求并响应对象。然后过滤器会检查请求对象,并决定将该请求转发给链中的下一个组件,或者中止该请求并直接向客户机发回一个响应。如果请求被 转发了,它将被传递给链中的下一个资源(另一个过滤器、servlet 或 JSP 页面)。在这个请求设法通过过滤器链并被服务器处理之后,一个响应将以相反的顺序通过该链发送回去。这样就给每个过滤器都提供了根据需要处理响应对象的机 会。

    当过滤器在 Servlet 2.3 规范中首次引入时,它们只能过滤 Web 客户机和客户机所访问的指定 Web 资源之间的内容。如果该资源然后将请求调度给其他 Web 资源,那就不能向幕后委托的任何请求应用过滤器。2.4 规范消除了这个限制。Servlet 过滤器现在可以应用于 J2EE Web 环境中存在请求和响应对象的任何地方。因此,Servlet 过滤器可以应用在客户机和 servlet 之间、servlet 和 servlet 或 JSP 页面之间,以及所包括的每个 JSP 页面之间。这才是我所称的强大能力和灵活性!

    实现一个 Servlet 过滤器
    他们说“好事多磨”。我不知道“他们”指的是谁,或者这句古老的谚语究竟有多真实,但是实现一个 Servlet 过滤器的确要经历三个步骤。首先要编写过滤器实现类的程序,然后要把该过滤器添加到 Web 应用程序中(通过在 Web 部署描述符 /web.xml 中声明它),最后要把过滤器与应用程序一起打包并部署它。我们将详细研究这其中的每个步骤。

    1. 编写实现类的程序
    过滤器 API 包含 3 个简单的接口(又是数字 3!),它们整洁地嵌套在 javax.servlet 包中。那 3 个接口分别是 Filter、FilterChain 和 FilterConfig。从编程的角度看,过滤器类将实现 Filter 接口,然后使用这个过滤器类中的 FilterChain 和 FilterConfig 接口。该过滤器类的一个引用将传递给 FilterChain 对象,以允许过滤器把控制权传递给链中的下一个资源。FilterConfig 对象将由容器提供给过滤器,以允许访问该过滤器的初始化数据。

    为了与我们的三步模式保持一致,过滤器必须运用三个方法,以便完全实现 Filter 接口:

    init():这个方法在容器实例化过滤器时被调用,它主要设计用于使过滤器为处理做准备。该方法接受一个 FilterConfig 类型的对象作为输入。

    doFilter():与 servlet 拥有一个 service() 方法(这个方法又调用 doPost() 或者 doGet())来处理请求一样,过滤器拥有单个用于处理请求和响应的方法——doFilter()。这个方法接受三个输入参数:一个 ServletRequest、response 和一个 FilterChain 对象。

    destroy():正如您想像的那样,这个方法执行任何清理操作,这些操作可能需要在自动垃圾收集之前进行。展示了一个非常简单的过滤器,它跟踪满足一个客户机的 Web 请求所花的大致时间。

    一个过滤器类实现
    1. import javax.servlet.*;
    2. import java.util.*;
    3. import java.io.*;
    4. public class TimeTrackFilter implements Filter {
    5.         private FilterConfig filterConfig = null;
    6.         public void init(FilterConfig filterConfig)
    7.         throws ServletException {
    8.                 this.filterConfig = filterConfig;
    9.         }
    10.         public void destroy() {
    11.                 this.filterConfig = null;
    12.         }
    13.         public void doFilter( ServletRequest request,
    14.         ServletResponse response, FilterChain chain )
    15.         throws IOException, ServletException {
    16.                 Date startTime, endTime;
    17.                 double totalTime;
    18.                 startTime = new Date();
    19.                 // Forward the request to the next resource in the chain
    20.                 chain.doFilter(request, wrapper);
    21.                 // -- Process the response -- \\
    22.                 // Calculate the difference between the start time and end time
    23.                 endTime = new Date();
    24.                 totalTime = endTime.getTime() - startTime.getTime();
    25.                 totalTime = totalTime / 1000; //Convert from milliseconds to seconds
    26.                 StringWriter sw = new StringWriter();
    27.                 PrintWriter writer = new PrintWriter(sw);
    28.                 writer.println();
    29.                 writer.println("===============");
    30.                 writer.println("Total elapsed time is: " + totalTime + " seconds." );
    31.                 writer.println("===============");
    32.                 // Log the resulting string
    33.                 writer.flush();
    34.                 filterConfig.getServletContext().
    35.                 log(sw.getBuffer().toString());
    36.         }
    37. }
    复制代码
    这个过滤器的生命周期很简单,不管怎样,我们还是研究一下它吧:

    初始化
    当容器第一次加载该过滤器时,init() 方法将被调用。该类在这个方法中包含了一个指向 FilterConfig 对象的引用。我们的过滤器实际上并不需要这样做,因为其中没有使用初始化信息,这里只是出于演示的目的。

    过滤
    过滤器的大多数时间都消耗在这里。doFilter() 方法被容器调用,同时传入分别指向这个请求/响应链中的 ServletRequest、ServletResponse 和 FilterChain 对象的引用。然后过滤器就有机会处理请求,将处理任务传递给链中的下一个资源(通过调用 FilterChain 对象引用上的 doFilter()方法),之后在处理控制权返回该过滤器时处理响应。


    析构
    容器紧跟在垃圾收集之前调用 destroy() 方法,以便能够执行任何必需的清理代码。

    2. 配置 Servlet 过滤器
    过滤器通过 web.xml 文件中的两个 XML 标签来声明。<filter> 标签定义过滤器的名称,并且声明实现类和 init() 参数。<filter-mapping> 标签将过滤器与 servlet 或 URL 模式相关联。

    摘自一个 web.xml 文件,它展示了如何声明过滤器的包含关系:

    在 web.xml 中声明一个过滤器
    1. <filter>
    2.   <filter-name>Page Request Timer</filter-name>
    3.   <filter-class>TimeTrackFilter</filter-class>
    4. </filter>
    5. <filter-mapping>
    6.   <filter-name>Page Request Timer</filter-name>
    7.   <servlet-name>Main Servlet</servlet-name>
    8. </filter-mapping>
    9. <servlet>
    10.   <servlet-name>Main Servlet</servlet-name>
    11.   <servlet-class>MainServlet</servlet-class>
    12. </servlet>
    13. <servlet-mapping>
    14.   <servlet-name>Main Servlet</servlet-name>
    15.   <url-pattern>/*</url-pattern>
    16. </servlet-mapping>
    复制代码

    上 面的代码示例声明了一个过滤器("Page Request Timer"),并把它映射到一个 servlet("Main Servlet")。然后为该 servlet 定义了一个映射,以便把每个请求(由通配符指定)都发送到该 servlet。这是控制器组件的典型映射声明。您应该注意这些声明的顺序,因为千万不能背离这些元素的顺序。

    3. 部署 Servlet 过滤器
    事实上,与 Web 应用程序一起部署过滤器绝对不涉及任何复杂性。只需把过滤器类和其他 Web 组件类包括在一起,并像您通常所做的那样把 web.xml 文件(连同过滤器定义和过滤器映射声明)放进 Web 应用程序结构中,servlet 容器将处理之后的其他所有事情。

    过滤器的许多应用
    您在 J2EE Web 应用程序中利用过滤器的能力,仅受到您自己的创造性和应用程序设计本领的限制。在适合使用装饰过滤器模式或者拦截器模式的任何地方,您都可以使用过滤器。过滤器的一些最普遍的应用如下:

    加载:对于到达系统的所有请求,过滤器收集诸如浏览器类型、一天中的时间、转发 URL 等相关信息,并对它们进行日志记录。

    性能:过滤器在内容通过线路传来并在到达 servlet 和 JSP 页面之前解压缩该内容,然后再取得响应内容,并在将响应内容发送到客户机机器之前将它转换为压缩格式。

    安全:过滤器处理身份验证令牌的管理,并适当地限制安全资源的访问,提示用户进行身份验证和/或将他们指引到第三方进行身份验证。过滤器甚至能够管理访问 控制列表(Access Control List,ACL),以便除了身份验证之外还提供授权机制。将安全逻辑放在过滤器中,而不是放在 servlet 或者 JSP 页面中,这样提供了巨大的灵活性。在开发期间,过滤器可以关闭(在 web.xml 文件中注释掉)。在生产应用中,过滤器又可以再次启用。此外还可以添加多个过滤器,以便根据需要提高安全、加密和不可拒绝的服务的等级。

    会话处理:将 servlet 和 JSP 页面与会话处理代码混杂在一起可能会带来相当大的麻烦。使用过滤器来管理会话可以让 Web 页面集中精力考虑内容显示和委托处理,而不必担心会话管理的细节。

    XSLT 转换:不管是使用移动客户端还是使用基于 XML 的 Web 服务,无需把逻辑嵌入应用程序就在 XML 语法之间执行转换的能力都绝对是无价的。

    使过滤器适应 MVC 体系结构
    模型-视图-控制器(Model-View-Controller,MVC)体系结构是一个有效的设计,它现在已作为最重要的设计方法学,整合到了诸如 Jakarta Struts 和 Turbine 等大多数流行的 Web 应用框架中。过滤器旨在扩充 MVC 体系结构的请求/响应处理流。不管请求/响应发生在客户机和服务器之间,还是发生在服务器上的其他组件之间,过滤器在处理流中的应用都是相同的。从 MVC 的观点看,调度器组件(它或者包括在控制器组件中,或者配合控制器组件工作)把请求转发给适当的应用程序组件以进行处理。这使得控制器层成为包括 Servlet 过滤器的最佳位置。通过把过滤器放在控制器组件本身的前面,过滤器可以应用于所有请求,或者通过将它放在控制器/调度器与模型和控制器之间,它可以应用于 单独的 Web 组件。

    MVC 体系结构广为传播,并具有良好的文档。请通过 参考资料 中的链接了解关于 MVC 和 MVC 体系结构中的 Servlet 实现的更多信息。

    结束语
    虽然过滤器才出现几年时间,但它们本身已作为一个关键组件嵌入到了所有敏捷的、面向对象的 J2EE Web 应用程序中。本文向您介绍了 Servlet 过滤器的使用。本文讨论了过滤器的高级设计,比较了当前规范(2.4)和以前(2.3)的模型,讲述了实现过滤器所涉及的精确步骤,以及如何在 Web 应用程序中声明过滤器,然后与应用程序一起部署它。本文还阐述了 Servlet 过滤器的一些最普遍应用,并提到了过滤器如何适应传统的 MVC 体系结构。

    这是 J2EE 探索者 系列的最后一篇文章。我们在年初通过粗略研究 Enterprise JavaBean 组件来开始我们的旅程,并提到了何时使用这些组件才真正有意义,以及何时这些组件才会变得大材小用的问题。然后我们将目光转向了 Web 层,绘制了一条通过 Servlet、JSP 页面、JavaBean 技术以及 Java Servlet API 中的无数选择和功能的路径。在这个系列文章中与您一起艰苦跋涉真是一件快乐的事情。我享受着编写这个系列文章的乐趣,并且我从大家的反馈中知道,这对您也 是一个很有价值的过程。

    Java 过滤器的作用
    http://www.ossez.com/forum.php?mod=viewthread&tid=13396&fromuid=426

    展开全文
  • Java - 过滤器有哪些作用和用法?

    万次阅读 2019-03-23 14:25:29
    Java Web开发中的过滤器(filter)是从Servlet 2.3规范开始增加的功能,并在Servlet 2.4规范中得到增强。对Web应用来说,过滤器是一个驻留在服务器端的Web组件,它可以截取客户端和服务器之间的请求与响应信息,并对...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    Java Web开发中的过滤器(filter)是从Servlet 2.3规范开始增加的功能,并在Servlet 2.4规范中得到增强。对Web应用来说,过滤器是一个驻留在服务器端的Web组件,它可以截取客户端和服务器之间的请求与响应信息,并对这些信息进行过滤。当Web容器接受到一个对资源的请求时,它将判断是否有过滤器与这个资源相关联。如果有,那么容器将把请求交给过滤器进行处理。在过滤器中,你可以改变请求的内容,或者重新设置请求的报头信息,然后再将请求发送给目标资源。当目标资源对请求作出响应时,容器同样会将响应先转发给过滤器,在过滤器中你可以对响应的内容进行转换,然后再将响应发送到客户端。

    常见的过滤器用途主要包括:对用户请求进行统一认证、对用户的访问请求进行记录和审核、对用户发送的数据进行过滤或替换、转换图象格式、对响应内容进行压缩以减少传输量、对请求或响应进行加解密处理、触发资源访问事件、对XML的输出应用XSLT等。

    和过滤器相关的接口主要有:Filter、FilterConfig和FilterChain。

    编码过滤器的例子:

    package chimomo.learning.java.code.jsp;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.annotation.WebInitParam;
    import java.io.IOException;
    
    /**
     * @author Created by Chimomo
     */
    @WebFilter(urlPatterns = {"*"}, initParams = {@WebInitParam(name = "encoding", value = "utf-8")})
    public class CodingFilter implements Filter {
    
        private String defaultEncoding = "utf-8";
    
        @Override
        public void init(FilterConfig config) {
            String encoding = config.getInitParameter("encoding");
            if (encoding != null) {
                defaultEncoding = encoding;
            }
        }
    
        @Override
        public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
                throws IOException, ServletException {
            req.setCharacterEncoding(defaultEncoding);
            resp.setCharacterEncoding(defaultEncoding);
            chain.doFilter(req, resp);
        }
    
        @Override
        public void destroy() {
        }
    
    }
    

    下载计数过滤器的例子:

    package chimomo.learning.java.code.jsp;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.http.HttpServletRequest;
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Properties;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * @author Created by Chimomo
     */
    @WebFilter(urlPatterns = {"/*"})
    public class DownloadCounterFilter implements Filter {
    
        private ExecutorService executorService = Executors.newSingleThreadExecutor();
        private Properties downloadLog;
        private File logFile;
    
        @Override
        public void init(FilterConfig config) {
            String appPath = config.getServletContext().getRealPath("/");
            logFile = new File(appPath, "DownloadLog.txt");
            if (!logFile.exists()) {
                try {
                    boolean b = logFile.createNewFile();
                    if (b) {
                        System.out.println("Log file is successfully created");
                    } else {
                        System.out.println("Log file already exists");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            downloadLog = new Properties();
            try {
                downloadLog.load(new FileReader(logFile));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
                throws IOException, ServletException {
            HttpServletRequest request = (HttpServletRequest) req;
            final String uri = request.getRequestURI();
            executorService.execute(() -> {
                String value = downloadLog.getProperty(uri);
                if (value == null) {
                    downloadLog.setProperty(uri, "1");
                } else {
                    int count = Integer.parseInt(value);
                    downloadLog.setProperty(uri, String.valueOf(++count));
                }
                try {
                    downloadLog.store(new FileWriter(logFile), "");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            chain.doFilter(req, resp);
        }
    
        @Override
        public void destroy() {
            executorService.shutdown();
        }
    
    }
    

    说明:这里使用了Servlet 3规范中的注解来部署过滤器,当然也可以在web.xml中使用<filter>和<filter-mapping>标签部署过滤器。

    展开全文
  • Java Web之过滤器(Filter)

    万次阅读 多人点赞 2018-07-31 16:58:40
    过滤器(Filter) 过滤器实际上就是对web资源进行拦截,做一些处理后再交给servlet。 通常都是用来拦截request进行处理的,也可以对返回的response进行拦截处理 大概流程图如下 应用场景 自动登录 统一设置...
  • java过滤器作用和工作原理

    千次阅读 2017-06-16 15:01:31
    一个请求来到时,web容器会判断是否有过滤器与该信息资源相关联,如果有则交给过滤器处理,然后再交给目标资源,响应的时候则以相反的顺序交给过滤器处理,最后再返回给用户浏览器。 过滤器类需要实现javax.servlet...
  • Java过滤器

    万次阅读 多人点赞 2012-03-06 18:50:15
    过滤器就是在源数据和目的数据之间过滤作用的中间件。  Web应用中,在处理请求时,经常有一些公共的工作,比如设置字符集。这样的工作需要写在每个页面,这样的写法费力且不好修改。使用过滤器就像在这些流程前...
  • java stream过滤_Java Stream过滤器

    千次阅读 2020-07-14 20:24:52
    java stream过滤Java Stream filter can be very helpful when you want to do some processing only on some elements of ... 当您希望仅基于特定条件对Stream的某些元素进行某些处理时,Java Stream过滤器可能会...
  • java过滤器会耗性能么,如果是大并发情况用过滤器好么,会不会导致性能较低,运行过缓?
  • import java.sql.SQLException; import dao.UserDao; import domain.User; public class UserService { public User login(String username, String password) throws SQLException { UserDao dao = new UserDao();...
  • 拦截器和过滤器的区别 过滤器和拦截器的区别: ①拦截器是基于java的反射机制的... ④拦截器可以访问action上下文、值栈里的对象,而过滤器不能访问。  ⑤在action的生命周期中,拦截器可以多次被调用,而过滤...
  • Java过滤器Filter讲解(Java基础)

    千次阅读 2020-06-06 19:48:59
    文章目录一、什么是过滤器二、如何编写过滤器三、 过滤器的配置四、Filter的生命周期五、多个Filter的执行顺序 一、什么是过滤器 Filter也称之为过滤器,它是Servlet技术中最激动人心的技术,WEB开发人员通过Filter...
  • JAVA-过滤器和拦截器1

    万次阅读 2020-07-05 21:09:29
    1、过滤器 (Filter) ...注意:这个方法必须执行成功,否则过滤器不起作用。 doFilter() :容器中的每一次请求都会调用该方法, FilterChain 用来调用下一个过滤器 Filter。 destroy(): 当容器销毁 过滤器
  • Java过滤器配置使用

    千次阅读 2017-10-22 16:51:18
    过滤器作用:用于过滤请求,在请求发出前后,做一些检查或操作,配置及使用步骤如下: 1.要配置Filter,首先建立一个Java类,实现Filter接口,代码如下 import java.io.IOException; import javax.servlet.Filter...
  • 触发事件: 项目中需要对用户信息进行匿名化处理,就是对接口返回的信息进行再次的处理。 处理方法①:直接在接口信息返回前,在进行返回数据...③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 346,512
精华内容 138,604
关键字:

java过滤器不起作用

java 订阅