建造者模式:使用多个简单的对象一步一步构建成一个复杂的对象。
建造者模式UML类图如下:
从UML类图可以看出,建造者模式包含4个元素:
抽象建造者(Builder):一个抽象接口,规范了产品对象的各个组成成分的建造。
具体建造者(ConcreteBuilder):与应用程序紧密相关的一些类,它们在应用程序调用下创建产品的实例。
导演者(Director):调用具体建造者角色来创建产品对象。
产品(Product):一般是一个较为复杂的对象。
具体代码:
1.抽象建造者类
package com.szcatic.builder;
public interface Builder {
public void buildWheel();
public void buildSkeleton();
public void buildEngine();
Product buildProduct();
}
2.具体建造者类
package com.szcatic.builder;
public class ConcreteBuilder implements Builder {
private Product product;
public ConcreteBuilder() {
this.product = new Product();
}
@Override
public void buildWheel() {
product.setWheel("轮子");
}
@Override
public void buildSkeleton() {
product.setSkeleton("架构");
}
@Override
public void buildEngine() {
product.setEngine("发动机");
}
@Override
public Product buildProduct() {
return product;
}
}
3.导演者类
package com.szcatic.builder;
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Builder getBuilder() {
return builder;
}
public void setBuilder(Builder builder) {
this.builder = builder;
}
public Product buildProduct() {
builder.buildEngine();
builder.buildSkeleton();
builder.buildWheel();
return builder.buildProduct();
}
}
4.产品类
package com.szcatic.builder;
public class Product {
private String wheel;
private String skeleton;
private String engine;
public String getWheel() {
return wheel;
}
public void setWheel(String wheel) {
this.wheel = wheel;
}
public String getSkeleton() {
return skeleton;
}
public void setSkeleton(String skeleton) {
this.skeleton = skeleton;
}
public String getEngine() {
return engine;
}
public void setEngine(String engine) {
this.engine = engine;
}
@Override
public String toString() {
return "Product [wheel=" + wheel + ", skeleton=" + skeleton + ", engine=" + engine + "]";
}
}
5.测试类
package com.szcatic.builder.test;
import org.junit.jupiter.api.Test;
import com.szcatic.builder.ConcreteBuilder;
import com.szcatic.builder.Director;
public class BuilderTest {
@Test
void testBuildProduct() {
System.out.println(new Director(new ConcreteBuilder()).buildProduct());
}
}
运行结果:
Product [wheel=轮子, skeleton=架构, engine=发动机]
总结
优点:
1、建造者独立,易扩展。
2、便于控制细节风险。
缺点:
1、产品必须有共同点,范围有限制。
2、如内部变化复杂,会有很多的建造类。
构造器模式的另一种应用场景
package com.hegret.builder;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private String id;
private String name;
private String password;
private String eamil;
private String phone;
public String getId() {
return id;
}
public String getName() {
return name;
}
public String getPassword() {
return password;
}
public String getEamil() {
return eamil;
}
public String getPhone() {
return phone;
}
private User(Builder builder) {
this.id = builder.id;
this.name = builder.name;
this.password = builder.password;
this.eamil = builder.eamil;
this.phone = builder.phone;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", password=" + password + ", eamil=" + eamil + ", phone=" + phone
+ "]";
}
public static class Builder {
private String id;
private String name;
private String password;
private String eamil;
private String phone;
public Builder id(String id) {
this.id = id;
return this;
}
public Builder name(String name) {
this.name = name;
return this;
}
public Builder password(String password) {
this.password = password;
return this;
}
public Builder eamil(String eamil) {
this.eamil = eamil;
return this;
}
public Builder phone(String phone) {
this.phone = phone;
return this;
}
public User build() {
return new User(this);
}
}
}