过滤器的简单实现

过滤器的简单实现

1：Filter接口，每个扩展都需要实现此接口

 1  /**
 2   * 过滤器。自定义的过滤器需要实现此接口<br>
 3   * 可以根据需求决定是否允许继续流转，如果需要，则调用<br>
 4   * chain.doFilter()方法继续。如果不调用，则责任链终止。
 5   * 
 6   *  @author  kzl
 7   * 
 8    */
 9  public   interface  Filter {
10       /**
11       * 执行过滤
12       * 
13       *  @param  chain
14       *            过滤责任链
15        */
16       void  doFilter(IFilterChain chain);
17  }
18 

2:责任链接口，用来控制过滤器是否继续执行

/**
 * 过滤器责任链
 * 
 *  @author  kzl
 * 
  */
public   interface  IFilterChain {
     /**
     * 执行过滤
      */
     void  doFilter();
}

3:过滤器组，用来添加自定义的过滤器

 1  /**
 2   * 过滤器组
 3   * 
 4   *  @author  kzl
 5   * 
 6    */
 7  public   interface  FilterGroup {
 8       /**
 9       * 添加过滤器
10       * 
11       *  @param  filter
12       *            过滤器
13       *  @return  返回此过滤器组,允许继续添加
14        */
15      FilterGroup append(Filter filter);
16 
17       /**
18       * 执行过滤操作
19       * 
20       *  @param  chain
21       *            过滤器责任链
22        */
23       void  doFilter(FilterChain chain);
24  }
25 

下面给出简单的实现类：
1：Filter1

 1  import  java.text.SimpleDateFormat;
 2  import  java.util.Date;
 3 
 4  public   class  Filter1  implements  Filter {
 5 
 6      @Override
 7       public   void  doFilter(IFilterChain chain) {
 8          System.out.println( new  SimpleDateFormat( " yyyy-MM-dd HH:mm:ss " )
 9                  .format( new  Date( 1256819348330l )));
10          chain.doFilter();
11      }
12 
13  }
14 

2:FilterChain

/**
 * 过滤器责任链
 * 
 *  @author  kzl
 * 
  */
public   class  FilterChain  implements  IFilterChain {
     /**
     * 过滤器组
      */
    FilterGroup group;

     public  FilterChain(FilterGroup group) {
         this .group  =  group;
    }

    @Override
     public   void  doFilter() {
         //  过滤器组执行
        group.doFilter( this );
    }
}

3:FilterGroup

 1  import  java.util.LinkedList;
 2 
 3  public   class  FilterGroupImpl  implements  FilterGroup {
 4      LinkedList < Filter >  list  =   new  LinkedList < Filter > ();
 5       int  current  =   0 ;
 6 
 7      @Override
 8       public   synchronized  FilterGroup append(Filter filter) {
 9          list.add(filter);
10           return   this ;
11      }
12 
13      @Override
14       public   void  doFilter(FilterChain chain) {
15           if  (current  <  list.size()) {
16              list.get(current ++ ).doFilter(chain);
17          }
18      }
19 
20  }
21 

4:最终组合起来的main

 1  public   class  Main {
 2       public   static   void  main(String[] args) {
 3          FilterGroup group  =   new  FilterGroupImpl();
 4          group.append( new  Filter1());
 5          group.append( new  Filter2());
 6          FilterChain chain  =   new  FilterChain(group);
 7          chain.doFilter();
 8      }
 9  }
10