精华内容
下载资源
问答
  • 目录概述代码实现rowKey过滤器RowFilter列族过滤器FamilyFilter列过滤器QualifierFilter 概述 过滤器可以分为两种:比较过滤器和专用过滤器过滤器的作用是在服务端判断数据是否满足条件,然后只将满足条件的数据...


    概述

    过滤器可以分为两种:比较过滤器专用过滤器过滤器的作用是在服务端判断数据是否满足条件,然后只将满足条件的数据返回给客户端。

    • 比较过滤器
      LESS —— 小于
      LESS_OR_EQUAL —— 小于等于
      EQUAL —— 等于
      NOT_EQUAL —— 不等于
      GREATER_OR_EQUAL —— 大于等于
      GREATER —— 大于
      NO_OP —— 排除所有

    • 专用过滤器
      BinaryComparator —— 按字节索引顺序比较指定字节数组,采用Bytes.compareTo(byte[])
      BinaryPrefixComparator —— 跟前面相同,只是比较左端的数据是否相同
      NullComparator —— 判断给定的是否为空
      BitComparator —— 按位比较
      RegexStringComparator —— 提供一个正则的比较器,仅支持 EQUAL 和非EQUAL
      SubstringComparator —— 判断提供的子串是否出现在value中


    代码实现

    以下代码均有一个BeforeTest和一个AfterTest

    /**
     * 创建连接HBase服务器的方法
     */
    private Connection connection;
    private Table table;
    
    @BeforeTest
    public void init() throws IOException {
        //获取连接
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum", "node01:2181,node02:2181,node03:2181");
        connection = ConnectionFactory.createConnection(configuration);
        //获取表
        table = connection.getTable(TableName.valueOf("myuser"));
    }
    
    /**
     * 关闭系统连接和表连接
     */
    @AfterTest
    public void close() throws IOException {
        //关闭表
        table.close();
        connection.close();
    }
    

     

    rowKey过滤器RowFilter

    /**
     * 过滤rowKey比0003小的数据
     */
    @Test
    public void rowFilter() throws IOException {
        Scan scan = new Scan();
    
        //因为RowFilter需要一个binaryComparator参数,所以需要创建一个对象
        BinaryComparator binaryComparator = new BinaryComparator("0003".getBytes());
    
        //通过rowFilter按照rowKet进行过滤
        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.LESS, binaryComparator);
    
        scan.setFilter(rowFilter);
    
        ResultScanner resultScanner = table.getScanner(scan);
        for (Result result : resultScanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowKey为" + Bytes.toString(row));
    
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();
                //id列和age列是整型数据
                if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                    System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                } else {
                    System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                }
            }
        }
    }
    

     

    列族过滤器FamilyFilter

    /**
     * 列族过滤器,只获取f2列族的数据
     */
    @Test
    public void familyFilter() throws IOException {
        //获取Scan对象
        Scan scan = new Scan();
    
        //FamilyFilter需要一个binaryComparator的参数,所以新建一个对象
        BinaryComparator binaryComparator = new BinaryComparator("f2".getBytes());
        //scan.setFilter需要的参数是FamilyFilter
        FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, binaryComparator);
    
        //数据装在scan中
        scan.setFilter(familyFilter);
    
        //拿到需要的所有数据
        ResultScanner resultScanner = table.getScanner(scan);
        for (Result result : resultScanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowKey为" + Bytes.toString(row));
    
            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();
                //id列和age列是整型数据
                if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                    System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                } else {
                    System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                }
            }
        }
    }
    

     

    列过滤器QualifierFilter

    /**
         * 列过滤器,只查询name这一列
         */
        @Test
        public void qualifierFilter() throws IOException {
            //获取Scan对象
            Scan scan = new Scan();
            //列过滤器就是QualifierFilter,new一个
            QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("name"));
            //将列过滤器的值设置到scan中
            scan.setFilter(qualifierFilter);
            //获取到所有的scan的数据
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                byte[] row = result.getRow();
                System.out.println("数据的rowKey为" + Bytes.toString(row));
                List<Cell> cells = result.listCells();
                for (Cell cell : cells) {
                    byte[] family = cell.getFamily();
                    byte[] qualifier = cell.getQualifier();
                    byte[] value = cell.getValue();
                    //id列和age列是整型数据
                    if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                    } else {
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                    }
                }
            }
        }
    

     

    列值过滤器ValueFilter

        /**
         * 列值过滤器,查询列中含有8的值
         */
        @Test
        public void valueFilter() throws IOException {
            //获取Scan对象
            Scan scan = new Scan();
            //列值过滤器ValueFilter,new一个对象
            ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("8"));
            //将ValueFilter过滤后的值放到Scan中
            scan.setFilter(valueFilter);
            //获取所有数据
            ResultScanner resultScanner = table.getScanner(scan);
            //遍历循环得到每一条数据
            for (Result result : resultScanner) {
                //获取每一条数据的rowKey
                byte[] row = result.getRow();
                System.out.println("数据的rowKey为" + Bytes.toString(row));
                //获取到数据中的每一个cell
                List<Cell> cells = result.listCells();
                //遍历循环得到每一个cell的值
                for (Cell cell : cells) {
                    byte[] qualifier = cell.getQualifier();
                    byte[] family = cell.getFamily();
                    byte[] value = cell.getValue();
                    //id列和age列是整型数据
                    if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                    } else {
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                    }
                }
            }
        }
    

    专用过滤器

    单列值过滤器 SingleColumnValueFilter

        /**
         * 单列值过滤器,查询name为刘备的人
         */
        @Test
        public void singleColumnValueFilter() throws IOException {
            //new一个Scan对象
            Scan scan = new Scan();
            //单列值过滤器,new一个对象,来限定条件
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("f1".getBytes(), "name".getBytes(), CompareFilter.CompareOp.EQUAL, "刘备".getBytes());
            //获取限定条件后拿到的数据
            scan.setFilter(singleColumnValueFilter);
            //所有数据封装到resultScanner中
            ResultScanner resultScanner = table.getScanner(scan);
            //循环遍历resultScanner中的每条数据
            for (Result result : resultScanner) {
                //获取每条数据的rowKey值
                byte[] row = result.getRow();
                System.out.println("数据的rowKey为" + Bytes.toString(row));
                //获取每条数据中的cell值
                List<Cell> cells = result.listCells();
                //遍历循环得到每一个cell
                for (Cell cell : cells) {
                    byte[] qualifier = cell.getQualifier();
                    byte[] family = cell.getFamily();
                    byte[] value = cell.getValue();
                    //id列和age列是整型数据
                    if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                    } else {
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                    }
                }
            }
    
        }
    

     

    列值排除过滤器SingleColumnValueExcludeFilter

        /**
         * 列值排除过滤器
         */
        @Test
        public void singleColumnValueExcludeFilter() throws IOException {
            Scan scan = new Scan();
            scan.setFilter(new SingleColumnValueExcludeFilter("f1".getBytes(),"name".getBytes(), CompareFilter.CompareOp.EQUAL,"刘备".getBytes()));
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                byte[] row = result.getRow();
                System.out.println("数据的rowKey为" + Bytes.toString(row));
                List<Cell> cells = result.listCells();
                for (Cell cell : cells) {
                    byte[] qualifier = cell.getQualifier();
                    byte[] family = cell.getFamily();
                    byte[] value = cell.getValue();
                    //id列和age列是整型数据
                    if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                    } else {
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                    }
                }
            }
    
        }
    

     

    rowKey前缀过滤器PrefixFilter

    /**
         * row前缀过滤器,查询以00开头的所有前缀的rowkey
         */
        @Test
        public void prefixFilter() throws IOException {
            Scan scan = new Scan();
            PrefixFilter prefixFilter = new PrefixFilter("00".getBytes());
            scan.setFilter(prefixFilter);
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                byte[] row = result.getRow();
                System.out.println("数据的rowKey为" + Bytes.toString(row));
                List<Cell> cells = result.listCells();
                for (Cell cell : cells) {
                    byte[] qualifier = cell.getQualifier();
                    byte[] family = cell.getFamily();
                    byte[] value = cell.getValue();
                    //id列和age列是整型数据
                    if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                    } else {
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                    }
                }
            }
        }
    

    &160;

    分页过滤器PageFilter

        /**
         * 分页过滤器
         * 分页有两个条件
         * pageNum  第几页
         * pageSize 每页有几条
         */
        @Test
        public void pageFilter() throws IOException {
    
            int pageNum = 3;
            int pageSize = 2;
    
    
            /*
            分为两种情况判断:
            第一页
            其他页
             */
            if (pageNum == 1){
                Scan scan = new Scan();
                //设置起始rowKey
                scan.setStartRow("".getBytes());
                //设置最大的返回结果,返回pageSize条
                scan.setMaxResultSize(pageSize);
                //分页过滤器
                PageFilter pageFilter = new PageFilter(pageSize);
                scan.setFilter(pageFilter);
    
                ResultScanner resultScanner = table.getScanner(scan);
                for (Result result : resultScanner) {
                    byte[] row = result.getRow();
                    System.out.println("数据的rowKey为" + Bytes.toString(row));
                    List<Cell> cells = result.listCells();
                    for (Cell cell : cells) {
                        byte[] qualifier = cell.getQualifier();
                        byte[] family = cell.getFamily();
                        byte[] value = cell.getValue();
                        //id列和age列是整型数据
                        if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                            System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                        } else {
                            System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                        }
                    }
                }
            } else {
                String startRow = "";
                Scan scan = new Scan();
                /*
                第二页的起始rowKey = 第一页的结束rowKey + 1
                第三页的起始rowKey = 第二页的结束rowKey + 1
                 */
                int resultSize = (pageNum - 1) * pageSize + 1;
                scan.setMaxResultSize(resultSize);
                //设置一次性往前扫描5条,最后一个rowKey是第三页起始rowKey
                PageFilter pageFilter = new PageFilter(resultSize);
                scan.setFilter(pageFilter);
                //resultScanner里面有5条数据
                ResultScanner scanner = table.getScanner(scan);
                for (Result result : scanner) {
                    //获取rowKey
                    byte[] row = result.getRow();
                    //最后一次循环遍历 rowKey为0005
                    startRow = Bytes.toString(row);
                }
                Scan scan1 = new Scan();
                scan1.setStartRow(startRow.getBytes());
                scan1.setMaxResultSize(pageSize);
    
                PageFilter pageFilter1 = new PageFilter(pageSize);
                scan1.setFilter(pageFilter1);
    
                ResultScanner scanner1 = table.getScanner(scan1);
                for (Result result : scanner1) {
                    byte[] row = result.getRow();
                    System.out.println("数据的rowKey为" + Bytes.toString(row));
                    List<Cell> cells = result.listCells();
                    for (Cell cell : cells) {
                        byte[] qualifier = cell.getQualifier();
                        byte[] family = cell.getFamily();
                        byte[] value = cell.getValue();
                        //id列和age列是整型数据
                        if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                            System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                        } else {
                            System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                        }
                    }
                }
            }
        }
    

    多过滤器综合查询FilterList

    需求: 使用 SingleColumnValueFilter 查询f1列族,name为刘备的数据,并且同时满足rowkey的前缀以00开头的数据(PrefixFilter)

        /**
         * 多过滤综合查询
         * 需求: 使用 SingleColumnValueFilter 查询f1列族,name为刘备的数据,并且同时满足rowkey的前缀以00开头的数据(PrefixFilter)
         */
        @Test
        public void filterList() throws IOException {
            Scan scan = new Scan();
    
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("f1".getBytes(),"name".getBytes(), CompareFilter.CompareOp.EQUAL,"刘备".getBytes());
            PrefixFilter prefixFilter = new PrefixFilter("00".getBytes());
    
            FilterList filterList = new FilterList(singleColumnValueFilter, prefixFilter);
    
            scan.setFilter(filterList);
    
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                byte[] row = result.getRow();
                System.out.println("数据的rowKey为" + Bytes.toString(row));
                List<Cell> cells = result.listCells();
                for (Cell cell : cells) {
                    byte[] qualifier = cell.getQualifier();
                    byte[] value = cell.getValue();
                    byte[] family = cell.getFamily();
                    //id列和age列是整型数据
                    if ("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(value))){
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toInt(value));
                    } else {
                        System.out.println("列族为"+Bytes.toString(family)+"列名为"+Bytes.toString(qualifier)+"列值为"+Bytes.toString(value));
                    }
                }
            }
        }
    

    代码实现删除数据

    	/**
         * 根据rowKey删除数据
         */
        @Test
        public void delete() throws IOException {
            Delete delete = new Delete("0007".getBytes());
            
            table.delete(delete);
    
        }
    
    展开全文
  • * hbase行键过滤器RowFilter */ @Test public void rowKeyFilter() throws IOException { //获取连接 Table myuser = connection.getTable(TableName.valueOf("myuser")); //获取scan Scan scan = new Scan...
  • 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了!

     

    展开全文
  • 增加过滤器,过滤非固定主机访问import java.io.IOException;import java.util.StringTokenizer;import javax.servlet.Filter;import javax.servlet.FilterChain;import javax.servlet.FilterConfig;import javax....

    增加过滤器,过滤非固定主机访问

    import java.io.IOException;

    import java.util.StringTokenizer;

    import javax.servlet.Filter;

    import javax.servlet.FilterChain;

    import javax.servlet.FilterConfig;

    import javax.servlet.ServletException;

    import javax.servlet.ServletRequest;

    import javax.servlet.ServletResponse;

    import javax.servlet.http.HttpServletRequest;

    import org.apache.commons.lang3.StringUtils;

    import org.slf4j.Logger;

    import org.slf4j.LoggerFactory;

    /**

    * Servlet Filter implementation class AuthenticationPathFilter

    */

    public class AuthenticationPathFilter implements Filter {

    /**

    * 日志

    */

    private static final Logger LOGGER = LoggerFactory.getLogger(AuthenticationPathFilter.class);

    /**

    * IP权限地址

    */

    private String ipPattern;

    /**

    * Default constructor.

    */

    public AuthenticationPathFilter() {

    }

    /**

    * @see Filter#destroy()

    */

    public void destroy() {

    }

    /**

    * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)

    */

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException,

    ServletException {

    String ip = request.getRemoteHost();

    String reqUrl = ((HttpServletRequest) request).getRequestURI();

    if (reqUrl.contains("forbidden")) {

    filterChain.doFilter(request, response);

    return;

    }

    if (validateIP(ip, ipPattern)) {

    filterChain.doFilter(request, response);

    }

    // else {

    // ((HttpServletResponse) response).sendRedirect("/");

    // }

    }

    /**

    * @see Filter#init(FilterConfig)

    */

    public void init(FilterConfig filterConfig) throws ServletException {

    this.ipPattern = filterConfig.getInitParameter("ip-pattern");

    }

    /**

    *

    * 功能描述: ip地址权限校验

    *

    * @param ipStr 请求ip

    * @param ipPattern 权限ip列表

    * @return 校验是否通过

    */

    public static boolean validateIP(String ipStr, String ipPattern) {

    if (StringUtils.isEmpty(ipPattern)) {

    return true;

    }

    if (StringUtils.isEmpty(ipStr)) {

    return false;

    }

    StringTokenizer patterns = new StringTokenizer(ipPattern, ";");

    while (patterns.hasMoreTokens()) {

    if (ipStr.equals(patterns.nextToken())) {

    return true;

    }

    }

    // String[] patternList = ipPattern.split(";");

    // for (String pattern : patternList) {

    // if (ipStr.equals(pattern)) {

    // return true;

    // }

    // }

    LOGGER.error("IP address no permissions!");

    return false;

    }

    }

    展开全文
  • 代码思路:想要循环遍历文件夹下所有子文件夹,就要用到递归。首先判断路径是否存在:是:获取文件判断是否文件夹:是:调用...import java.io.File;import java.util.Scanner;public class TestGuolv {public stat...

    代码思路:

    想要循环遍历文件夹下所有子文件夹,就要用到递归。

    首先判断路径是否存在:

    是:获取文件

    判断是否文件夹:

    是:调用自身,继续获取子文件夹下内容

    否:判断文件后缀,符合则输出

    否:输出提示

    package com.hanqi.maya.util;

    import java.io.File;

    import java.util.Scanner;

    public class TestGuolv {

    public static void main(String[] args) {

    Scanner sc=new Scanner(System.in);

    System.out.println("请输入要查找的路径");

    String s=sc.nextLine();

    File file =new File(s);

    filesum(file,1);

    }

    public static void filesum(File f,int len){

    if(f.exists()){//判断路径是否存在

    File[] files=f.listFiles(); //获取路径下的文件名

    for(File fi:files){ //循环输出文件名

    if(fi.isDirectory()){ //判断是否文件夹

    printBlank(len);

    System.out.println(fi.getName()+"文件夹");

    filesum(fi,len+1); //继续调用自身

    }else{

    printBlank(len); //输出空格

    if(fi.getName().endsWith(".java")){//如果是文件则 判断是否“.java”后缀,是则输出

    System.out.println(fi.getName());

    }

    }

    }

    }else{

    System.out.println("文件不存在!!!");

    }

    }

    public static void printBlank(int len){

    for (int i = 0; i < len; i++) {//输出. 以区分文件夹层次

    System.out.print(". ");

    }

    }

    }

    ab12f8a76ae26fd41349931e4014114b.png

    总结与问题:

    昨天学到输出文件夹下所有文件,今天稍作改动变成了找出文件夹下指定后缀的文件。

    又因为输出的时候没有层次,所以写了个循环用来在输出的文件前面加空格以便层次分明,再后来发现空格对汉字的层次不够分明,遇到汉字会缩进几个空格,但是用符号就不会这样。

    还有如何控制指定后缀名的问题没有解决。

    以上这篇Java实现简单文件过滤器功能就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • 过滤器。。RequestFilter.javaimport java.io.IOException;import javax.servlet.Filter;import javax.servlet.FilterChain;import javax.servlet.FilterConfig;import javax.servlet.ServletException;import javax...
  • 1.浏览器不使用缓存设置过滤器import javax.servlet.*;import javax.servlet.http.HttpServletResponse;import java.io.IOException;/*** 用于的使 Browser 不缓存页面的过滤器*/public class ForceNoCacheFilter ...
  • Java实现布隆过滤器

    千次阅读 2020-05-11 15:47:03
    Java 实现布隆过滤器 1.什么是布隆过滤器? 布隆过滤器(Bloom Filter)是一个叫做 Bloom 的老哥于1970年提出的。 实际上可以把它看作由二进制向量(或者说位数组)和一系列随机映射函数(哈希函数)两部分组成的...
  • 使用java实现的布隆过滤器算法,jdk-1.7,使用java实现的布隆过滤器算法,jdk-1.7,使用java实现的布隆过滤器算法,jdk-1.7,
  • 在学习Java的时候,我们会讲到的一个东西,名字叫做过滤器。顾名思义,过滤器,就是我们用来过滤的,那过滤什么呢?这是一个问题。1)“登录过滤器”就是为了防止在用户没有登录的情况下来访问我们的网站。2)举例:...
  • 布隆过滤器是可以用于判断一个元素是不是在一个集合里,并且相比于其它的数据结构,布隆过滤器在空间和时间方面都有巨大的优势。下面这篇文章主要给大家介绍了关于Java实现布隆过滤器的相关资料,需要的朋友可以参考下
  • java配置CORSFilter过滤器实现跨域很多时候登录跨域时候需要从cookie中获取session,记录一下获取方法前端:ajax写法:$.ajax({url: "http://localhost:8080/",type: "GET",xhrFields: {withCredentials: true //设置...
  • 使用文件过滤器来搜索文件我们可以使用过滤器实现在某一目录下指定文件格式的搜索在File类中有两个和ListFiles重载的方法,方法的参数传递的就是过滤器一、FileFilterFile[] listFiles(FileFilter filter)java.io....
  • java 过滤器实现

    千次阅读 2014-07-28 11:24:44
    Java过滤器实现
  • java 实现布隆过滤器

    2020-09-22 20:27:02
    /* ... All Rights Reserved. */ ... import java.util.BitSet; /** * @author : zhangsencheng * @version : W1.0 * @description : 布隆过滤器实现类 * @program : com.example.mytest.testbloom .

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,297
精华内容 2,118
关键字:

java实现过滤器

java 订阅