之前写了几篇设计模式,感觉都太死板了,今天写这篇换个思路,先来讲一讲例子,然后再来说说定义。
建造者模式(Builder Pattern)当然就是造东西啦,那我们就来举一个造汽车的例子吧。
产品类:
先制造汽车外壳、发动机、轮胎、方向盘等汽车部件,然后对这些部件进行组装。现在要制造两种汽车—奔驰车和宝马车,显然奔驰车和宝马车的汽车部件都是不一样的,组装方式也是不一样的,所以我们需要具体的产品类。
public abstract class CarModel {
//制造发动机
protected abstract void buildEngine();
//制造外壳
protected abstract void buildShell();
//制造轮胎
protected abstract void buildTyre();
//方向盘
protected abstract void buildSteeringwheel();
//组装汽车
protected abstract void assemble();
final public void product(){
this.buildEngine();
this.buildShell();
this.buildTyre();
this.buildSteeringwheel();
this.assemble();
}
}
奔驰车产品类:
package com.clarezhou.builderpattern;
public class BenzModel extends CarModel{
@Override
protected void buildEngine() {
System.out.println("制造奔驰发动机");
}
@Override
protected void buildShell() {
System.out.println("制造奔驰外壳");
}
@Override
protected void buildTyre() {
System.out.println("制造奔驰轮胎");
}
@Override
protected void buildSteeringwheel() {
System.out.println("制造奔驰方向盘");
}
@Override
protected void assemble() {
System.out.println("组装奔驰汽车");
}
}
宝马车产品类:
package com.clarezhou.builderpattern;
public class BmwModel extends CarModel{
@Override
protected void buildEngine() {
System.out.println("制造宝马发动机");
}
@Override
protected void buildShell() {
System.out.println("制造宝马外壳");
}
@Override
protected void buildTyre() {
System.out.println("制造宝马轮胎");
}
@Override
protected void buildSteeringwheel() {
System.out.println("制造宝马方向盘");
}
@Override
protected void assemble() {
System.out.println("组装宝马车");
}
}
抽象建造者:
package com.clarezhou.builderpattern;
public abstract class CarBuilder {
/** 获取汽车 **/
public abstract CarModel getCarModel();
}
具体建造者 :
package com.clarezhou.builderpattern;
public class BenzBuilder extends CarBuilder{
private BenzModel benz = new BenzModel();
@Override
public CarModel getCarModel() {
return this.benz;
}
}
package com.clarezhou.builderpattern;
public class BmwBuilder extends CarBuilder{
private BmwModel bmw = new BmwModel();
@Override
public CarModel getCarModel() {
return this.bmw;
}
}
指挥者:
起到封装的作用, 避免高层模块深入到建造者内部的实现类。
package com.clarezhou.builderpattern;
public class Director {
private BenzBuilder benzBuilder= new BenzBuilder();
private BmwBuilder bmwBuilder = new BmwBuilder();
/**
* 制造奔驰汽车
* @return
*/
public BenzModel getBenzModel(){
return (BenzModel) this.benzBuilder.getCarModel();
}
/**
* 制造宝马汽车
* @return
*/
public BmwModel getBmwModel(){
return (BmwModel) this.bmwBuilder.getCarModel();
}
}
客户端:
package com.clarezhou.builderpattern;
public class Client {
public static void main(String[] args) {
Director director = new Director();
//制造一万台奔驰车
for (int i = 0; i < 10000; i++) {
director.getBenzModel().product();
}
//制造一万台宝马车
for (int i = 0; i < 10000; i++) {
director.getBmwModel().product();
}
}
}
这个例子举的比较简单,其实完全可以只使用模板方法模式就可以完成的,只是为了介绍这个建造者模式,多加了建造者的部分,大家可以想象一些更复杂的例子。
看完例子 我们再来看看建造者的定义:
建造者模式(Builder Pattern),又称生成器模式,使用多个简单的对象一步一步构建成一个复杂的对象,用户不需要知道内部的具体构建细节。
建造者模式属于创建型模式。(创建型模式:单例模式、工厂(方法)模式、抽象工厂模式、建造者模式、原型模式)。
定义:
Separate the construction of a complex object from its representation so that the same
construction process can create different representations.
将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示。
类图:
角色:
Product(产品类): 一个具体的产品对象(通常实现了模板方法模式)。
Builder(抽象建造者): 创建一个Product对象的各个部件指定的抽象接口。
ConcreteBuilder(具体建造者): 实现抽象接口,构建和装配各个部件。
Director(指挥者): 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用,一是:隔离了客户与对象的生产过程,二是:负责控制产品对象的生产过程。
通用源码(来自设计模式之禅):
产品类:
public class Product {
public void doSomething(){
//独立业务处理
}
}
抽象建造者:
public abstract class Builder {
//设置产品的不同部分, 以获得不同的产品
public abstract void setPart();
//建造产品
public abstract Product buildProduct();
}
具体建造者:
public class ConcreteProduct extends Builder {
private Product product = new Product();
//设置产品零件
public void setPart(){
/*
* 产品类内的逻辑处理
*/
}
//组建一个产品
public Product buildProduct() {
return product;
}
}
指挥者类:
public class Director {
private Builder builder = new ConcreteProduct();
//构建不同的产品
public Product getAProduct(){
builder.setPart();
/*
* 设置不同的零件, 产生不同的产品
*/
return builder.buildProduct();
}
}
参考:
设计模式之禅