filter 订阅
Filter 技术是servlet 2.3 新增加的功能。servlet2.3是sun公司于2000年10月发布的,它的开发者包括许多个人和公司团体,充分体现了sun公司所倡导的代码开放性原则。在众多参与者的共同努力下,servlet2.3比以往功能都强大了许多,而且性能也有了大幅提高。 展开全文
Filter 技术是servlet 2.3 新增加的功能。servlet2.3是sun公司于2000年10月发布的,它的开发者包括许多个人和公司团体,充分体现了sun公司所倡导的代码开放性原则。在众多参与者的共同努力下,servlet2.3比以往功能都强大了许多,而且性能也有了大幅提高。
信息
外文名
Filter
发    布
2000年10月
体    现
代码开放性原则
作    用
改变request和修改response
出    自
sun公司
中文名
过滤器
所    属
servlet 2.3
Filter特点功能
它新增加的功能包括:1. 应用程序生命周期事件控制;2. 新的国际化;3. 澄清了类的装载规则;4. 新的错误及安全属性;5. 不赞成使用HttpUtils 类;6. 各种有用的方法;7. 阐明并扩展了几个servlet DTD;8. filter功能.
收起全文
精华内容
下载资源
问答
  • java过滤器Filter 万次阅读 多人点赞
    2019-07-31 19:08:31

    一、简介

    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了!

     

    更多相关内容
  • 基于MATLAB的Filter使用,低通、带通和高通滤波器的仿真。包括filter、ftt等函数的使用
  • 注意:这篇文章很长,学习完后将会解决你对于过滤器(Filter)的所有疑惑,下面将通过理论和代码的结合来进行讲解演示..... 目录 基本介绍 过滤器原理 过滤器(Filter)接口 使用过滤器(Filter) 创建过滤器(Fliter...

            注意:这篇文章很长,学习完后将会解决你对于过滤器(Filter)的所有疑惑,下面将通过理论和代码的结合来进行讲解演示..... 


     目录

    基本介绍

    过滤器原理

    过滤器(Filter)接口

    使用过滤器(Filter)

    创建过滤器(Fliter)

    使用过滤器(Filter)

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

    注解方式

    xml方式 

    过滤器(Filter)生命周期

    理论说明 

    代码演示

    FilterConfig和FilterChain说明

    FilterConfig

    FilterConfig实例运用

    FilterChain 

    FilterChain应用实例

    多个Filter的执行顺序

    执行顺序验证

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

    代码实现

    代码验证

    总结 


    基本介绍

            过滤器,顾名思义就是对事物进行过滤的,在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个阶段,分别是初始化,拦截和过滤,销毁。

    1. 初始化阶段:当服务器启动时,我们的服务器(Tomcat)就会读取配置文件,扫描注解,然后来创建我们的Filter。
    2. 拦截和过滤阶段:只要请求资源的路径和拦截的路径相同,那么过滤器就会对请求进行过滤,这个阶段在服务器运行过程中会一直循环。
    3. 销毁阶段:当服务器(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页面.

             输入评论内容:你好啊!!!

             下面显示了我们的评论,我们再来输入:你真是个zz

             显示你真是个**,我们的评论过滤就成功了。


    总结 

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

            如果觉得讲的还不错,那么就点赞评论支持一下吧 

    展开全文
  • filter solutions

    千次下载 热门讨论 2012-06-07 00:45:24
    上传一个滤波器设计软件,很强大,很经典的,做电子设计会用到的
  • Filter过滤器(超详细)

    万次阅读 多人点赞 2021-01-17 16:03:49
    1.Filter ?什么是过滤器 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 过滤器它只关心请求的地址是否匹配,不关心请求的资源是否存在(只看后缀名是否等于,不关心后缀名在现实中是否真的存在)!!!

    展开全文
  • Matlab中filter函数用法

    千次阅读 2020-12-26 18:39:58
    filter 语法 说明 示例 移动平均滤波器 对矩阵行进行滤波 对各部分中的数据进行滤波 输入参数 输出参数 详细信息 有理传递函数 提示 filter 1 维数字滤波器 语法 y = filter(b,a,x) y = filter(b,a...

    目录

    语法

    说明

    示例

    移动平均滤波器

    对矩阵行进行滤波

    对各部分中的数据进行滤波

    有理传递函数


    filter函数是1 维数字滤波器。

    语法

    y = filter(b,a,x)
    
    y = filter(b,a,x,zi)
    
    y = filter(b,a,x,zi,dim)
    
    [y,zf] = filter(___)

    说明

    y = filter(b,a,x) 使用由分子和分母系数 b 和 a 定义的有理传递函数对输入数据 x 进行滤波。

    如果 a(1) 不等于 1,则 filter 按 a(1) 对滤波器系数进行归一化。因此,a(1) 必须是非零值。

    • 如果 x 为向量,则 filter 将滤波后数据以大小与 x 相同的向量形式返回。

    • 如果 x 为矩阵,则 filter 沿着第一维度操作并返回每列的滤波后的数据。

    • 如果 x 为多维数组,则 filter 沿大小不等于 1 的第一个数组维度进行计算。如果 x 为多维数组,则 filter 沿大小不等于 1 的第一个数组维度进行计算。

    y = filter(b,a,x,zi) 将初始条件 zi 用于滤波器延迟。zi 的长度必须等于 max(length(a),length(b))-1。

    y = filter(b,a,x,zi,dim) 沿维度 dim 进行计算。例如,如果 x 为矩阵,则 filter(b,a,x,zi,2) 返回每行滤波后的数据。

    [y,zf] = filter(___) 还使用任一上述语法返回滤波器延迟的最终条件 zf。

    示例

    移动平均滤波器

            移动平均滤波器是用于对含噪数据进行平滑处理的常用方法。此示例使用filter函数计算沿数据向量的平均值。创建一个由正弦曲线数据组成的1×100行向量,其中的正弦曲线被随机干扰所损坏。

    t = linspace(-pi,pi,100);
    rng default  %initialize random number generator
    x = sin(t) + 0.25*rand(size(t));

            移动平均值滤波器沿数据移动长度为windowSize的窗口,并计算每个窗口中包含的数据的平均值。以下差分方程定义向量 x 的移动平均值滤波器:

            窗口大小为 5 时,计算有理传递函数的分子和分母系数。

    windowSize = 5; 
    b = (1/windowSize)*ones(1,windowSize);
    a = 1;

            求数据的移动平均值,并绘制其对原始数据的图。

    y = filter(b,a,x);
    
    plot(t,x)
    hold on
    plot(t,y)
    legend('Input Data','Filtered Data')

    对矩阵行进行滤波

            此示例使用以下有理传递函数对数据的矩阵进行滤波。

            创建一个由随机输入数据组成的2×15矩阵。

    rng default  %initialize random number generator
    x = rand(2,15);

            定义有理传递函数的分子和分母系数。

    b = 1;
    a = [1 -0.2];

            沿着x的第二维度应用传递函数并返回每行的一维数字滤波结果。绘制原始数据的第一行对已滤波数据的图。

    y = filter(b,a,x,[],2);
    
    t = 0:length(x)-1;  %index vector
    
    plot(t,x(1,:))
    hold on
    plot(t,y(1,:))
    legend('Input Data','Filtered Data')
    title('First Row')

            绘制输入数据的第二行对已滤波数据的图。

    figure
    plot(t,x(2,:))
    hold on
    plot(t,y(2,:))
    legend('Input Data','Filtered Data')
    title('Second Row')

    对各部分中的数据进行滤波

            使用滤波器延迟的初始条件和最终条件对各部分中的数据进行滤波,尤其是需要考虑内存限制时请执行此操作。生成一个大型的随机数据序列并将其拆分为两段:x1 和 x2。

    x = randn(10000,1);
    
    x1 = x(1:5000);
    x2 = x(5001:end);

            整个序列 x 是 x1 和 x2 的垂直串联。定义有理传递函数的分子和分母系数,

    b = [2,3];
    a = [1,0.2];

            对子序列 x1 和 x2 进行滤波,一次一个。输出对 x1 进行滤波的最终条件,以便在第一段末尾存储滤波器的内部状态。

    [y1,zf] = filter(b,a,x1);

            将对 x1 进行滤波的最终条件用作对第二段也就是 x2 进行滤波的初始条件。

    y2 = filter(b,a,x2,zf);

            y1 是来自x1的滤波后的数据,而y2是来自x2的滤波后的数据。整个滤波后的序列是y1和y2的垂直串联。同时对整个序列进行滤波以供比较。

    y = filter(b,a,x);
    
    isequal(y,[y1;y2])
    
    
    ans = logical
       1
    

    b - 有理传递函数的分子系数

            有理传递函数的分子系数,指定为向量。

    a - 有理传递函数的分母系数

            有理传递函数的分母系数,指定为向量。

    x - 输入数据

            输入数据,指定为向量、矩阵或多维数组。

    zi - 滤波器延迟的初始条件

            滤波器延迟的初始条件,指定为向量、矩阵或多维数组。

    • 如果 zi 是向量,则它的长度必须是 max(length(a),length(b))-1。

    • 如果 zi 是矩阵或多维数组,则主维度的大小必须为 max(length(a),length(b))-1。剩余的每个维度的大小必须与 x 的相应维度的大小匹配。例如,假设沿 3×4×5 数组 x 的第二个维度 (dim = 2) 使用 filter。数组 zi 的大小必须为 [max(length(a),length(b))-1]×3×5。

            由 [] 指定的默认值将所有滤波器延迟初始化为零。

    dim - 沿其运算的维度

            沿其运算的维度,指定为正整数标量。如果未指定值,则默认值是大小不等于 1 的第一个数组维度。以一个二维输入数组 x 为例。

    • 如果 dim = 1,则 filter(b,a,x,zi,1) 沿着 x 的行进行计算并返回应用于每列的滤波器。

    • 如果 dim = 2,则 filter(b,a,x,zi,2) 沿 x 的列进行计算,并返回应用于每一行的滤波器。

      如果 dim 大于 ndims(x),则 filter 返回 x。

    y - 滤波后的数据

            滤波后的数据,以向量、矩阵或大小与输入数组 x 相同的多维数组的形式返回。如果 x 的类型为 single,则 filter 本身以单精度进行计算,y 的类型也是 single。否则,y 以 double 类型返回。

    zf - 滤波器延迟的最终条件

            滤波器延迟的最终条件,以向量、矩阵或多维数组的形式返回。

    • 如果x是一个向量,则zf是长度为max(length(a),length(b))-1的列向量。

    • 如果x是矩阵或多维数组,则 zf 是长度为 max(length(a),length(b))-1的列向量数组,其中zf中的列数等于x中的列数。例如,假设沿3×4×5数组x的第二个维度 (dim = 2) 使用filter。数组zf 的大小为 [max(length(a),length(b))-1]×3×5。

    有理传递函数

            Z变换域中这种 filter 运算的输入-输出说明是一种有理传递函数。有理传递函数采用如下形式:

            可同时处理FIR和IIR滤波器[1]。na是反馈滤波器阶数,nb是前馈滤波器阶数。由于归一化,假定a(1) = 1。还可以将有理传递函数表示为以下差分方程:

            此外,也可以使用如下图所示的 direct-form II 转置实现表示有理传递函数。此处,na = nb。

            filter在样本 m 处的运算由时域差分方程给定

    提示

    • 如果有 Signal Processing Toolbox™,请将 y = filter(d,x) 与digitalFilter(Signal Processing Toolbox) 对象d结合使用来对输入信号x进行滤波。要根据频率响应设定生成d,可以使用designfilt (Signal Processing Toolbox)。

    • 如果有 DSP System Toolbox™,将 y = filter(dObj,x) 与 dfilt (DSP System Toolbox) 对象 dObj 结合使用来对输入信号 x 进行滤波。

    • 要将 filter函数与来自 FIR 滤波器的b系数结合使用,请使用 y = filter(b,1,x)。

    • 有关滤波函数的详细信息,可以参考数字滤波(Signal Processing Toolbox)。

    展开全文
  • matlab中filter函数的用法如果你深爱的人此刻在你身边陪你,你怎么会有时间来看这些文字呢离散系统的差分方程为 2y[k]-y[-1]-3y[k-2]=2x[k]-x[k-1] x[k]=(0.5^k)u看楼主的意思主要是想实现差分方程 先从简单的说起:...
  • 当然它也不是完美无缺,它也有自己的缺点,接下来跟随我一起详细了解下BloomFilter的实现原理,以及它优缺点、应用场景,最后再看下Google guava包中BloomFilter的实现,并对比下它和HashSet在不同...
  • Zuul Filter

    万次阅读 2018-10-30 17:51:43
    文章目录简介Filter 类型Zuul 原生 Filter 简介   Zuul 的核心逻辑是由一系列紧密配合工作的 Filter 来实现的,它们能够在进行 HTTP 请求或者响应的时候执行相关操作。可以说,没有 Filter 责任链,就没有如今的 ...
  • C++实现MATLAB的filter函数

    热门讨论 2012-09-06 12:13:27
    因为需要使用filter函数(MATLAB内置函数),曾在网上copy过一段代码,但是那个算法实现的不全,没有计算zf,所以我自己结合MATLAB帮助重写了一下,测试结果OK
  • Filter Solutions 10完全破解版

    热门讨论 2013-09-11 13:19:53
    Filter Solutions 10 滤波器软件,完全破解版。内含破解说明。
  • 【Python基础】内置函数filter详解

    千次阅读 2022-04-03 11:01:03
    从一个列表中筛选出满足某个约束的子列表序列,使用filter替代for循环能提速1000倍,还在等啥赶紧学起来~
  • springboot的filter 过滤器的使用

    千次阅读 2021-04-01 15:58:53
    检票员(filter)---> 电影院。 注意:配置多个filter的时候,要设置编号id,值越小,优先级越高,越先执行。 1.2 使用场景 场景:权限控制、用户登录(非前端后端分离场景)等,过滤非法登录 二 自定义过滤的...
  • OpenCV 图像卷积:cv.filter2D() 函数详解

    万次阅读 多人点赞 2021-01-24 21:36:48
    API 照例,我们搬一下官网的 API: C++ void cv::filter2D(InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1, -1), double
  • Java Web之过滤器(Filter

    万次阅读 多人点赞 2018-07-31 16:58:40
    过滤器(Filter) 过滤器实际上就是对web资源进行拦截,做一些处理后再交给servlet。 通常都是用来拦截request进行处理的,也可以对返回的response进行拦截处理 大概流程图如下 应用场景 自动登录 统一设置...
  • 整理出、节点内容如下: <filter> <display-name>display-name> <description>description> <icon> <small-icon>small-icon> <large-icon>large-icon> icon> <filter-name>filter-name> <filter-class>filter-class...
  • Dubbo使用Filter

    千次阅读 2022-03-12 16:39:21
    通过实现org.apache.dubbo.rpc.Filter接口可以自定义Filter import org.apache.dubbo.rpc.Filter; import org.apache.dubbo.rpc.Invocation; import org.apache.dubbo.rpc.Invoker; import org.apache.dubbo.rpc....
  • Filter过滤器工作原理

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

    千次阅读 多人点赞 2020-05-11 20:53:44
    bool查询简介 Elasticsearch(下面简称ES)中的bool查询在业务中使用也是比较多的。在一些非实时的分页查询,导出的场景,我们经常使用bool查询组合各种查询...filter, 返回的文档必须满足filter子句的条件。但是跟Mus
  • 【VUE】过滤器Filter

    千次阅读 2022-03-27 14:56:45
    注意,filter在Vue3中已经删除。 本文回顾filter,并扩展内容,再引出下一篇的Computed。 是什么 功能:对需要显示的数据,进行一定的格式化操作后再显示 注意:filter不会修改原本的数据,而是基于原本的数据来...
  • spring cloud gateway之filter

    万次阅读 多人点赞 2018-12-17 21:45:21
    转载请标明出处: ...本文出自方志朋的博客 在上一篇文章详细的介绍了Gateway的Predict,Predict决定了请求由哪一个路由处理,在路由处理之前,需要经过“pre...由filter工作流程点,可以知道filter有着非常重要的作用...
  • 03.analyzer-token_filter

    千次阅读 2020-10-17 19:18:35
    lowercase token filter2. stemmer token filter3. stop1. 默认的情况下会干掉这些词2. 创建analyzer的时候使用3. 配置4. synonym1. 配置2. expand的作用3.样例解析5. remove deplicates6. unique token filter7. ...
  • filter_by() 和 filter() 的最主要的区别: 模块 语法 ><(大于和小于)查询 and_和or_查询 filter_by() 直接用属性名,比较用= 不支持 不支持 filter() 用类名.属性名,比较用== ...
  • backdrop-filter,让你的网站熠熠生”毛’

    千次阅读 多人点赞 2022-05-13 09:01:43
    大家好,我是半夏,一个刚刚开始写文的沙雕程序员.如果喜欢我的文章,可以关注➕ 点赞 加我微信:frontendpicker,一起学习交流前端,成为更优秀的工程师~...backdrop-filter 可以说是 CSS 中为毛玻璃量身定制的一.
  • 01.analyzer简介及char_filter组件

    万次阅读 2020-07-12 20:08:18
    { "analysis": { "analyzer": { "my_analyzer": { "tokenizer": "keyword", "char_filter": [ "my_char_filter" ] } }, "char_filter": { "my_char_filter": { "type": "pattern_replace", "pattern": "(\\d+)-(?...
  • 拦截器(Interceptor)和过滤器(Filter)的执行顺序和区别
  • 其实Filter才是真正意义的筛选器,其筛选能力远大于Calculate附带的筛选功能,我们常见的筛选利用Calculate完成而不是用Filter,完全是因为杀鸡焉用牛刀。就好像求1+1=2,我们没有必要用电脑来计算。 我们先说说...
  • Dubbo Filter用法详解

    千次阅读 2019-09-15 12:29:48
    Filter是Dubbo中使用较为频繁的组件,其作用在于对所指定的请求进行过滤,功能非常类似于AOP,可以实现诸如请求过滤器和全局异常捕获器等组件。本文首先会讲解Filter的用法,然后会从源码的角度讲解其实现原理。 1. ...
  • 一、FFmpeg filter的原理 1. 引言及示例 FFmpeg中的libavfilter提供了一整套的基于filter的机制。 filter本身是一个插件的形式,可以快速的组装需要的效果。 比如下面的filter,可以实现视频的水平镜像效果。 ...
  • JS中filter()方法的使用

    千次阅读 2021-04-09 11:28:37
    filter() 方法创建一个新的数组,新数组中的元素是通过检查指定数组中符合条件的所有元素。 注意: filter() 不会对空数组进行检测;不会改变原始数组 语法 array.filter(function(currentValue,index,arr), ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,579,439
精华内容 631,775
关键字:

filter