Java建造者模式原型和链式变种

建造者最开始有4个角色
1.用户client，提出造房子 Room的需求
2.设计者，Designer,出图纸，指挥包工头干，持有包工头
3.包工头， interface Build,拥有步骤和返回房子Room
4.Room，最终的产品
这里写图片描述

代码从client开始

public class Client {
    //client 客户提出需求，造房子，并得到房子
    //不关心过程和建造逻辑
    public static void main(String[] args) {
        //1.提供具体建造者
        WorkerBuilder worker=new WorkerBuilder();
        //2.设计指导者
        Desinger designer=new Desinger();
        //3.准备开始建造
        Room room=designer.preparBuild(worker);
        //4.建造完成，验收
        System.out.println("room建造完成:"+room.toString());
    }
}

这里写图片描述
从上面可以很好的看出，client提出到最后得到，可以完全省掉了建造逻辑和过程，这就是最初的建造者模式模型。

下面是包工头和具体工人实现

public interface Build {
    **//抽象 建造者,包工头**
    void makeWindow();
    void makeFloor();
    Room build();
}
public class WorkerBuilder implements Build {
    //**具体建造者 工人worker持有房子引用**
    Room room=new Room();
    @Override
    public void makeWindow() {
        // TODO Auto-generated method stub
        room.setWindow("透明玻璃窗户！");
    }

    @Override
    public void makeFloor() {
        // TODO Auto-generated method stub
        room.setFloor("意大利地板");
    }

    @Override
    public Room build() {
        // TODO Auto-generated method stub
        return room;
    }
}

public class Desinger {
    //设计师出图纸，管理着具体建造者
    public Room preparBuild(Build builder) {
        //指挥工人施工
        builder.makeFloor();
        builder.makeWindow();
        return builder.build();
    }
}
public class Room {
    //产品类，room，最红返回给client
    private String window;
    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;
    }
    private String floor;
    @Override
    public String toString() {
        return "Room [window=" + window + ", floor=" + floor + "]";
    }

总结：然后因为Room的字段都是public，对外开放，用户可以看得到调用并修改建造过程，这不是最好的方式。只是最初的简单原型。

下面是建造者模式变形之后的的模型图
这里写图片描述

对比第一张图，去掉了抽象建造者，既是包工头interface Build；
去掉了设计师傅，designer,可以抽象的来说，这个变形就是具体实施工人自己直接接活了

public class Client {
    //client 客户提出需求，造房子，并得到房子
    //不关心过程和建造逻辑
    public static void main(String[] args) {
        //1.提供具体建造者，链式编程
        Room room=new WorkerBuilder().makeFloor("光滑地板").makeWindow("透明窗口").build();
        //4.建造完成，验收
        System.out.println("room建造完成:"+room.toString());
    }
}

这里写图片描述

public class Room {
    //产品类，room，最红返回给client
    private String window;
    private String floor;

    /**
     * 隐藏set 和get 之后真正的构建过程
     * @param roomParams
     * @return
     */
    public Room freshRoom(RoomParams roomParams) {
        this.window=roomParams.window;
        this.floor=roomParams.floor;
        return this;
    }

    @Override
    public String toString() {
        return "Room [window=" + window + ", floor=" + floor + "]";
    }
}

public class WorkerBuilder {
    //具体建造者 工人worker持有房子引用
    Room room=new Room();
    RoomParams roomParams=new RoomParams();

    public WorkerBuilder makeWindow(String windowStyle) {
        roomParams.setWindow(windowStyle);
        return this;
    }

    public WorkerBuilder makeFloor(String floorStyle) {
        roomParams.setFloor(floorStyle);
        return this;
    }

    public Room build() {
        // TODO Auto-generated method stub
        return room.freshRoom(roomParams);
    }

    class RoomParams{
        public String window;
        public void  setWindow(String window) {
            this.window = window;
        }
        public void setFloor(String floor) {
            this.floor = floor;
        }
        public String floor;
    }
}

Java建造者模式原型和链式变种

猜你喜欢