设计模式-建造者模式

最新推荐文章于 2024-07-12 17:30:22 发布

Alexander Sun

最新推荐文章于 2024-07-12 17:30:22 发布

阅读量227

点赞数

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/xiaohua1230/article/details/116977268

版权

设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

建造者模式

其它创建型模式链接：

建造者模式概述

无论是在现实世界中还是软件系统中都会存在一些复杂的对象，它们拥有多个组成部门，例如汽车，它包括车轮、方向盘、发动机等多种部件。对于大多数用户而言，并不知道这些装配细节，也几乎不会使用单独某个部件，而是使用一辆完整汽车。

如何将这些部件组成一辆汽车是建造者模式需要解决的问题。建造者模式可以将部件本身和它的组装过程分开，用户只需要指定复杂对象的类型即可得到该对象，而无须知道其具体的内部细节。

定义如下：

建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式结构

Builder（抽象建造者）：它为创建一个产品对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类是BuildPartX()，用于创建复杂对象的各个部件；另一类是getResult()，他们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。
ConcreteBuilder（具体建造类）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确所创建的复杂对象。还可以提供一个方法返回创建好的复杂对象。
Product（产品）：它是被构建的复杂对象，包含多个组成部分，具体建造者创建该产品内部表示并定义它的装配过程。
Director（指挥者）：负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互。

建造者模式和抽象工厂模式的区别

建造者模式与抽象工厂模式都是较为复杂的创建型模式，建造者模式返回一个完整的复杂产品，抽象工厂模式返回一系列相关的产品

在抽象工厂模式中，客户端通过选择具体工厂来生产所需要的对象，而在建造者模式中，客户端通过指定具体建造者类型来指导Director类如何去生产对象，侧重于一步步构造一个复杂对象。

如果将抽象工厂模式看成一个汽车配件生产厂，生成不同类型的汽车配件，那么建造者模式就是一个汽车组装厂，通过对配件进行组装返回一辆完整的汽车。

案例

某软件公司的游戏中，游戏角色是一个复杂的对象，它包含性别、脸型等多个组成部分，不同的角色，其性别、脸型、服装、发型等外部特征都有所差异。

无论是何种造型的游戏角色，它的创建过程都大同小异，都需要逐步创建其组成部分，再将各个部门组装成一个完整的游戏角色。

试用建造者模式来实现游戏角色的创建。

结构图

代码实现

Builder

public abstract class ActorBuilder {
    protected static Actor actor = new Actor();

    public abstract void buildType();

    public abstract void buildSex();

    public abstract void buildFace();

    public abstract void buildCostume();

    public abstract void buildHairStyle();

    public Actor createActor() {
        return actor;
    }
}

Product

@Data
public class Actor {
    private String type;
    private String sex;
    private String face;
    private String costume;
    private String hairStyle;
}

ConcreteBuilder

public class AngelBuilder extends ActorBuilder {
    @Override
    public void buildType() {
        actor.setType("天使");
    }

    @Override
    public void buildSex() {
        actor.setSex("女");
    }

    @Override
    public void buildFace() {
        actor.setFace("漂亮");
    }

    @Override
    public void buildCostume() {
        actor.setCostume("白裙");
    }

    @Override
    public void buildHairStyle() {
        actor.setHairStyle("披肩长发");
    }
}

public class DevilBuilder extends ActorBuilder {
    @Override
    public void buildType() {
        actor.setType("恶魔");
    }

    @Override
    public void buildSex() {
        actor.setSex("妖");
    }

    @Override
    public void buildFace() {
        actor.setFace("丑陋");
    }

    @Override
    public void buildCostume() {
        actor.setCostume("黑衣");
    }

    @Override
    public void buildHairStyle() {
        actor.setHairStyle("光头");
    }
}

public class HeroBuilder extends ActorBuilder {
    @Override
    public void buildType() {
        actor.setType("英雄");
    }

    @Override
    public void buildSex() {
        actor.setSex("男");
    }

    @Override
    public void buildFace() {
        actor.setFace("英俊");
    }

    @Override
    public void buildCostume() {
        actor.setCostume("盔甲");
    }

    @Override
    public void buildHairStyle() {
        actor.setHairStyle("飘逸");
    }
}

Director

public class ActorController {
    public Actor construct(ActorBuilder actorBuilder) {
        Actor actor;
        actorBuilder.buildType();
        actorBuilder.buildSex();
        actorBuilder.buildFace();
        actorBuilder.buildCostume();
        actorBuilder.buildHairStyle();
        actor = actorBuilder.createActor();
        return actor;
    }
}

客户端

public class Demo {
    public static void main(String[] args) {
        ActorBuilder actorBuilder;
       actorBuilder=(ActorBuilder) XmlUtil.getBean();
       ActorController actorController=new ActorController();
        Actor actor = actorController.construct(actorBuilder);
        System.out.println("type: "+actor.getType());
        System.out.println("sex: "+actor.getSex());
        System.out.println("face: "+actor.getFace());
        System.out.println("costume: "+actor.getCostume());
        System.out.println("hairStyle: "+actor.getHairStyle());
    }
}

配置文件

<?xml version = "1.0"?>
<config>
    <chartType>rectangle</chartType>
    <className>builder.AngelBuilder</className>
</config>

效果展示

type: 天使
sex: 女
face: 漂亮
costume: 白裙
hairStyle: 披肩长发

指挥者类的深入讨论

省略Director

有些情况下，为了简化系统结构，可以将Director和抽象建造者Builder进行合并，在Builder中逐步提供构建复杂产品对象的construct()方法。由于Builder通常为抽象类，因此可以将construct方法定义为静态方法，以便可以直接调用。

现在对案例的Builder进行修改

public abstract class ActorBuilder {
    protected static Actor actor = new Actor();

    public abstract void buildType();

    public abstract void buildSex();

    public abstract void buildFace();

    public abstract void buildCostume();

    public abstract void buildHairStyle();

    public Actor construct(ActorBuilder actorBuilder) {
        actorBuilder.buildType();
        actorBuilder.buildSex();
        actorBuilder.buildFace();
        actorBuilder.buildCostume();
        actorBuilder.buildHairStyle();
        return actor;
    }
}

还可以将construct参数去掉，直接调用方法

public abstract class ActorBuilder {
    protected static Actor actor = new Actor();

    public abstract void buildType();

    public abstract void buildSex();

    public abstract void buildFace();

    public abstract void buildCostume();

    public abstract void buildHairStyle();

    public Actor construct(ActorBuilder actorBuilder) {
        this.buildType();
        this.buildSex();
        this.buildFace();
        this.buildCostume();
        this.buildHairStyle();
        return actor;
    }
}

钩子方法的引入

可以通过引入钩子方法来控制是否对buildPartXXX()方法的调用。

对Builder进行改造

public abstract class ActorBuilder {
    protected static Actor actor = new Actor();

    public abstract void buildType();

    public abstract void buildSex();

    public abstract void buildFace();

    public abstract void buildCostume();

    public abstract void buildHairStyle();
	
    //钩子方法
    public boolean isBareheaded(){
        return false;
    }
    
    public Actor createActor() {
        return actor;
    }
}

修改具体的Builder

恶魔不需要头发，所以无需构建头发部件

public class DevilBuilder extends ActorBuilder {
    @Override
    public void buildType() {
        actor.setType("恶魔");
    }

    @Override
    public void buildSex() {
        actor.setSex("妖");
    }

    @Override
    public void buildFace() {
        actor.setFace("丑陋");
    }

    @Override
    public void buildCostume() {
        actor.setCostume("黑衣");
    }

    @Override
    public void buildHairStyle() {
        actor.setHairStyle("光头");
    }
    //覆盖钩子方法
    @Override
    public boolean isBareheaded(){
        return true;
    }
}

修改Director

public class ActorController {
    public Actor construct(ActorBuilder actorBuilder) {
        Actor actor;
        actorBuilder.buildType();
        actorBuilder.buildSex();
        actorBuilder.buildFace();
        actorBuilder.buildCostume();
        if (!actorBuilder.isBareheaded()){
            actorBuilder.buildHairStyle();
        }
        actor = actorBuilder.createActor();
        return actor;
    }
}

建造者模式优缺点与适用环境

建造者模式优点

建造者模式的优点主要有如下：

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