管道过滤器模式 分布式

之前在 benjielin前辈的博客中看到“管道过滤器（Pipe-And-Filter）模式（http://bj007.blog.51cto.com/1701577/345677）”，当时将文章中运用到的组合模式（Composite）与我刚刚写过的装饰模式（Decorator）和职责链模式（Chainof Responsibility）混为一谈，并希望用这后面两个模式进行代码实现，+_+

现在觉得还是先把那文章中的组合模式给具体实现一下吧，具体的文字描述请看上面文章链接哦。

在我的代码中，我假设的需求是：给定多个条件（即过滤器），遍历一本字典中的所有单词，将同时符合所有条件的所有单词查询（过滤）出来。现假定需要过滤出“单词中同时包含a、b、cd字串，并且以"end”结尾，最后是单词的长度大于7”。

好了，看清了需求，得出类图如下：

1. //字典
2. classDictionary{
4. //字典里面有好多单词
5. privateArrayList<String>allWords;
7. publicDictionary(ArrayList<String>allWords){
8. this.allWords=allWords;
9. }
11. //获取字典中所有单词
12. publicArrayList<String>getAllWords(){
13. returnthis.allWords;
14. }
15. }

1. //过滤器接口，只有match()方法
2. interfaceIFilter{
3. publicbooleanmatch(Stringword);
4. }

1. //树叶型过滤器，过滤单词中长度大于指定长度
2. classLengthFilterimplementsIFilter{
3. privateintlength;
5. publicLengthFilter(intlength){
6. this.length=length;
7. }
9. @Override
10. publicbooleanmatch(Stringword){
11. if(word.length()>length){
12. returntrue;
13. }
14. returnfalse;
15. }
16. }

1. //树叶型过滤器，过滤单词中包含有某个字符字串
2. classContainsFilterimplementsIFilter{
3. privateStringsubStr;
5. publicContainsFilter(StringsubStr){
6. this.subStr=subStr;
7. }
9. @Override
10. publicbooleanmatch(Stringword){
11. if(word.contains(subStr)){
12. returntrue;
13. }
14. returnfalse;
15. }
16. }

1. //树叶型过滤器，过滤单词中以某个字符字串结束
2. classEndFilterimplementsIFilter{
3. privateStringsubStr;
5. publicEndFilter(StringsubStr){
6. this.subStr=subStr;
7. }
9. @Override
10. publicbooleanmatch(Stringword){
11. if(word.endsWith(subStr)){
12. returntrue;
13. }
14. returnfalse;
15. }
16. }

1. //抽象组合型过滤器，类似于树枝节点
2. abstractclassCompositeFilterimplementsIFilter{
4. protectedArrayList<IFilter>filters;
6. publicCompositeFilter(){
7. this.filters=newArrayList<IFilter>();
8. }
10. //继续将IFilter接口中的match()声明为abstract，
11. //由具体的过滤器子类进行实现
12. publicabstractbooleanmatch(Stringword);
14. //添加过滤器链
15. publicvoidaddFilters(ArrayList<IFilter>filters){
16. this.filters.addAll(filters);
17. }
19. //添加一个过滤器
20. publicvoidaddFilter(IFilterfilter){
21. this.filters.add(filter);
22. }
24. //既然是树枝过滤器，其下必有子过滤器
25. publicArrayList<IFilter>getFilters(){
26. returnthis.filters;
27. }
28. }

1. //and过滤器，树枝型过滤器
2. classAndFilterextendsCompositeFilter{
3. @Override
4. publicbooleanmatch(Stringword){
5. for(IFilterfilter:super.filters){
6. if(!(filter.match(word))){
7. returnfalse;
8. }
9. }
10. returntrue;
11. }
12. }

1. //or过滤器，树枝型过滤器
2. classOrFilterextendsCompositeFilter{
3. @Override
4. publicbooleanmatch(Stringword){
5. for(IFilterfilter:super.filters){
6. if(filter.match(word)){
7. returntrue;
8. }
9. }
10. returnfalse;
11. }
12. }

1. //管道
2. classPipe{
4. //字典，相当于流入管道的数据流
5. privateDictionarydictionary;
7. //用于保存过滤后的最终数据
8. privateLinkedHashSet<String>theWords;
10. //单词查询中需要用到的过滤器树
11. privateIFilterfilterTree;
13. //用于保存字典中的所有单词，即数据流中的一个个数据
14. privateArrayList<String>allWords;
16. publicPipe(Dictionarydictionary,IFilterfilterTree){
17. this.dictionary=dictionary;
18. this.filterTree=filterTree;
19. this.theWords=newLinkedHashSet<String>();
20. }
22. publicLinkedHashSet<String>getWords(){
23. //先搜索过滤字典中所有单词，再返回符合要求的单词集合
24. this.allWords=dictionary.getAllWords();
25. this.findWords();
26. returnthis.theWords;
27. }
29. privatevoidfindWords(){
30. //对每个单词进行过滤
31. for(Stringword:allWords){
32. if(filterTree.match(word)==true){
33. this.theWords.add(word);
34. }
35. }
36. }
37. }

1. //测试类
2. publicclassClient{
3. publicstaticvoidmain(String[]args){
5. //创建过滤器树:包含"a"、"b"、"cd"子串,以"end"结尾,长度>7
7. //同时包含"a"、"b"、"cd"子串的过滤器
8. CompositeFilterandFilter=newAndFilter();
10. IFiltercontain01=newContainsFilter("a");
11. IFiltercontain02=newContainsFilter("b");
12. IFiltercontain03=newContainsFilter("cd");
13. andFilter.addFilter(contain01);
14. andFilter.addFilter(contain02);
15. andFilter.addFilter(contain03);
17. //以"end"或"END"结尾的过滤器
18. CompositeFilterorFilter=newOrFilter();
20. IFilterend01=newEndFilter("end");
21. IFilterend02=newEndFilter("END");
22. orFilter.addFilter(end01);
23. orFilter.addFilter(end02);
25. //长度>7的过滤器
26. IFilterlengthFilter=newLengthFilter(7);
28. //构建过滤器树，用根过滤器将上面的所有过滤器组合起来
29. CompositeFilterrootFilter=newAndFilter();
31. rootFilter.addFilter(andFilter);
32. rootFilter.addFilter(orFilter);
33. rootFilter.addFilter(lengthFilter);
35. //自定义一本字典里的所有单词
36. ArrayList<String>allWords=newArrayList<String>();
37. allWords.add("akkkk");
38. allWords.add("ab--b-cd--end");
39. allWords.add("abckk");
40. allWords.add("abdcend");//长度为6,不符合
41. allWords.add("kakbkck");
42. allWords.add("a-b-cd-END");
43. allWords.add("bbcc");
45. //自定义一本字典
46. Dictionarydictionary=newDictionary(allWords);
48. //将字典、过滤器树传入管道
49. Pipepipe=newPipe(dictionary,rootFilter);
51. //单词流在通过管道时被过滤，获取最终单词
52. System.out.println(pipe.getWords());
53. }
54. }

测试结果：

1. [ab--b-cd--end,a-b-cd-END]

如此一来，基本上解决了我在原来文章中的许多疑问（下面的是修改前的内容），根据 benjielin前辈的提示，修改了原来完全不合理的地方，可看评论哦。

话说回来，原来的代码也太乱了，原因就是我完全理解错了benjielin 前辈文章中关于组合模式中AndFilter 类、OrFilter类的用处，也完全没弄明白组合模式究竟用于何处，呼...

小结：

1、Pipe 类中过滤的代码少了很多，只是调用过滤器的match() 方法而已；

2、由 1 也相应地去除了由 Pipe类来判断对象属于树叶还是树枝类型的逻辑，消去了坏味道；

3、原文中利用递归遍历过滤器树的方法一点都不合理，完全应该去除，当初是因为没理清思路；

4、改变主意，不用 职责链模式 来实现管道过滤器模式了，因为现在我觉得那个模式应该实现不了 Composite 模式这样的功能，它最多也只能起到链 的作用。

我的相关文章：

组合模式（Composite）的安全模式与透明模式http://haolloyin.blog.51cto.com/1177454/347308

职责链模式（Chain ofResponsibility）的Java实现http://haolloyin.blog.51cto.com/1177454/342166

爱华网本文地址 » http://www.aihuau.com/a/25101011/99400.html