設計模式之建造者模式(創建型模式)

簡介
建造者模式（Builder Pattern）使用多個簡單的對象一步一步構建成一個複雜的對象。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。

模式結構

• 產品角色（Product）：它是包含多個組成部件的複雜對象和屬性，是一個模型。

• 抽象建造者（Builder）：它是一個包含創建產品各個子部件的抽象方法的接口或者抽象類，通常還包含一個返回複雜產品的方法 ，該方法一般是抽象並且返回值類型是產品角色（Product）。

• 具體建造者(Concrete Builder）：實現 Builder 接口或者繼承Builder 抽象類，完成複雜產品的各個部件的具體創建方法。

• 指揮者（Director）：它調用建造者（Builder）中的部件構造與裝配方法完成複雜對象的創建，不設計產品具體構建細節。

實現案例
我們以計算機的組裝過程爲例，使用建造者模式，首先我們簡化計算機的組裝過程，這裏只考慮四個主要部件，分別爲主板，顯示器，操作系統和cpu，任何計算機都是有以上四個部分組成的。

public class BuilderPattern {
    public static void main(String[] args) {
        Builder builder=new MacBoolBuilder();
        Director director=new Director(builder);
        director.builder("mac主板","mac顯示頻","macOs","A13Cpu");
        System.out.println(builder.getComputer().toString());
    }
}

//產品類
@Data
class Computer{
    private String board;//主板
    private String display;//顯示器
    private String system;//系統
    private String cpu;
}
//抽象builder類
abstract class Builder{
    //設置主板
    public abstract void builderBoard(String board);
    //設置顯示器
    public abstract void builderDisplay(String display);
    //設置系統
    public abstract void builderSystem(String system);
    //設置cpu
    public abstract void builderCpu(String cpu);
    //創建computer
    public abstract Computer getComputer();
}
//具體builder類
class MacBoolBuilder extends Builder{
    private Computer computer=new Computer();
    @Override
    public void builderBoard(String board) {
        computer.setBoard(board);
    }

    @Override
    public void builderDisplay(String display) {
        computer.setDisplay(display);
    }

    @Override
    public void builderSystem(String system) {
        computer.setSystem(system);
    }

    @Override
    public void builderCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}
//Director類的主要作用是調用具體的builder，來構建對象的各個部分，Director類起到封裝作用，避免高層模塊深入到建造者內部的實現類。
class Director {

    Builder builder=null;

    public Director(Builder builder){
        this.builder=builder;
    }

    public void builder(String board,String display,String system,String os){
        builder.builderBoard(board);
        builder.builderDisplay(display);
        builder.builderSystem(system);
        builder.builderCpu(os);
    }
}

運行結果 ：Computer(board=mac主板, display=mac顯示頻, system=macOs, cpu=A13Cpu)

實際在開發中，Director常常被忽略，而是直接通過Builder的方式鏈式組裝，同是，builder是一個靜態內部類。

@Data
class ThinkPad {
    private String board;//主板
    private String display;//顯示器
    private String system;//系統
    private String cpu;//cpu

    private ThinkPad(Builder builder){
        this.cpu=builder.cpu;
        this.display=builder.display;
        this.board=builder.board;
        this.system=builder.system;
    }

    static class Builder{
        private String board;//主板
        private String display;//顯示器
        private String system;//系統
        private String cpu;//cpu
        public Builder setBoard(String board){
            this.board=board;
            return this;
        }
        public Builder setDisplay(String display){
            this.display=display;
            return this;
        }
        public Builder setSystem(String system){
            this.system=system;
            return this;
        }
        public Builder setCpu(String cpu){
            this.cpu=cpu;
            return this;
        }
        public ThinkPad builder(){
            return new ThinkPad(this);
        }
    }

    public static void main(String[] args) {
        ThinkPad thinkPad=new ThinkPad.Builder().setBoard("Intel").setDisplay("華爲").setCpu("I7").setSystem("win10").builder();
        System.out.println(thinkPad.toString());
    }
}
運行結果： ThinkPad(board=Intel, display=華爲, system=win10, cpu=I7)

建造者模式的典型應用

• StringBuffer 、StringBuilder
• mybatis 中的SqlSessionFactoryBuilder
• Lambda 中的@Builder註解