架构设计五之建造者模式和责任链模式

前言

        建造者模式在设计模式中还算是一个用的比较多的设计模式，建造者设计模式的核心在于隐藏内部构建细节，通过外部的Builder来实现构建。Builder负责Product类对象的具体过程构建，Director负责指导Build，要求Builder按照其指定的顺序去完成Produt的构造。最后通过Builder返回建造后的结果。

标准建造者模式

/**
 * 建造者角色
 * 工人接口，定义了各个工人所需要进行的工作
 * 并不负责具体的建造
 * 
 * 同时房子是具体的（农民工）建造的  所以需要有返回房子的方法
 * @author tucheng
 *
 */
public interface Build {
    public void makeWindow();

    public void  makeFloor();

    public Room getRoom();

}

public class WorkBuilder  implements Build{
    private Room room=new Room();
    @Override
    public void makeWindow() {
        room.setFloor("地板  ");
    }

    @Override
    public void makeFloor() {
        room.setWindow("窗户");
    }

    @Override
    public Room getRoom() {
        return room;
    }
}


/**
 * 房子类  
 * 首先要描述下 房子要有些什么
 * 有哪些属性
 * 
 * @author tucheng
 *
 */
public class Room {
    private String window;  
    private String floor;
    public String getWindow() {
        return window;
    }
    public void setWindow(String window) {
        this.window = window;
    }
    public String getFloor() {
        return floor;
    }
    public void setFloor(String floor) {
        this.floor = floor;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "---->floor  "+floor+"   window   "+window;
    }

}


/**
 * 指导者 角色
 * 所具备的能力
 * 
 * 设计师  他知道房子怎么设计
 * 他会指挥工人去建造
 * 实际生活中  大厦的设计者并不会看大厦的具体实现细节
 * 更多的是从整体角度出发，指挥这个工人团队建造
 * 所以他肯定对工人所具备的能力和行为有很深的了解
 * 换做程序代码中 ，他也肯定会持有工人 的这个对象的引用
 * 
 * 
 * @author tucheng
 *
 */
public class Designer {

    public void order(Build build)
    {
        build.makeFloor();
        build.makeWindow();
    }
}

public class Client {
      public static void main(String[] args) {    
             Build worker = new WorkBuilder(); //获取工人对象   
             Designer  designer = new  Designer();   //获取设计师对象 
             designer.order(worker);    //设计师指挥工人工作
             System.out.println(worker.getRoom());;   //工人交房 
          }  
}

上面就是一个标准的建造者模式，有设计者、有建造者，但是不觉会发现设计师属于多余的一个角色，接着看下对它进行的优化.

优化建造者模式

public class WorkBuilder{
    private RoomParmas parmas;
    public WorkBuilder( ) {
        this.parmas = new RoomParmas();
    }
    public  WorkBuilder makeWindow(String window ) {
        parmas.window=window;
        return this;
    }
    public WorkBuilder makeFloor(String floorCorlor) {
        parmas.floor=floorCorlor;
        return this;
    }
    public WorkBuilder makeDoor(String door) {
        parmas.door=door;
        return this;
    }
    public Room makeChat(String  chat) {
        parmas.chat=chat;
        Room room=new Room();
        return room;
    }
    public  void show()
    {

    }
    public Room build() {
        Room room=new Room();
        room.apply(parmas);
        return room;
    }
    class RoomParmas
    {
        public  String window;  
        public String floor;
        public String door;
        public String  chat;
    }
}

/**
 * 房子类  
 * 首先要描述下 房子要有些什么
 * 有哪些属性
 * 
 * @author tucheng
 *
 */
public class Room {
    private String window;  
    private String floor;
    private String doorl;
    private String  chat;
    public void apply(WorkBuilder.RoomParmas parmas)
    {
        window=parmas.window;
        floor=parmas.floor;
        doorl=parmas.door;
        chat=parmas.chat;
    }
    public void setChat(String chat) {
        this.chat = chat;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "---->floor  "+floor+"   window   "+window;
    }
    public void show()
    {

    }   
}


public class Client {
      public static void main(String[] args) {    
             Room room=(new WorkBuilder()).makeWindow("蓝色玻璃").makeFloor("黄色地板").makeChat("").show();; //获取工人对象   
             System.out.println(room);;   //工人交房 
          }  
}

看到上面的链式调用相信很多人就豁然开朗，这不就是类似于三方框架glide、imageloader的链式调用嘛，说的没错，之所以说建造者模式常用，用的最多的就是存在与三方框架，因为三方框架中包含的实现细节比较多，所以为了不给外部看到内部的实现细节，同时又能给用户更好的扩展，代码又整洁，只有通过这种方式才能实现此目的。

责任链模式

      责任链模式是一种设计模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。
责任链模式涉及到的角色如下所示：
●　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。
●　具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。
实现方式：

public abstract class Handler {
    public Handler nextHandler;
    public  void handleRequest(AbstractRequest abstractRequest)
    {
        if(getHandleLevel()==abstractRequest.getRequestLevel())
        {
            handle(abstractRequest);
        }else {
            if(nextHandler!=null)
            {
                nextHandler.handleRequest(abstractRequest);
            }else {
                System.out.println("---->  所有的处理对象都不能处理它");
            }

        }
    }
    /**
     * 每个处理者的对象的具体处理方式
     * @param abstractRequest
     */
    public abstract void handle(AbstractRequest abstractRequest);
    /**
     * 每个处着对象处理的级别
     * @return
     */
    public abstract int getHandleLevel();
}


public class Handler1 extends Handler{
    @Override
    public void handle(AbstractRequest abstractRequest) {
        System.out.println("----handle1  处理请求: "+abstractRequest.getRequestLevel());
    }

    @Override
    public int getHandleLevel() {
        return 1;
    }
}


public class Handler2 extends Handler {

    @Override
    public void handle(AbstractRequest abstractRequest) {
        System.out.println("----handle2  处理请求: "+abstractRequest.getRequestLevel());
    }

    @Override
    public int getHandleLevel() {
        return 2;
    }
}

public class Handler3  extends Handler {

    @Override
    public void handle(AbstractRequest abstractRequest) {
        System.out.println("----handle3  处理请求: "+abstractRequest.getRequestLevel());
    }

    @Override
    public int getHandleLevel() {
        return 3;
    }
}


public abstract class AbstractRequest {
    private Object object;

    public AbstractRequest(Object object)
    {
        this.object=object;
    }
    /**
     * 具体的内容对象
     * @return
     */
    public Object getContent()
    {
        return object;
    }
    /**
     * 获取请求级别
     */
    public abstract int getRequestLevel();
}


public class Request1 extends AbstractRequest{

    public Request1(Object object) {
        super(object);  
    }

    @Override
    public int getRequestLevel() {
        return 1;
    }
}

public class Request2  extends AbstractRequest{

    public Request2(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 2;
    }
}

public class Request3  extends AbstractRequest{

    public Request3(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 3;
    }
}


public class Client {
    public static void main(String[] args) {
        //确定链式关系
        Handler handler1=new Handler1();
        Handler handler2=new Handler2();
        Handler handler3=new Handler3();
        handler1.nextHandler=handler2;
        handler2.nextHandler=handler3;

        AbstractRequest request3=new Request3("请求1");

        handler1.handleRequest(request3);
    }
}

责任链模式需要发生者去手动建立关系，当遇到if-else比较多的场景的时候，很多的if-else会导致代码不美观，而且扩展性不好。