Android架构进阶（六）—— 建造者模式

建造者模式

定义

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

简介

• 建造者模式使用的目的是构造复杂对象，如果对象内部不是很复杂或者功能不是很多，是没有必要使用建造者模式的
• 使用者可以不用关心建造的过程和细节，只要使用对外提供的公共方法来构造对象即可。
• 关于建造者模式的使用，基本有两类方式，一种是传统的外部Builder类的方式，一般是使用静态内部类Builder的方式去构造对象。

传统Builder模式

1. 成员

• 1.产品类；
• 2.抽象的Builder类；
• 3.Builder实现类；
• 4.使用者；

2. 实例

我们使用建造者模式的目的，是创建复杂对象，那么首先，我们就需要这个复杂的对象，即产品类

public class Product{
	private int param1;
	private int param2;
	private int param3;
	private int param4;
	private int param5;
	private int param6;
	/**
	/* getter and setter
	**/
	...
	 @Override
    public String toString() {
		return ""+param1+param2+param3+param4+param5+param6;
	}
}

接下来是此模式的核心——抽象Builder类（接口）

public interface Builder{
	void setParam1();
	void setParam2();
	void setParam3();
	void setParam4();
	void setParam5();
	void setParam6();
	Product getProduct();
}

接下来就需要我们的实现类

public class BuilderImpl implements Builder{
	private Product product;
	public BuilderImpl(){
		this.product = new Product();
	}

	@Override
	public void setParam1(){
		product.setParam1(1);
	}

	@Override
	public void setParam2(){
		product.setParam2(2);
	}
	
	@Override
	public void setParam3(){
		product.setParam3(3);
	}
	
	@Override
	public void setParam4(){
		product.setParam4(4);
	}
	
	@Override
	public void setParam5(){
		product.setParam5(5);
	}

	@Override
	public void setParam6(){
		product.setParam6(6);
	}
	
	@Override
    public Product getProduct() {
        return product;
    }
}

最后我们实现一下使用类

public class Use{
	private Builder builder;
	public void setBuilder(Builder builder){
		this.builder = builder;
	}

	public void createComputer(){
		builder.setParam1();
		builder.setParam2();
		builder.setParam3();
		builder.setParam4();
		builder.setParam5();
		builder.setParam6();
	}
	
	public Product getProduct(){
		return builder.getProduct();
	}
}

3.使用

public class Test{
	public static void main(String[] args){
		Use use = new Use();
		use.setBuilder(new BuilderImpl ());
		use.createProduct();
		log.i("Product",use.toString());
	}
}

输出：

Product:"21"

改革Builder模式 —— 静态内部类Builder

1.成员

只有产品类和内部Builder类

public class Product{
	public static class Builder{
	}
}

2.实例

public class Product{

	private final String param1;
	private final String param2;
	private final String param3;
	
	private Product(Builder builder){
		this.param1 = builder.param1;
		this.param2 = builder.param2;
		this.param3 = builder.param3;
	}
	
	public static class Builder{
		private final String param1;
		private String param2;
		private String param3; 
		
		public Builder(String param1){
			this.param1 = param1;
		}
		
		public Builder param2(){
			this.param2 = param2;
			return this;
		}

		public Builder param3(){
			this.param3 = param3;
			return this;
		}

		public Product build(){
			return new Product(this);
		}
	}
}

3.使用

public class Use{
	public static void main(String[] args){
		Product p = new Product.Builder("param1")
			.param2("param2")
			.param3("param3")
			.build();
	}
}

总结

• 我们其实使用过很多建造者模式，例如，AlertDialog的Builder。
• 建造者模式是用来创建复杂对象的，如果只是普通的对象，内部逻辑较少或者内部属性不多就没有必要使用建造者模式（以上两个例子就没必要用Builder模式，本人只是用作样例）

优缺点

优点	封装性良好，易于解耦，易于扩展，易于精确控制对象的创建
缺点	产生多余的Build对象，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制