GOF23-建造者模式

建造者模式定义：建造者模式分离了对象子组件的构造（由builder构造）和装配（由director装配）。从而可以构造出复杂的对象。

适用环境：某个对象构建过程比较复杂。实现对象的创建和装配解耦，让客户端使用者只需要关心自己得到的产品而不是关心产品时怎样具体产生的（这一点类似工厂模式。）

一、工厂模式与建造者模式区别及其联系

1.区别

工厂模式：产生的一个产品是一个整体。比如一个强壮的机器人。一个红的机器人

建造者模式：产生的一个产品是一堆子组件组合的复杂的对象，比如一个强壮的机器人由主体，胳膊，腿构成

2.联系

通常构造者模式会和工厂模式或者单例模式一起组合使用。在构造器内部提供简单类的对象。

我是用简单的产品机器人作为例子练习的，两个大部分，机器人的构建和机器人的组装。

二、UML类图

三、源码

1.产品类Robot，由Body、Leg、Arm组成。

package builder;

/**
 * 建造者模式：分离了对象子组件的单独构造（由builder来负责）和装配（由Director负责）。
 * 从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用；
 * 实现创建和装配解耦，不同的构建器，相同的装配，也可以做出不同的对象；
 * 相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
 */
public class Robot {
    private Body body;
    private  Leg leg;
    private Arm arm;

    public Body getBody() {
        return body;
    }

    public void setBody(Body body) {
        this.body = body;
    }

    public Leg getLeg() {
        return leg;
    }

    public void setLeg(Leg leg) {
        this.leg = leg;
    }

    public Arm getArm() {
        return arm;
    }

    public void setArm(Arm arm) {
        this.arm = arm;
    }
}

class Arm{
    private String name;
    public Arm(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Leg{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Leg(String name) {
        this.name = name;
    }
}
class Body{
    public Body(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name;
}

2.构建者：

package builder;

public interface RobotBuilder {
    Body builderBody();
    Leg builderLeg();
    Arm builderArm();
}

package builder;

public class StrongRobotBuilder implements RobotBuilder {
    private Robot robot;
    public Body builderBody() {
        System.out.println("构造身体");
        return new Body("强壮的身体");
    }

    public Leg builderLeg() {
        System.out.println("构造腿");

        return new Leg("强壮的腿");
    }

    public Arm builderArm() {
        System.out.println("构造胳膊");

        return new Arm("强壮的胳膊");
    }
}

构建者只提供子组件构建，这里可以使用单例模式或者工厂模式结合起来使用

3.组件者

package builder;

public interface RobotDirector {
    Robot directRobot();
}

package builder;

public class StrongRobotDirector implements RobotDirector {
    private RobotBuilder builder;

    public StrongRobotDirector(RobotBuilder builder) {
        this.builder = builder;
    }

    public Robot directRobot() {
        Robot robot = new Robot();
        robot.setBody(builder.builderBody());
        robot.setArm(builder.builderArm());
        robot.setLeg(builder.builderLeg());
        return robot;
    }
}

组装者调用构建者得到子组件和组装成复杂对象robot

4.客户端

package builder;

public class Client {
    public static void main(String[] args) {
        RobotBuilder builder = new StrongRobotBuilder();
        RobotDirector director = new StrongRobotDirector(builder);
        Robot robot = director.directRobot();
        System.out.println(robot.getBody().getName());
    }
}

四：总结

构建者模式用来解决构造复杂对象，比如对象包含Vo，Do，配置文件的读取。实现了子组件和this对象的解耦。 builder，director都具有单一职责，对代码的扩展放开。当需要新增一个同族类似产品时只需要新建Builder类和对应的产品类。

猜你喜欢