Java设计模式之建造者模式

落日映苍穹つ 2021-10-09 04:36 336阅读 0赞

之前写了几篇设计模式，感觉都太死板了，今天写这篇换个思路，先来讲一讲例子，然后再来说说定义。

建造者模式（Builder Pattern）当然就是造东西啦，那我们就来举一个造汽车的例子吧。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VrdW4xMzE0_size_16_color_FFFFFF_t_70][]

产品类：

先制造汽车外壳、发动机、轮胎、方向盘等汽车部件，然后对这些部件进行组装。现在要制造两种汽车—奔驰车和宝马车，显然奔驰车和宝马车的汽车部件都是不一样的，组装方式也是不一样的，所以我们需要具体的产品类。

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.

将一个复杂对象的构建与它的表示分离， 使得同样的构建过程可以创建不同的表示。

类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VrdW4xMzE0_size_16_color_FFFFFF_t_70 1][]

角色：

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();
        }
    }

参考：

设计模式之禅

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VrdW4xMzE0_size_16_color_FFFFFF_t_70]: /images/20211009/fc6d8fce12d24a4e99da2f7dfeb711e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3VrdW4xMzE0_size_16_color_FFFFFF_t_70 1]: /images/20211009/993dff49d8eb46b1bc7680d4a5717ccf.png