设计模式之-建造者模式

 

目录

        概述

        建造者模式包含以下4个角色：

Builder（抽象建造者）

ConcreteBuilder（具体建造者）

Product（产品）

Director（指挥者）

实例代码

(1) Actor：游戏角色类，充当复杂产品对象

(2) ActorBuilder：游戏角色建造者，充当抽象建造者

(4) AngelBuilder：天使角色建造者，充当具体建造者

(5) NanJunYuBuilder：自己角色建造者，充当具体建造者

(6) ActorController：角色控制器，充当指挥者

(7) Client：客户端测试类

         代码结果及分析:

         模式优点:

         模式缺点:

         模式适用环境:

---

概述:

       建造者模式可以将部件本身和它们的组装过程分开，关注如何一步步创建一个包含多个组成部分的复杂对象，用户只需要指定复杂对象的类型即可得到该对象，而无须知道其内部的具体构造细节。

•      将客户端与包含多个部件的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可
• 关注如何逐步创建一个复杂的对象，不同的建造者定义了不同的创建过程。

 

 

建造者模式包含以下4个角色：

• Builder（抽象建造者）

• ConcreteBuilder（具体建造者）

• Product（产品）

• Director（指挥者）

 

建造者模式的实现 典型的复杂对象类代码：

假如我们要创建一些游戏角色，不同的角色有不同的外观属性，我们将游戏角色这个复杂的对象用建造者模式进行构建。

 

实例类图。

 

实例代码

• (1) Actor：游戏角色类，充当复杂产品对象

• (2) ActorBuilder：游戏角色建造者，充当抽象建造者

• (4) AngelBuilder：天使角色建造者，充当具体建造者

• (5) NanJunYuBuilder：自己角色建造者，充当具体建造者

• (6) ActorController：角色控制器，充当指挥者

• (7) Client：客户端测试类

创建 Actor类 充当复杂产品对象

package designpatterns.builder;

/**
 * @Author: Frank
 * @Description: Actor充当复杂产品对象
 * @Date: Create in  2018/10/22 8:11 PM
 */
public class Actor {
    private String type;       //角色类型
    private String sex;        //性别
    private String face;       //脸型
    private String costume;    //服装
    private String hairstyle;  //发型

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getFace() {
        return face;
    }

    public void setFace(String face) {
        this.face = face;
    }

    public String getCostume() {
        return costume;
    }

    public void setCostume(String costume) {
        this.costume = costume;
    }

    public String getHairstyle() {
        return hairstyle;
    }

    public void setHairstyle(String hairstyle) {
        this.hairstyle = hairstyle;
    }
}

定义ActorBuilder抽象类 游戏角色建造者 ，充当抽象建造者 

package designpatterns.builder;

/**
 * @Author: Frank
 * @Description: ActorBuilder 游戏角色建造者 ，充当抽象建造者
 * @Date: Create in  2018/10/22 8:16 PM
 */
public abstract class ActorBuilder {
    protected Actor actor = new Actor();

    protected abstract void buildType();

    protected abstract void buildSex();

    protected abstract void buildCostume();

    protected abstract void buildHairStyle();

    protected abstract void buildFace();

    //工厂方法返回一个完整的游戏角色对象
    public Actor createActor() {
        return actor;
    }
}

定义ActorController 角色控制器，充当指挥官

package designpatterns.builder;

/**
 * @Author: Frank
 * @Description:ActorController 角色控制器，充当指挥官
 * @Date: Create in  2018/10/22 8:38 PM
 */
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;
    }
}

我们现在创建一个天使的角色， AngelBuilder

package designpatterns.builder;

/**
 * @Author: Frank
 * @Description: AngelBuilder 天使角色建造者，充当具体建造者
 * @Date: Create in  2018/10/22 8:29 PM
 */
public class AngelBuilder extends ActorBuilder {
    @Override
    protected void buildType() {
        actor.setType("天使");
    }

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

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

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

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

• 我们测试一下

package designpatterns.builder;

/**
 * @Author: Frank
 * @Description: 客户端测试类
 * @Date: Create in  2018/10/22 8:42 PM
 */
public class BuilderClient {
    public static void main(String[] args) {
        ActorBuilder actorBuilder=new AngelBuilder();
        ActorController actorController = new ActorController();
        Actor actor=actorController.construct(actorBuilder);
        String type = actor.getType();
        System.out.println(type + "的外观：");
        System.out.println("性别：" + actor.getSex());
        System.out.println("面容：" + actor.getFace());
        System.out.println("服装：" + actor.getCostume());
        System.out.println("发型：" + actor.getHairstyle());
    }
}

现在我们再创建一个自己，我们只需要继承ActorBuilder类就行了。并不会动之前的代码

package designpatterns.builder;

/**  创建一个自己
 * @Author Frank
 * @Description
 * @Date: Create in  2019-07-09 17:22
 */
public class NanJunYuBuilder extends ActorBuilder{

    @Override
    protected void buildType() {
        actor.setType("小哥哥");
    }

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

    @Override
    protected void buildCostume() {
        actor.setCostume("nike");
    }

    @Override
    protected void buildHairStyle() {
        actor.setHairstyle("渣男锡纸烫");
    }

    @Override
    protected void buildFace() {
        actor.setFace("帅气");
    }
}

package designpatterns.builder;

/**
 * @Author: Frank
 * @Description: 客户端测试类
 * @Date: Create in  2018/10/22 8:42 PM
 */
public class BuilderClient {
    public static void main(String[] args) {
        ActorBuilder actorBuilder=new NanJunYuBuilder();
        ActorController actorController = new ActorController();
        Actor actor=actorController.construct(actorBuilder);
        String type = actor.getType();
        System.out.println(type + "的外观：");
        System.out.println("性别：" + actor.getSex());
        System.out.println("面容：" + actor.getFace());
        System.out.println("服装：" + actor.getCostume());
        System.out.println("发型：" + actor.getHairstyle());
    }
}

 

代码结果及分析:

    如果需要更换具体角色建造者，只需要修改配置文件(利用反射，有兴趣的同学可以拓展) 当需要增加新的具体角色建造者时，只需将新增具体角色建造者作为抽象角色建造者的子类，然后修改配置文件即可，原有代码无须修改，完全符合开闭原则

 

模式优点:

       客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象 每一个具体建造者都相对独立，与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，扩展方便，符合开闭原则 可以更加精细地控制产品的创建过程

 

模式缺点:

       建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，不适合使用建造者模式，因此其使用范围受到一定的限制 如果产品的内部变化复杂，可能会需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加了系统的理解难度和运行成本

 

模式适用环境:

     需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员变量 需要生成的产品对象的属性相互依赖，需要指定其生成顺序 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

 

相关代码；

 https://gitee.com/nanjunyu/designPatterns-study.git

 

                                                                    原创公众号
                                                        关注java 设计模式，JVM特性，
                                                        并发编程、分布式、微服务，
                                                        inux高可用集群，等相关技术。
                                                                扫一扫关注我吧！