Java设计模式—— 建造者模式（Builder Pattern）

建造者模式：使用多个简单的对象一步一步构建成一个复杂的对象。

建造者模式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);
		}

	}

}