创建型模式 - 建造者模式

最新推荐文章于 2024-09-12 17:23:35 发布

橘子上树丶

最新推荐文章于 2024-09-12 17:23:35 发布

阅读量261

点赞数 1

分类专栏：设计模式文章标签：建造者模式对象构建链式调用工厂模式代码重构

本文链接：https://blog.csdn.net/qq398470261/article/details/118765661

版权

设计模式专栏收录该内容

23 篇文章 0 订阅

订阅专栏

系列文章目录

文章目录

系列文章目录
前言
一、建造者模式
- 1.1 建造者模式介绍
- 1.2 建造者模式结构
二、实现
四、建造者模式的注意事项和细节
五、参考文献

前言

代码地址

一、建造者模式

1.1 建造者模式介绍

建造者模式又叫生成器模式，是一种对象构建模式，它可以将复杂对象的创造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象；
建造者模式是一步一步创建一个复杂对象，它允许客户只通过制定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节；

1.2 建造者模式结构

产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件；
抽象建造者（Builder）：它是一个包含创建产品各个部件指定的接口/抽象类；
具体建造者（Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法；
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息；

二、实现

现在有这样一个需求：

需要盖房子，这一过程为打桩、砌墙、封顶
房子有各种各样的，比如普通房、高楼、别墅，各种房子的过程虽然一样，但是要求不是相同的；

2.1 传统实现

在这里插入图片描述

package com.dozezz.designpattern.builder.traditional;

/**
 * @Description: 抽象类
 * @Author: dozezz
 * @Date: 2021/7/14 21:09
 * @Version: 1.0
 */
public abstract class AbstractHouse {

    public abstract void buildBasic();

    public abstract void buildWall();

    public abstract void roofed();

    public void build(){
        buildBasic();
        buildWall();
        roofed();
    }
}

package com.dozezz.designpattern.builder.traditional;

/**
 * @Description: 具体类
 * @Author: dozezz
 * @Date: 2021/7/14 21:15
 * @Version: 1.0
 */
public class CommonHouse extends AbstractHouse{
    @Override
    public void buildBasic() {
        System.out.println(String.format("%s 打桩..","CommonHouse"));
    }

    @Override
    public void buildWall() {
        System.out.println(String.format("%s 砌墙..","CommonHouse"));
    }

    @Override
    public void roofed() {
        System.out.println(String.format("%s 封顶..","CommonHouse"));
    }
}

package com.dozezz.designpattern.builder.traditional;

/**
 * @Description: 传统方法客户端
 * @Author: dozezz
 * @Date: 2021/7/14 21:02
 * @Version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        AbstractHouse abstractHouse = new CommonHouse();
        abstractHouse.build();
    }
}

优点是比较好理解，简单易操作；
设计的程序结构，过于简单，没有涉及缓存层对象，程序的扩展和维护不好。也就是说，这种设计方案，把产品（如：房子）和创建产品的过程（如：建房子流程）封装在一起，耦合性增强了；
解决方案：将产品和产品建造过程结构 ==> 建造者模式；

2.2 建造者模式实现

在这里插入图片描述

package com.dozezz.designpattern.builder.builder;

/**
 * @Description: 具体产品
 * @Author: dozezz
 * @Date: 2021/7/14 19:18
 * @Version: 1.0
 */
public class House {
    private String basic;

    private String wall;

    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

package com.dozezz.designpattern.builder.builder;

/**
 * @Description: 抽象建造者
 * @Author: dozezz
 * @Date: 2021/7/14 19:28
 * @Version: 1.0
 */
public abstract class AbstractHouseBuilder {

    public House house;

    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void roofed();

    public abstract House buildHouse();
}

package com.dozezz.designpattern.builder.builder;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/14 19:46
 * @Version: 1.0
 */
public class CommonHouse extends AbstractHouseBuilder{

    public CommonHouse() {
        house = new House();
    }

    @Override
    public void buildBasic() {
        house.setBasic(String.format("%s 打桩","CommonHouse"));
    }

    @Override
    public void buildWalls() {
        house.setWall(String.format("%s 砌墙","CommonHouse"));
    }

    @Override
    public void roofed() {
        house.setRoofed(String.format("%s 封顶","CommonHouse"));
    }

    @Override
    public House buildHouse() {
        return house;
    }
}

package com.dozezz.designpattern.builder.builder;

/**
 * @Description: 指挥者，这里去指定制作流程，返回产品
 * @Author: dozezz
 * @Date: 2021/7/14 19:40
 * @Version: 1.0
 */
public class HouseDirector {

    private AbstractHouseBuilder houseBuilder;

    //构造器传入 AbstractHouseBuilder
    public HouseDirector(AbstractHouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //如何处理建造房子的流程，交给指挥者
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }

}

package com.dozezz.designpattern.builder.builder;

/**
 * @Description: 客户端 - 建造者模式创建复杂对象
 * @Author: dozezz
 * @Date: 2021/7/14 21:03
 * @Version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        HouseDirector houseDirector = new HouseDirector(new CommonHouse());
        House house = houseDirector.constructHouse();
        System.out.println(house.toString());

//        House{basic='CommonHouse 打桩', wall='CommonHouse 砌墙', roofed='CommonHouse 封顶'}
    }
}

上面示例中，导演类在建造者模式中具有和重要的作用，它用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把导演类和抽象建造者进行结合；

abstract class AbstractHouseBuilder1 {

    public House house;

    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void roofed();

    public abstract House buildHouse();
    
    public House newHouse(){
        this.buildBasic();
        this.buildWalls();
        this.roofed();
        
        return this.buildHouse();
    }
}

这样做确实简化了系统结构，但是同时也加重了抽象建造者的职责，又不是太符合单一职责原则，如果newHouse()过于复杂，建议还是封装到导演类中；
还有一种常用的使用方式，就是方一个类构造器需要传入很多参数时，如果创见证类的实例，代码可读性会非常差，而且容易引起错误，此时就可以利用建造者模式构建；

class NewHouse {
    private String basic;

    private String wall;

    private String roofed;

    public String getBasic() {
        return basic;
    }

    public NewHouse(Builder builder) {
        this.basic = builder.basic;
        this.wall = builder.wall;
        this.roofed = builder.roofed;
    }

    public static final class Builder{
        private String basic;

        private String wall;

        private String roofed;

        public Builder basic(String basic){
            this.basic = basic;
            return  this;
        }

        public Builder wall(String wall){
            this.wall = wall;
            return  this;
        }

        public Builder roofed(String roofed){
            this.roofed = roofed;
            return  this;
        }

        public NewHouse build(){
            return  new NewHouse(this);
        }
    }

    @Override
    public String toString() {
        return "NewHouse{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

2. 3 链式调用实现

package com.dozezz.designpattern.builder.chain;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/15 21:26
 * @Version: 1.0
 */
public abstract class AbstractBuilder {

    Phone phone ;

    public abstract AbstractBuilder customizedCpu(String cpu);

    public abstract AbstractBuilder customizedMem(String mem);

    public abstract AbstractBuilder customizedDisk(String disk);

    public abstract AbstractBuilder customizedCam(String cam);

    public Phone getPhone(){
        return  phone;
    }
}

package com.dozezz.designpattern.builder.chain;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/15 22:01
 * @Version: 1.0
 */
public class XiaomiBuilder extends AbstractBuilder{

    public XiaomiBuilder() {
        phone = new Phone();
    }

    @Override
    public AbstractBuilder customizedCpu(String cpu) {
        phone.setCpu(cpu);
        return this;
    }

    @Override
    public AbstractBuilder customizedMem(String mem) {
        phone.setMem(mem);
        return this;
    }

    @Override
    public AbstractBuilder customizedDisk(String disk) {
        phone.setDisk(disk);
        return this;
    }

    @Override
    public AbstractBuilder customizedCam(String cam) {
        phone.setCam(cam);
        return this;
    }
}

package com.dozezz.designpattern.builder.chain;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/15 21:24
 * @Version: 1.0
 */
public class Phone {
    private String cpu;
    private String mem;
    private String disk;
    private String cam;

    public String getCpu() {
        return cpu;
    }

    public String getMem() {
        return mem;
    }

    public String getDisk() {
        return disk;
    }

    public String getCam() {
        return cam;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMem(String mem) {
        this.mem = mem;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public void setCam(String cam) {
        this.cam = cam;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", mem='" + mem + '\'' +
                ", disk='" + disk + '\'' +
                ", cam='" + cam + '\'' +
                '}';
    }
}

package com.dozezz.designpattern.builder.chain;

/**
 * @Description:
 * @Author: dozezz
 * @Date: 2021/7/15 22:09
 * @Version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        XiaomiBuilder xiaomiBuilder = new XiaomiBuilder();
        AbstractBuilder builder = xiaomiBuilder.customizedCam("定制相机").customizedCpu("定制CPU").customizedMem("定制内存").customizedDisk("定制硬盘");
        System.out.println(builder.getPhone());
    }
}

public class Client {
    public static void main(String[] args) {
//        HouseDirector houseDirector = new HouseDirector(new CommonHouse());
//        House house = houseDirector.constructHouse();
//        System.out.println(house.toString());

//        House{basic='CommonHouse 打桩', wall='CommonHouse 砌墙', roofed='CommonHouse 封顶'}


        NewHouse newHouse = new NewHouse.Builder().basic("打桩").wall("砌墙").roofed("封顶").build();
        System.out.println(newHouse.toString());

//        NewHouse{basic='打桩', wall='砌墙', roofed='封顶'}
    }
}

四、建造者模式的注意事项和细节

4.1 建造者模式优缺点

优点：

客户端不必知道产品内部组成的细节，将产品本身和产品创建过程解耦，使得相同的创建过程可以创建不同的产品对象；
每一个具体建造者都相对独立，而与其他具体建造者无关，因此可以很方便地增加或替换具体建造者，用户使用不同的具体建造者即可得到不同的产品对象；
可以更加精细地控制产品创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程；
增加新的具体创建者无需修改原有类库的代码，指挥者类针对抽象建造者编程，系统扩展更方便，符合开闭原则

缺点：

产品之间差异性很大的情况：建造者模式多创建的产品一般都具有较多的共同特点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围收到一定限制；
产品内部变化复杂的情况：如果产品的内部变化复杂，可能会导致需要定义很多的建造者类来实现这种变化，导致系统变得很庞大；

4.2 适用场景

相同的方法，不同执行顺序，产生不同结果；
多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同；
产品类非常复杂或者产品类中不同的调用顺序产生不同的作用；
初始化一个对象特别复杂，参数多，而且很多参数都具有默认值；

4.3 建造者模式、工厂模式区别

建造者模式与抽象工厂模式相比，建造者模式返回一个组装好的完整产品，针对一个产品等级，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级，构成一个产品族；
建造者更加注重方法的调用顺序，工厂模式注重创建对象；
建造者模式创建复杂对象，由各种复杂的组件构成，在建造过程中顺序不一样最终对象部件组成也不一样，工厂模式创建出来的对象都一样；
抽象工厂中，客户端实例化工厂类，然后调用工厂方法获取产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类指导如何生成对象，包括对象的组装和建造步骤，侧重一步步构造一个复杂对象，返回一个完整对象；

五、参考文献

http://c.biancheng.net/view/1354.html
https://www.bilibili.com/video/BV1G4411c7N4?p=54&spm_id_from=pageDriver
https://baiyp.ren/JAVA%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-08%E5%BB%BA%E9%80%A0%E8%80%85%E6%A8%A1%E5%BC%8F.html

橘子上树丶

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
创建型模式 - 建造者模式

系列文章目录文章目录系列文章目录前言一、建造者模式1.1 建造者模式介绍1.2 建造者模式结构二、实现2.1 传统实现2.2 建造者模式实现2. 3 链式调用实现四、建造者模式的注意事项和细节4.1 建造者模式优缺点4.2 适用场景4.3 建造者模式、工厂模式区别五、参考文献前言代码地址一、建造者模式1.1 建造者模式介绍建造者模式又叫生成器模式，是一种对象构建模式，它可以将复杂对象的创造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象；
复制链接

扫一扫