设计模式-建造者模式及应用

在系统开发中，往往会有创建一个复杂对象的需求。这个复杂对象由多个子部件组合而成。例如我们现在需要组装一台计算机，计算机由CPU、主板、硬盘、内存、显示器、鼠标、键盘…等组装而成，而选择需要根据我们真实的使用场景去组装不同配置的电脑。例如同一个公司的同事，不同岗位对计算机配置的需求也不同，研发同学的配置可能会高，而文职类工作的同学配置就无须那么高。

公司IT运维部门的同学就需要按照不同需要组装不同配置的电脑。各个组件灵活替换，按需装配。类似于这种场景产品的创建，下面介绍的建造者模式，就能很好的描述此类场景。

建造者模式

建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。此外建造者模式是一种对象创建型模式。

结构与实现

建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。

• 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
• 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
• 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
• 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

结构图如下：

实例代码：
使用本文开始时候介绍的组装电脑的案例，来完成建造者模式的案例；

• 产品角色

public class Computer {
	
	private String cpu;
	
	private String disk;
	
	private String ram;

	private String screen;
	
	private String mouse;
	
	private String keyboard;

	public String getCpu() {
		return cpu;
	}

	public void setCpu(String cpu) {
		this.cpu = cpu;
	}

	public String getDisk() {
		return disk;
	}

	public void setDisk(String disk) {
		this.disk = disk;
	}

	public String getRam() {
		return ram;
	}

	public void setRam(String ram) {
		this.ram = ram;
	}

	public String getScreen() {
		return screen;
	}

	public void setScreen(String screen) {
		this.screen = screen;
	}

	public String getMouse() {
		return mouse;
	}

	public void setMouse(String mouse) {
		this.mouse = mouse;
	}

	public String getKeyboard() {
		return keyboard;
	}

	public void setKeyboard(String keyboard) {
		this.keyboard = keyboard;
	}

	@Override
	public String toString() {
		return "Computer [cpu=" + cpu + ", disk=" + disk + ", ram=" + ram + ", screen=" + screen + ", mouse=" + mouse
				+ ", keyboard=" + keyboard + "]";
	}
}

• 抽象建造者

public abstract class AbstractBuilder {
	
	/**
	 * 具体产品
	 */
   protected Computer computer = new Computer();
	
	/**
	 * 配置cpu
	 */
	protected abstract void setCpu();
	
	/**
	 * 配置disk
	 */
	protected abstract void setDisk();
	
	/**
	 * 配置 ram
	 */
	protected abstract void setRam();
	
	/**
	 * 配置screen
	 */
	protected abstract void setScreen();
	

	/**
	 * 配置keyboard
	 */
	protected abstract void setKeyboard();
	

	/**
	 * 配置mouse
	 */
	protected abstract void setMouse();
	
	
	/**
	 * 返回创建具体对象
	 * @return
	 */
	public Computer getResult() {
		return computer;
	}
}

• 具体建造者1

public class ConcreteBuilderApple extends AbstractBuilder{

	@Override
	protected void setCpu() {
		computer.setCpu("M1");
	}

	@Override
	protected void setDisk() {
		computer.setDisk("Seagate 2TB");
	}

	@Override
	protected void setRam() {
		computer.setRam("Kingston 16G");
	}

	@Override
	protected void setScreen() {
		computer.setScreen("Sasung");
	}

	@Override
	protected void setKeyboard() {
		computer.setKeyboard("apple keyboard");
	}

	@Override
	protected void setMouse() {
		computer.setMouse("apple mouse");
	}
}

• 具体建造者2

public class ConcreteBuilderHuawei extends AbstractBuilder{

	protected void setCpu() {
		computer.setCpu("Intel");
	}

	protected void setDisk() {
		computer.setDisk("Sasung 1TB");
	}

	protected void setRam() {
		computer.setRam("AMD 8G");		
	}

	
	protected void setScreen() {	
		computer.setScreen("Sony");
	}

	
	protected void setKeyboard() {
		computer.setKeyboard("Huawei");		
	}
	
	protected void setMouse() {
		computer.setKeyboard("Logitech");		
	}
}

• 指挥者

public class ComputerDirector {
	
	AbstractBuilder builder = null;
	
	public ComputerDirector(AbstractBuilder builder){
		this.builder = builder;
	}
	
    // 创建实例
	public Computer builderComputer() {
		builder.setCpu();
		builder.setDisk();
		builder.setRam();
		builder.setRam();
		builder.setMouse();
		builder.setKeyboard();
		builder.setScreen();
		return builder.getResult();	
	}
}

• 使用方

public class Client {

	public static void main(String[] args) {
		ConcreteBuilderApple concreteBuilderApple =  new ConcreteBuilderApple();
		// 假设生产苹果电脑
		ComputerDirector computerDirector = new ComputerDirector(concreteBuilderApple);
	    Computer macBookPro =computerDirector.builderComputer();
      System.out.println(macBookPro.toString());
	}
}

执行结果：

Computer [cpu=M1, disk=Seagate 2TB, ram=Kingston 16G, screen=Sasung, mouse=apple mouse, keyboard=apple keyboard]

案例结构图：

使用场景

当需要创建的产品具备复杂创建过程时，可以抽取出共性创建过程，然后交由具体实现类自定义创建流程，使得同样的创建行为可以生产出不同的产品，分离了创建与表示，使创建产品的灵活性大大增加。

建造者模式主要适用于以下应用场景：

• 相同的方法，不同的执行顺序，产生不同的结果。
• 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
• 产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。
• 初始化一个对象特别复杂，参数多，而且很多参数都具有默认值。

项目中经常使用的，静态类的方式实现建造者

还以我们上面的案例来演示，需要变动产品类;

public class Computer2 {
	
	private String cpu;
	
	private String disk;
	
	private String ram;

	private String screen;
	
	private String mouse;
	
	private String keyboard;

	public String getCpu() {
		return cpu;
	}

	public void setCpu(String cpu) {
		this.cpu = cpu;
	}

	public String getDisk() {
		return disk;
	}

	public void setDisk(String disk) {
		this.disk = disk;
	}

	public String getRam() {
		return ram;
	}

	public void setRam(String ram) {
		this.ram = ram;
	}

	public String getScreen() {
		return screen;
	}

	public void setScreen(String screen) {
		this.screen = screen;
	}

	public String getMouse() {
		return mouse;
	}

	public void setMouse(String mouse) {
		this.mouse = mouse;
	}

	public String getKeyboard() {
		return keyboard;
	}

	public void setKeyboard(String keyboard) {
		this.keyboard = keyboard;
	}

	@Override
	public String toString() {
		return "Computer [cpu=" + cpu + ", disk=" + disk + ", ram=" + ram + ", screen=" + screen + ", mouse=" + mouse
				+ ", keyboard=" + keyboard + "]";
	}
	
	public static class Builder{
		Computer2 product = new Computer2();
		
		public Builder setCpu(String cpu) {
			product.cpu = cpu;
			return this;
		}
		
		public Builder setRam(String ram) {
			product.ram = ram;
			return this;
		}
		
		public Builder setDisk(String disk) {
			product.disk = disk;
			return this;
		}
		
		
		public Builder setScreen(String screen) {
			product.screen = screen;
			return this;
		}
		
		public Builder setMouse(String mouse) {
			product.mouse = mouse;
			return this;
		}
		
		public Builder setKeyboard(String keyboard) {
			product.keyboard = keyboard;
			return this;
		}
		
		
	     public Computer2 getResult() {
		     return product;
	     }
	}
}

• 使用方：

public class Client2 {
	
	public static void main(String[] args) {	
	  Computer2 computer2 =	new Builder().setCpu("Intel").setDisk("wd").setRam("AMD").setScreen("索尼").getResult();
	  System.out.println(computer2);
	}
}

执行结果

Computer [cpu=Intel, disk=wd, ram=AMD, screen=索尼, mouse=null, keyboard=null]

通过静态内部类（指挥者、建造者）构造具体产品的方式，简化建造者模式的使用。使得代码更简介，缺点是违反开闭原则，产品属性更改，内部类也要更改。

优缺点

优点：

• 封装性好，讲复杂对象的构建过程与表示分开
• 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
• 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点：

• 产品的组成部分必须相同，这限制了其使用范围。
• 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

建造者模式在源码中的使用

1.建造者模式在MyBatis源码中的应用
MyBatis 中 SqlSessionFactoryBuiler 类用到了建造者模式，SqlSessionFactory由具体SqlSessionFactoryBuilder产生；下面分析一下源码部分

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

这里DefaultSqlSessionFactory创建需要Configuration对象，这里SqlSessionFactoryBuilder 充当了我们的指挥者；

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();

            try {
                inputStream.close();
            } catch (IOException var13) {
            }
        }
        return var5;
    }

Configuration对象是一个复杂对象，具体的创建Configuration的建造者为XMLConfigBuilder，抽象建造者为BaseBuilder，具体建造者的构建过程,通过parseConfiguration（）方法，构造配置项，parse（）方法获取我们构造的 Configuration对象。

// 构造过程
    private void parseConfiguration(XNode root) {
        try {
            Properties settings = this.settingsAsPropertiess(root.evalNode("settings"));
            this.propertiesElement(root.evalNode("properties"));
            this.loadCustomVfs(settings);
            this.typeAliasesElement(root.evalNode("typeAliases"));
            this.pluginElement(root.evalNode("plugins"));
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectionFactoryElement(root.evalNode("reflectionFactory"));
            this.settingsElement(settings);
            this.environmentsElement(root.evalNode("environments"));
            this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            this.typeHandlerElement(root.evalNode("typeHandlers"));
            this.mapperElement(root.evalNode("mappers"));
        } catch (Exception var3) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
        }
    }

// 获取结果
public Configuration parse() {
        if (this.parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        } else {
            this.parsed = true;
            this.parseConfiguration(this.parser.evalNode("/configuration"));
            return this.configuration;
        }
    }    

✨✨ 欢迎🔔订阅个人的微信公众号 享及时博文更新