抽丝剥茧设计模式- 责任链模式（Chain of Responsibility Pattern）
一、关于设计模式的思考
1.很多设计模式的区别不是语法的区别，而是语义的区别。
2.最难的是proxy，其次是chain of responsibility，Reactor 也当作设计模式。
3.所谓设计模式 就是把简单问题复杂化，把变化的部分封装那，即"封装变化"。
4.大部分的设计模式都是利用Java多态，多态是Java面向对象的核心。
二、请思考如下需求：
在公众号上发表文章，后台要经过处理才能发表和存如数据库，每个处理策略都要检查一遍。
三、责任链模式（Chain of Responsibility Pattern）
让多个处理请求的对象都有可能接收请求，将这些处理请求的对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。
应用场景：servlet Filter、listener
四、例子
package org.design.behavioral.chain;
import java.util.ArrayList;
import java.util.List;
public class ChainOfResponsibility {
public static void main(String[] args) {
Article article = new Article();
article.setArticle("Hello every one,(--)<script> This is a sensitive word! 666");
//java是值传递，函数调用的时候如果是基本类型，传值的copy，如果是引用类型，传的是引用类型地址的copy
//version 1 需要过滤文章中恶意脚本和敏感词
/*
String str = article.getArticle();
//过滤恶意脚本
str = str.replace("<","[");
str = str.replace(">","]");
//过滤敏感词
str = str.replace("sensitive","*");
article.setArticle(str);
System.out.println(article);
*/
//version 2 将过滤策略封装到Filter类中
/*
Filter scriptFilter = new ScriptFilter();
scriptFilter.doFilter(article);
Filter sensitiveFilter = new SensitiveFilter();
sensitiveFilter.doFilter(article);
System.out.println(article);
*/
//version 3 借助list，形成链
/*
List<Filter> filters = new ArrayList<Filter>();
filters.add(new ScriptFilter());
filters.add(new SensitiveFilter());
filters.add(new ExpressionFilter());
filters.add(new NumberFilter());
for(Filter f:filters){
f.doFilter(article);
}
System.out.println(article);
*/
//version 4 filter chain，与version相比，只不过把add 和遍历方法放到FilterChainV1中了。
//编程小技巧：将Filter们构成链条，链式编程。
/*
FilterChainV1 chainV1 = new FilterChainV1();
chainV1.add(new ScriptFilter()).add(new NumberFilter());
chainV1.doFilter(article);
System.out.println(article);
FilterChainV1 chainV2 = new FilterChainV1();
chainV2.add(new ExpressionFilter()).add(new SensitiveFilter());
chainV2.doFilter(article);
System.out.println(article);
*/
/*
version 5 FilterChain其实自己也是一个Filter，像递归。
FilterChainV2 implements Filter
FilterChainV2 chainV21 = new FilterChainV2();
chainV21.add(new ScriptFilter()).add(new NumberFilter());
FilterChainV2 chainV22 = new FilterChainV2();
chainV22.add(new ExpressionFilter()).add(new SensitiveFilter());
chainV21.add(chainV22);
chainV21.doFilter(article);
System.out.println(article);
*/
/*
version 6 由FilterChain中的某一个Filter决定链条是否继续。Filter中增加返回值，继续返回true，终止返回false。
判断逻辑放在FilterChain中不合适，由Filter自己决定是否继续更合理。
因为扩展Filter的时候，应该由扩展的Filter决定是否继续，不用修改FilterChain。
*/
FilterChin chain = new FilterChin();
chain.add(new ScriptFilter()).add(new NumberFilter()).add(new ExpressionFilter()).add(new SensitiveFilter());
chain.doFilter(article);
System.out.println(article);
}
}
class Article {
public String article;
public String getArticle() {
return article;
}
public void setArticle(String article) {
this.article = article;
}
@Override
public String toString() {
return "Article{" +
"article='" + article + '\'' +
'}';
}
}
interface Filter {
boolean doFilter(Article article);
}
class ScriptFilter implements Filter {
@Override
public boolean doFilter(Article article) {
System.out.println("Exec ScriptFilter");
//过滤恶意脚本
String str = article.getArticle();
str = str.replace("<", "[");
str = str.replace(">", "]");
article.setArticle(str);
return true;
}
}
class SensitiveFilter implements Filter {
@Override
public boolean doFilter(Article article) {
System.out.println("Exec SensitiveFilter");
//过滤敏感词
String str = article.getArticle();
str = str.replace("sensitive", "*");
article.setArticle(str);
return false;
}
}
class ExpressionFilter implements Filter {
@Override
public boolean doFilter(Article article) {
System.out.println("Exec ExpressionFilter");
//过滤表情
String str = article.getArticle();
str = str.replace("(--)", "@");
article.setArticle(str);
return true;
}
}
class NumberFilter implements Filter {
@Override
public boolean doFilter(Article article) {
System.out.println("Exec NumberFilter");
//过滤数字
String str = article.getArticle();
str = str.replaceAll("\\d", "000");
article.setArticle(str);
return true;
}
}
class FilterChainV1 {
List<Filter> filters = new ArrayList<Filter>();
////编程小技巧：return FilterChain，将FilterChain形成链 类似StringBuffer.append();
public FilterChainV1 add(Filter filter) {
this.filters.add(filter);
return this;
}
public void doFilter(Article article) {
for (Filter f : filters) {
f.doFilter(article);
}
}
}
class FilterChainV2 implements Filter {
List<Filter> filters = new ArrayList<Filter>();
////编程小技巧：return FilterChain，将FilterChain形成链 类似StringBuffer.append();
public FilterChainV2 add(Filter filter) {
this.filters.add(filter);
return this;
}
public boolean doFilter(Article article) {
for (Filter f : filters) {
f.doFilter(article);
}
return true;
}
}
class FilterChin implements Filter {
List<Filter> filters = new ArrayList<Filter>();
FilterChin add(Filter filter) {
this.filters.add(filter);
return this;
}
@Override
public boolean doFilter(Article article) {
for (Filter f : filters) {
if (!f.doFilter(article)) ;
return false;
}
return true;
}
}
五、补充知识：
1.replace的参数是char和CharSequence，既可以支持字符的替换，也支持字符串的替换(CharSequence字符串序列)；
2.replaceAll的参数是regex或者char，基于正则表达式的替换，例如通过replaceAll("\\d", "#")把一个字符串所有的数字字符都换成#号；
3.相同点：均为全部替换，把源字符串中的某一字符或字符串全部换成指定的字符或字符串。
4.如果只想替换第一次出现的，使用replaceFirst()，改方法也是基于正则表达式的替换，与replaceAll()不同的时，仅替换第一次出现的字符串;
5.如果replaceAll()和replaceFirst()所用的参数据不是基于正则表达式，则与replace()替换字符串的效果是一样，即这两者也支持字符串的操作；
感谢阅读到现在，请在留言区提出宝贵的意见！
更多精彩内容，关注微信公众号：技术严选
