【设计模式】快速理解建造者模式，及其在JDK源码中的应用

2022-04-28 272

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 建造者（Builder）模式在百度百科上的定义：是一种将复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。这段话在理解上十分抽象，简单来讲就是如果一个对象很复杂，使用建造者模式允许用户通过简单的方式构建这个对象，而不用关心对象具体构建的细节。且可以使用同样的构建过程可以创建出不同的对象。接下来将会通过具体的代码实例去讲解建造者模式。

（一）什么是建造者模式

建造者（Builder）模式在百度百科上的定义：是一种将复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。

这段话在理解上十分抽象，简单来讲就是如果一个对象很复杂，使用建造者模式允许用户通过简单的方式构建这个对象，而不用关心对象具体构建的细节。且可以使用同样的构建过程可以创建出不同的对象。

接下来将会通过具体的代码实例去讲解建造者模式。

（二）建造者模式中的几个角色

建造者模式中定义了四个主要角色，现在看定义可以不太容易理解，等结合之后的代码就容易理解了。

抽象建造者Builder

建造者的抽象类或者接口，主要用来定义具体建造者需要实现的一些方法。

具体建造者 ConcreteBuilder

具体的建造者，是抽象建造者的实现类。

具体的对象Client

最终想要生成的对象。

引导者Director

实例的生成需要依赖Director角色，Director生成实例不依赖ConcreteBuilder，它只通过调用Builder角色中定义的方法。

（三）建造者模式的实践

光看上面的概念比较难理解建造者模式，接下来通过一个造车的例子讲解建造者模式。

为了简化逻辑，这里将一辆车定义为由轮子、能源和颜色组成。首先定义出具体要生成的对象，也就是角色中的Client角色：

publicclassCar {
// 轮子privateStringwheel;
// 能源privateStringenergy;
// 颜色privateStringcolor;
publicCar(){}
publicvoidsetColor(Stringcolor) {
this.color=color;
    }
publicvoidsetEnergy(Stringenergy) {
this.energy=energy;
    }
publicvoidsetWheel(Stringwheel) {
this.wheel=wheel;
    }
@OverridepublicStringtoString() {
return"Car{"+"wheel='"+wheel+'\''+", energy='"+energy+'\''+", color='"+color+'\''+'}';
    }
}

造车的逻辑可以抽象为造轮子，造能源，喷颜色，最后生成一辆车，因此可以将Builder角色构建出来

publicabstractclassBuilder {
publicabstractvoidbuildWheel();
publicabstractvoidbuildEnergy();
publicabstractvoidbuildColor();
publicabstractCargetCar();
}

具体每种车都有每种车的造法，因此分别构建两种车型的构建实体类，也就是角色中的ConcreteBuilder

publicclassBMWCarBuilderextendsBuilder {
privateCarcar;
publicBMWCarBuilder(){
car=newCar();
    }
@OverridepublicvoidbuildWheel() {
car.setWheel("四个轮子");
    }
@OverridepublicvoidbuildEnergy() {
car.setEnergy("油箱");
    }
@OverridepublicvoidbuildColor() {
car.setColor("黑色");
    }
@OverridepublicCargetCar() {
returncar;
    }
}

另一种具体建造者：

publicclassTeslaCarBuilderextendsBuilder {
privateCarcar;
publicTeslaCarBuilder(){
car=newCar();
    }
@OverridepublicvoidbuildWheel() {
car.setWheel("四个轮子");
    }
@OverridepublicvoidbuildEnergy() {
car.setEnergy("电池");
    }
@OverridepublicvoidbuildColor() {
car.setColor("白色");
    }
@OverridepublicCargetCar() {
returncar;
    }
}

最后需要有一个引导者Director角色，通过引导者调用Builder中定义的方法。

publicclassDirector {
privateBuilderbuilder;
publicDirector(Builderbuilder){
this.builder=builder;
    }
publicvoidbuildCar(){
builder.buildWheel();
builder.buildColor();
builder.buildEnergy();
    }
}

使用方式如下：首先创建了TeslaCarBuilder实例对象，交给引导者，引导者角色调用buildCar方法后TeslaCarBuilder就可以通过调用getCar获取对应的Car了。BMWCarBuilder也是同样的方式。

publicclassMain {
publicstaticvoidmain(String[] args) {
TeslaCarBuilderteslaCarBuilder=newTeslaCarBuilder();
Directordirector=newDirector(teslaCarBuilder);
director.buildCar();
CarteslaCar=teslaCarBuilder.getCar();
System.out.println(teslaCar.toString());
BMWCarBuilderbmwCarBuilder=newBMWCarBuilder();
director=newDirector(bmwCarBuilder);
director.buildCar();
CarbmwCar=bmwCarBuilder.getCar();
System.out.println(bmwCar.toString());
    }
}

还记得最开始对建造者模式的定义吗？使用建造者模式允许用户通过简单的方式构建这个对象，而不用关心对象具体构建的细节。且可以使用同样的构建过程可以创建出不同的对象。

在真正创建对象的过程中，已经不需要关注Car是如何build的，因此具体构建的细节都由各自的ConcreteBuilder去实现。并且同样的构建过程只要传入的ConcreteBuilder不同就可以创建不同的对象。

（四）建造者模式的变通

如果将具体建造者ConcreteBuilder、引导者Director、对象Client三种角色合为一种，那么建造者模式就会变得更加精简：首先还是要定义抽象方法Builder

publicabstractclassBuilder {
publicabstractBuilderbuildWheel(Stringwheel);
publicabstractBuilderbuildEnergy(Stringenergy);
publicabstractBuilderbuildColor(Stringcolor);
publicabstractCargetCar();
}

使用时就更加方便了：

publicclassMain {
publicstaticvoidmain(String[] args) {
Carcar=newCar.CarBuilder()
                .buildColor("白色")
                .buildEnergy("新能源")
                .buildWheel("四个轮子")
                .getCar();
System.out.println(car.toString());
    }
}

（五）建造者模式在源码中的应用

StringBuilder就是建造者模式精简后的用法，StringBuilder继承了Appendable接口：

publicinterfaceAppendable {
Appendableappend(CharSequencecsq) throwsIOException;
Appendableappend(CharSequencecsq, intstart, intend) throwsIOException;
Appendableappend(charc) throwsIOException;
}

其具体的append方法和我们在第四章讲解的十分相似：

publicfinalclassStringBuilderextendsAbstractStringBuilderimplementsjava.io.Serializable, CharSequence{
@OverridepublicStringBuilderappend(Stringstr) {
super.append(str);
returnthis;
    }
}

在使用时，也是通过一路append实现链式编程。

stringBuilder.append("hello").append("world");

（六）总结

最传统的建造者模式体现着设计模式中“可替换性”的思想，Director不知道自己使用的具体是哪个Builder的实现类，所以Builder的实现类具备可替换性，也就可以理解为是一个个的组件。写代码时使用设计模式并不会让代码简单或者好写，反而会更复杂，但是在维护或者迭代时，就会省下很多精力。