“这是我参与8月更文挑战的第25天,活动详情查看:8月更文挑战”
1、建造者模式概述
建造者(Builder)模式的定义:指将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示,这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象,然后一步一步构建而成。它将变与不变相分离,即产品的组成部分是不变的,但每一部分是可以灵活选择的。
该模式的主要优缺点如下:
- 封装性好,构建和表示分离。
- 扩展性好,各个具体的建造者相互独立,有利于系统的解耦。
- 客户端不必知道产品内部组成的细节,建造者可以对创建过程逐步细化,而不对其它模块产生任何影响,便于控制细节风险。
其缺点如下:
- 产品的组成部分必须相同,这限制了其使用范围。
- 如果产品的内部变化复杂,如果产品内部发生变化,则建造者也要同步修改,后期维护成本较大。
建造者(Builder)模式和工厂模式的关注点不同:建造者模式注重零部件的组装过程,而工厂方法模式更注重零部件的创建过程,但两者可以结合使用。
应用场景:
- 相同的方法,不同的执行顺序,产生不同的结果。
- 多个部件或零件,都可以装配到一个对象中,但是产生的结果又不相同。
- 产品类非常复杂,或者产品类中不同的调用顺序产生不同的作用。
- 初始化一个对象特别复杂,参数多,而且很多参数都具有默认值。
2、建造者模式的结构
建造者(Builder)模式的主要角色如下。
- 产品角色(Product):它是包含多个组成部件的复杂对象,由具体建造者来创建其各个零部件。
- 抽象建造者(Builder):它是一个包含创建产品各个子部件的抽象方法的接口/抽象类,通常还包含一个返回复杂产品的方法 getResult()。
- 具体建造者(Concrete Builder):实现 Builder 接口,完成复杂产品的各个部件的具体创建方法。
- 指挥者(Director):它调用建造者对象中的部件构造与装配方法完成复杂对象的创建,在指挥者中不涉及具体产品的信息。
建造者模式的结构图:
3、建造者模式的实现
3.1、常规实现
具体的产品类,包含多个组成部件
public class Product {
//有ABCD多个部件
private String buildA;
private String buildB;
private String buildC;
private String buildD;
public String getBuildA() {
return buildA;
}
public void setBuildA(String buildA) {
this.buildA = buildA;
}
public String getBuildB() {
return buildB;
}
public void setBuildB(String buildB) {
this.buildB = buildB;
}
public String getBuildC() {
return buildC;
}
public void setBuildC(String buildC) {
this.buildC = buildC;
}
public String getBuildD() {
return buildD;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return "Product{" +
"buildA='" + buildA + '\'' +
", buildB='" + buildB + '\'' +
", buildC='" + buildC + '\'' +
", buildD='" + buildD + '\'' +
'}';
}
}
抽象建造者,包含创建产品各个子部件的抽象方法
//抽象的建造者
public abstract class Builder {
//具体产品的各个子部件的抽象方法
abstract void buildA();//部件A
abstract void buildB();//部件B
abstract void buildC();//部件C
abstract void buildD();//部件B
//返回具体产品的方法
abstract Product getProduct();
}
具体建造者1,实现 Builder 接口,完成复杂产品的各个部件的具体创建方法。
//具体建造者,实现抽象建造者,完成复杂产品的各个部件的具体创建方法
public class Worker extends Builder{
private Product product; //提升作用域
//通过具体建造者的构造器生成具体产品的对象
public Worker(){
product = new Product();
}
@Override
void buildA() {
product.setBuildA("完成部件A");
System.out.println("完成部件A");
}
@Override
void buildB() {
product.setBuildB("完成部件B");
System.out.println("完成部件B");
}
@Override
void buildC() {
product.setBuildC("完成部件C");
System.out.println("完成部件C");
}
@Override
void buildD() {
product.setBuildD("完成部件D");
System.out.println("完成部件D");
}
@Override
Product getProduct() {
System.out.println("完成产品ABCD的创建");
return product;
}
}
具体建造者2,实现 Builder 接口,完成复杂产品的各个部件的具体创建方法。
public class WorkerTwo extends Builder{
private Product product;
public WorkerTwo(){
product = new Product();
}
@Override
void buildA() {
product.setBuildA("完成部件A2");
System.out.println("完成部件A2");
}
@Override
void buildB() {
product.setBuildB("完成部件B2");
System.out.println("完成部件B2");
}
@Override
void buildC() {
product.setBuildC("完成部件C2");
System.out.println("完成部件C2");
}
@Override
void buildD() {
product.setBuildD("完成部件D2");
System.out.println("完成部件D2");
}
@Override
Product getProduct() {
System.out.println("完成产品ABCDTWO的创建");
return product;
}
}
指挥者,调用建造者对象中的部件构造与装配方法完成复杂对象的创建
public class Director {
//调用建造者对象中的部件构造与装配方法完成复杂对象的创建
public Product construct(Builder builder){
builder.buildA();
builder.buildB();
builder.buildC();
builder.buildD();
return builder.getProduct();
}
}
客户类,实现具体建造者1
public class Client {
public static void main(String[] args) {
Director director = new Director();
Product build = director.construct(new Worker());//实现具体建造者1
System.out.println(build.toString());
}
}
测试:
客户类,实现具体建造者2
public class Client {
public static void main(String[] args) {
Director director = new Director();
Product build = director.construct(new WorkerTwo());
System.out.println(build.toString());
}
}
测试:
上面示例是 Builder模式的常规用法,指挥者类 Director 在 Builder模式中具有很重要的作用,它用于指导具体构建者如何构建产品,控制调用先后次序,并向调用者返回完整的产品类,但是有些情况下需要简化系统结构,可以把Director和抽象建造者进行结合。
3.2、更为灵活的实现
产品-->套餐
public class Product {
//默认套餐
private String BuildA = "汉堡";
private String BuildB = "薯条";
private String BuildC = "炸鸡";
private String BuildD = "可乐";
public String getBuildA() {
return BuildA;
}
public void setBuildA(String buildA) {
BuildA = buildA;
}
public String getBuildB() {
return BuildB;
}
public void setBuildB(String buildB) {
BuildB = buildB;
}
public String getBuildC() {
return BuildC;
}
public void setBuildC(String buildC) {
BuildC = buildC;
}
public String getBuildD() {
return BuildD;
}
public void setBuildD(String buildD) {
BuildD = buildD;
}
@Override
public String toString() {
return "Product{" +
"BuildA='" + BuildA + '\'' +
", BuildB='" + BuildB + '\'' +
", BuildC='" + BuildC + '\'' +
", BuildD='" + BuildD + '\'' +
'}';
}
}
抽象建造类
public abstract class Builder {
abstract Builder buildA(String msg);//汉堡
abstract Builder buildB(String msg);//薯条
abstract Builder buildC(String msg);//炸鸡
abstract Builder buildD(String msg);//可乐
//返回具体的套餐
abstract Product getProduct();
}
具体建造者-->服务员
public class Worker extends Builder{
private Product product;
public Worker() {
product = new Product();
}
@Override
Builder buildA(String msg) {
product.setBuildA(msg);
return this;
}
@Override
Builder buildB(String msg) {
product.setBuildB(msg);
return this;
}
@Override
Builder buildC(String msg) {
product.setBuildC(msg);
return this;
}
@Override
Builder buildD(String msg) {
product.setBuildD(msg);
return this;
}
@Override
Product getProduct() {
return product;
}
}
客户:实现默认套餐
public class Client {
public static void main(String[] args) {
Worker worker = new Worker();
Product product = worker.getProduct();
System.out.println(product.toString());
}
}
测试:
实现自选套餐:
public class Client {
public static void main(String[] args) {
Worker worker = new Worker();
Product product = worker
.buildA("蛋糕")
.buildB("鸡腿")
.buildC("")
.buildD("")
.getProduct();
System.out.println(product.toString());
}
}
测试:
4、建造者模式和工厂模式的区别
- 建造者模式更加注重方法的调用顺序,工厂模式注重创建对象。
- 创建对象的力度不同,建造者模式创建复杂的对象,由各种复杂的部件组成,工厂模式创建出来的对象都一样
- 关注重点不一样,工厂模式只需要把对象创建出来就可以了,而建造者模式不仅要创建出对象,还要知道对象由哪些部件组成。
- 建造者模式根据建造过程中的顺序不一样,最终对象部件组成也不一样。