4.建造者模式

最新推荐文章于 2022-05-18 20:14:56 发布

鹏哥哥啊Aaaa

最新推荐文章于 2022-05-18 20:14:56 发布

阅读量4.4k

点赞数 3

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

本文链接：https://blog.csdn.net/qq_40594696/article/details/107004220

版权

设计模式专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1.建造者模式是什么？

对于一些复杂对象，它们是由多个组成部分组成。用户不需要知道每个部分，只使用完整的对象就行。

以汽车为例，包括发动机、方向盘、车轮，用户不需要知道它们是怎么做的，只需要使用汽车这个对象就行。

建造者模式需要做的是将部件本身和它们的组装过程分开，关注如何一步步的创建一个复杂对象。而用户只需要指定复杂对象的类型就可以得到复杂对象，不需要知道其细节。

2.建造者模式结构

（1）Builder（抽象建造者）：指定抽象接口。在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Build既可以是抽象类，也可以是接口。

（2）ConcreteBuilder（具体建造者）：它实现Builder接口，实现各个部件的具体构造和装配方法

（3）Product（产品）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程

（4）Director（指挥者）：指挥者又叫导演类，它负责安排复杂对象的建造次序。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象，然后通过指挥者类的构造函数或者setter方法将该对象传入指挥者类中

3.建造者模式实现

复杂对象=包含多个成员变量的对象

（1）声明复杂对象

public class Product {
    //定义部件
    private String partA;
    private String partB;
    private String partC;

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

（2）抽象建造者

/**
 * 抽象建造者
 */
public abstract class Builder {
    //创建产品对象
    protected Product product = new Product();

    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();

    //返回产品对象
    public Product getResult(){
        return product;
    }
}

（3）具体建造者

/**
 * 具体建造者
 */
public class ConcreteBuilder1 extends Builder {
    @Override
    public void buildPartA() {
        product.setPartA("A1");
    }

    @Override
    public void buildPartB() {
        product.setPartB("B1");
    }

    @Override
    public void buildPartC() {
        product.setPartC("C1");
    }
}

（4）指挥者

/**
 * 指挥者
 */
public class Director {
    private Builder builder;

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

    public void setBuilder(Builder builder){
        this.builder = builder;
    }

    //产品构建与组装方法
    public Product construct(){
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

（5）客户端使用建造者模式

/**
 * 客户端使用建造者模式
 */
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder1();//可通过配置文件实现
        Director director = new Director(builder);
        Product product = director.construct();
    }
}

4.建造者模式应用实例——使用建造者模式来实现游戏角色的创建

（1）游戏角色，复杂对象

/**
 * 游戏角色
 */
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;
    }
}

（2）抽象建造者

/**
 * 游戏角色抽象建造者
 */
public abstract class ActorBuilder {
    protected 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;
    }
}

（3）三个具体建造者

/**
 * 英雄角色建造者，充当具体建造者
 */
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("飘逸");
    }
}

/**
 * 天使角色创造者，充当具体建造者
 */
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("光头");
    }
}

（4）指挥者

/**
 * 指挥者
 */
public class ActorController {
    //逐步构建复杂产品对象
    public Actor construct(ActorBuilder ab){
        Actor actor;
        ab.buildType();
        ab.buildSex();
        ab.buildFace();
        ab.buildCostume();
        ab.buildHairstyle();
        actor = ab.createActor();
        return actor;
    }
}

（5）配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <className>controller.buildModuleRole.AngelBuilder</className>
</config>

（6）工具类

public class XMLUtil {
    /**
     * 从xml配置文件中提取具体类的类名，并返回一个实例对象
     */
    public static Object getBean(){
        try {
            //创建DOM文档对象
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
            Document document = builder.parse(new File("src//controller//buildModuleRole//config.xml"));

            //获取包含类名的文本节点
            NodeList nl = document.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = classNode.getNodeValue();

            //通过类名生成实例对象并将其返回
            Class c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;

        }catch (Exception e){
            e.printStackTrace();
            return  null;
        }

    }
}

（7）客户端测试类

/**
 * 客户端测试类
 */
public class Client {
    public static void main(String args[]){
        ActorBuilder ab;
        ab = (ActorBuilder)XMLUtil.getBean();//反射生成具体建造者对象

        ActorController ac = new ActorController();
        Actor actor;
        actor = ac.construct(ab);//根据指挥者创建完整的建造者对象

        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());
    }
}

（8）路径及返回结果

5.指挥者类的深入讨论

指挥者类用于指导具体建造者如何构建产品，它按一定顺序调用Builder的buildPartX()方法，控制调用的先后次序，并向客户端返回一个完整的产品对象。下面讨论几种指挥者类的变化形式：

（1）省略指挥者类

在Builder中提供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 createActor(){
//        return actor;
//    }

    public static Actor construct(ActorBuilder ab){
        ab.buildType();
        ab.buildSex();
        ab.buildFace();
        ab.buildCostume();
        ab.buildHairstyle();
        return actor;
    }
}

/**
 * 客户端测试类
 */
public class Client {
    public static void main(String args[]){
        ActorBuilder ab;
        ab = (ActorBuilder)XMLUtil.getBean();//反射生成具体建造者对象
        Actor actor;
        actor = ActorBuilder.construct(ab);

//        ActorController ac = new ActorController();
//        actor = ac.construct(ab);//根据指挥者创建完整的建造者对象

        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());
    }
}

在此基础上还可以更加简便一步，将construct()中的参数去掉：（注意static）

/**
 * 游戏角色抽象建造者
 */
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;
//    }

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

/**
 * 客户端测试类
 */
public class Client {
    public static void main(String args[]){
        ActorBuilder ab;
        ab = (ActorBuilder)XMLUtil.getBean();//反射生成具体建造者对象
        Actor actor;
        actor = ab.construct();

//        ActorController ac = new ActorController();
//        actor = ac.construct(ab);//根据指挥者创建完整的建造者对象

        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());
    }
}

（2）钩子方法的引入

建造者模式可以逐步构建一个复杂产品，还可以通过钩子方法（Hook Method）来控制是否对某个buildPartX()进行调用。

钩子方法的返回类型通常类boolean类型，方法名一般是isXXX()，钩子方法定义在抽象建造者的类中。

说白了，就是加一个校验，仅此而已。

/**
 * 游戏角色抽象建造者
 */
public abstract class ActorBuilder {
    protected 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;
    }
}


/**
 * 恶魔角色创造者，充当具体建造者
 */
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;
    }
}


/**
 * 客户端测试类
 */
public class Client {
    public static void main(String args[]){
        ActorBuilder ab;
        ab = (ActorBuilder)XMLUtil.getBean();//反射生成具体建造者对象

        ActorController ac = new ActorController();
        Actor actor;
        actor = ac.construct(ab);//根据指挥者创建完整的建造者对象

        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());
    }
}

6.建造者模式的优缺点

优：

（1）客户端不必知道产品细节，将产品与产品创建解耦

（2）每个具体建造者独立，所以替换或者新增具体建造者很方便

（3）通过钩子更加精确的控制创建过程

缺：

（1）建造者模式适用于产品有较多共同点的，如果差异很大不适合。因此适用范围受到限制

（2）过多的具体建造者会增加系统理解程度

7.适用范围

（1）复杂的对象，一般含有多个成员变量

（2）对象属性互相依赖，需要制定生成顺序

（3）对象的创建过程独立于创建该对象的类。建造者模式是在指挥者类完成，而不是建造者类