设计链模式

1、现在假设一个场景：做一个BBS系统，也就意味着人们可以在论坛上自由言论。一个好的系统肯定要对言论进行处理，比如说敏感词汇、脚本代码等等。

A、原始的做法：

package program.design.model;
public class LinkedDesign {
    public static void main(String[] args) {
         String msg="<script>this is 敏感 information</script>";
         
         MsgProcessor prossor=new MsgProcessor();
         prossor.setMsg(msg);
         String result=prossor.process();
         System.out.println(result);
    }
}


package program.design.model;
public class MsgProcessor {
    private String msg;
    public String process() {
        //process the html tag<>
        String result=msg.replaceAll("<","[")
        .replaceAll(">","]")
        //process the sensitive vocabulary
        .replace("敏感","☺");
        return result;
    }
    
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

评价：如此进行处理的话，如果现在添加了新的需求，也就意味着要对msg添加新的处理逻辑，或者改变原先的处理逻辑，那么这就不得不去修改这段逻辑代码了。设计模式的初衷就是有额外的逻辑或功能模块添加的时候，不会对原来的逻辑代码进行大幅的修改。

 

B、在这里，msg的处理方法是不断变化的，我们可以将每一种处理方式设计成一个相应的类。如处理敏感词汇的类SensitiveFilter、处理脚本代码的类HTMLFilter。为了是一个类型能接收这些所有的类，我们就得定义一个接口，使得这些处理过滤类都实现这个接口。

package program.design.model;

public class Main {
    public static void main(String[] args) {
       String msg="<script>this is 敏感 information</script>";
       MsgProcessor processor=new MsgProcessor();
       processor.setMsg(msg);
       String result=processor.process();
       System.out.println(result);
    }
}


public class MsgProcessor {

    private String msg;
    public String process() {
        Filter[] filters=new Filter[]{new HTMLFilter(),new SensitiveFilter()};
        for(int i=0;i<filters.length;i++) {
            msg=filters[i].doFilter(msg);
        }
        
        return msg;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}


public interface Filter {
   String doFilter(String str);
}


public class HTMLFilter implements Filter{
    @Override
    public String doFilter(String str) {
        String result=str.replaceAll("<", "[")
        .replaceAll(">", "]");
        return result;
    }
}



public class SensitiveFilter implements Filter{
    @Override
    public String doFilter(String str) {
        String result=str.replace("敏感","☺");
        return result;
    }
}

评价：这样，代码就变得灵活多了，增加新的规则时，我们只需添加新的过滤类且只要对逻辑代码进行少量的改动，但是还是存在改动的情况，即增加新的过滤规则时，要将新的过滤实例在逻辑代码的数组中给出来。而一个真正好的设计模式要达到的效果是：不对处理逻辑代码进行任何的修改，即不会对MsgProcessor进行修改。那么现在还得增加一个FilterChain，所有的Filter放在这个类当中，我们在真正用时只需实例化FilterChain，并调用其中的方法，也不用去修改FilterChain当中的逻辑代码。

import java.util.ArrayList;
import java.util.List;

/**
 *实现Filter接口的好处是，FilterChain不仅可以将FilterChain
 *串起来，还可以将Filter串起来
 */
public class FilterChain implements Filter{
    List<Filter> filters=new ArrayList<Filter>();
    //返回this，使得可以进行链式编程
    public FilterChain addFilter(Filter filter) {
        filters.add(filter);
        return this;
    }
    @Override
    public String doFilter(String str) {
        for(Filter f:filters) {
            str=f.doFilter(str);
        }
        return str;
    }
}


public class Main {
    public static void main(String[] args) {
       String msg="<script>this is 敏感 information</script>";
       FilterChain fc=new FilterChain();
       fc.addFilter(new HTMLFilter())
       .addFilter(new SensitiveFilter());
       
       String result=fc.doFilter(msg);
       System.out.println(result);
    }
}

评论：设计模式就是要站在制作类库的角度去编写代码，而这里的class Main就是使用者在实际编程的过程当中所要调用类库当中提供的类去实现自己的逻辑。“责任链的编程模式”做到了这一点，我们在编程的时候，如果有新的需求产生，并不需要去改动“类库当中的类”；而是添加新的处理逻辑，再在在使用者角度里的class Main当中对代码进行修改。