一起学设计模式 - 创建型设计模式之建造者模式

待我称王封你为后i 2022-11-07 01:45 193阅读 0赞

### 文章目录 ###

*  一起学设计模式 - 创建型设计模式之建造者模式
 *   *  1.建造者模式是什么？
     *  2.建造者模式组成部分
     *  3.建造者模式的实现
     *  4.建造者模式的优缺点

# 一起学设计模式 - 创建型设计模式之建造者模式 #

## 1.建造者模式是什么？ ##

>  `建造者模式（Builder Pattern）`就是使用多个简单的对象一步一步构建成一个复杂的对象，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。  
>    
>  允许用户只通过指定复杂对象的类型和内容就可以构建它们，不需要知道内部的具体构建细节

## 2.建造者模式组成部分 ##

> 建造者模式主要组成有四部分
> 
> 1.  `Builder`：抽象建造者，定义多个通用方法和构建方法。
> 2.  `ConcreteBuilder`：具体建造者，一般有多个。
> 3.  `Director`：指挥者，控制整个组合过程。将需求交给建造者，由建造者去创建对象。
> 4.  `Product`：最终生产的产品角色。  
>      
> 
>  为了方面大家理解我们举一个现实生活的例子。比亚迪汽车工厂现在需要生产汽车，每一辆汽车的整个生产流程除了细节在大体上都是相同的，并且已经实现自动化生产，假设只需操作员选择型号即可。  
>    
>  首先系统会拟定一套流程，比如装发动机->装引擎盖->装轮子->合底盘->整车组装，这一套流程属于标准化的流程适用于所有车型，这就是上面`Builder抽象建造者`的角色；  
>    
>  此时接入该规范的有两套车型，一个比亚迪唐，一个比亚迪汉。现在接到一笔订单需要生产100辆比亚迪唐，此时执行人员就需要在终端上面拟定制造计划然后分发给比亚迪唐的生产线。这里执行人员就相当于`Director`指挥者，而比亚迪唐的生产线就相当于`ConcreteBuilder具体建造者`。  
>    
>  最终生产出来的比亚迪唐/汉就是最终的`Product产品`。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70]

## 3.建造者模式的实现 ##

>  这里我们延续之前的惯例，以电脑的整个组装流程为例，首先我们需要一个电脑的`Product产品实体`。

**电脑对象**

public class Computer { 
    
        private String cpu;
    
        private String memory;
    
        private String disk;
    
        private String power;
    
        private String mainBoard;
    
        public String getCpu() { 
            return cpu;
        }
    
        public void setCpu(String cpu) { 
            this.cpu = cpu;
        }
    
        public String getMemory() { 
            return memory;
        }
    
        public void setMemory(String memory) { 
            this.memory = memory;
        }
    
        public String getDisk() { 
            return disk;
        }
    
        public void setDisk(String disk) { 
            this.disk = disk;
        }
    
        public String getPower() { 
            return power;
        }
    
        public void setPower(String power) { 
            this.power = power;
        }
    
        public String getMainBoard() { 
            return mainBoard;
        }
    
        public void setMainBoard(String mainBoard) { 
            this.mainBoard = mainBoard;
        }
    
        @Override
        public String toString() { 
            return "Computer{" +
                    "cpu='" + cpu + '\'' +
                    ", memory='" + memory + '\'' +
                    ", disk='" + disk + '\'' +
                    ", power='" + power + '\'' +
                    ", mainBoard='" + mainBoard + '\'' +
                    '}';
        }
    }

>  有了主体对象后，首先我们需要定义整个电脑制作流程的`Builder抽象建造者`，里面定义一些建造者的公共接口。

**Builder抽象建造者**

/*** * 建造者公共接口 */
    public interface ComputerBuilder { 
    
        void buildCpu();
    
        void buildMemory();
    
        void buildDisk();
    
        void buildPower();
    
        void buildMainBoard();
    
        Computer createComputer();
    
    
    }

>  接着就是用于生产具体产品的`ConcreteBuilder具体建造者`了，这里我们实现了高配和低配两种电脑的具体建造者。

**高配电脑建造者**

public class HighComputerBuilder implements ComputerBuilder { 
    
        private Computer computer = new Computer();
    
        @Override
        public void buildCpu() { 
            computer.setCpu("高配CPU");
        }
    
        @Override
        public void buildMemory() { 
            computer.setMemory("高配内存");
        }
    
        @Override
        public void buildDisk() { 
            computer.setDisk("高配硬盘");
        }
    
        @Override
        public void buildPower() { 
            computer.setPower("高配电源");
        }
    
        @Override
        public void buildMainBoard() { 
            computer.setMainBoard("高配主板");
        }
    
        @Override
        public Computer createComputer() { 
            return computer;
        }
    }

**低配电脑建造者**

public class LowComputerBuilder implements ComputerBuilder { 
    
        private Computer computer = new Computer();
    
        @Override
        public void buildCpu() { 
            computer.setCpu("低配CPU");
        }
    
        @Override
        public void buildMemory() { 
            computer.setMemory("低配内存");
        }
    
        @Override
        public void buildDisk() { 
            computer.setDisk("低配硬盘");
        }
    
        @Override
        public void buildPower() { 
            computer.setPower("低配电源");
        }
    
        @Override
        public void buildMainBoard() { 
            computer.setMainBoard("低配主板");
        }
    
        @Override
        public Computer createComputer() { 
            return computer;
        }
    }

>  最后就是整个构建过程的`Director指挥者`。`Director`将产品和创建过程进行解耦，使用相同的创建过程创建不同的产品，控制产品生产过程。  
>    
>  `Director`是全程指导组装过程，具体的细节还是`Builder`去操作。

/** * 整个构建过程 指挥者 */
    public class ComputerBuilderDirector { 
    
        public static Computer create(ComputerBuilder builder){ 
            builder.buildCpu();
            builder.buildDisk();
            builder.buildMainBoard();
            builder.buildMemory();
            builder.buildPower();
            return builder.createComputer();
        }
    
        public static void main(String[] args) { 
            Computer highComputer = ComputerBuilderDirector.create(new HighComputerBuilder());
            System.out.println(highComputer.toString());
    
            Computer lowComputer = ComputerBuilderDirector.create(new LowComputerBuilder());
            System.out.println(lowComputer.toString());
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 1]

>  这里把整个的关系图谱放出给大家，整个思路还是比较简单但是比较实用的一种设计模式，在很多源码中也经常使用到。很多时候整个流程不一定完全一样，但是思路大体是差不多的，所以在我们学习设计模式的时候更多是去理解思想进行举一反三。  
>    
>  这里如果需要再抽象一点，可以把`HighComputerBuilder`和`LowComputerBuilder`的获取封装为动态的方式，这个大家根据情况自己调整。

## 4.建造者模式的优缺点 ##

>  建造者模式核心思想就上面那些，这里我们总结一下他的优缺点。
> 
> 1.  `优点`：  
>      客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦；每一个具体建造者都相对独立，而与其他的具体建造者无关，更加精细地控制产品的创建过程。  
>        
>      增加新的具体建造者无须修改原有类库的代码，符合开闭原则；建造者模式结合链式编程来使用，代码上更加美观。
> 2.  `缺点`：建造者模式所创建的产品一般具有较多的共同点，如果产品差异大则不建议使用。  
>      
> 
>  建造者模式和之前介绍的抽象工厂模式也有一点像。建造者模式返回一个组装好的完整产品 ；而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。

--------------------

>  源码地址：[【设计模式博客源码】][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70]: /images/20221023/1c7339c6242c46d1b99bca547d8f77cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 1]: /images/20221023/c2a94d77567249209c77dfd594c77dd4.png
[Link 1]: https://gitee.com/onethree/design-pattern