建造者模式（Builder）

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

一个Sender接口，两个实现类MailSender和SmsSender。最后，建造者类如下：

/**
 * 产品接口
 */
public interface Sender {
    public void Send();
}

/**
 * 产品类
 */
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

/**
 * 产品类
 */
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

/**
 * 建造者类
 */
public class Builder {
    private List<Sender> list = new ArrayList<Sender>();

    public void produceMailSender(int count){
        for(int i=0; i<count; i++){
            list.add(new MailSender());
        }
    }
    public void produceSmsSender(int count){
        for(int i=0; i<count; i++){
            list.add(new SmsSender());
        }
    }
}

/**
 * 测试类
 */
public class Test {

    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.produceMailSender(10);
    }
}

从这点看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。

使用建造模式构建复杂对象
　　考虑这样一个实际应用，要创建一个保险合同的对象，里面很多属性的值都有约束，要求创建出来的对象是满足这些约束规则的。约束规则比如：保险合同通常情况下可以和个人签订，也可以和某个公司签订，但是一份保险合同不能同时与个人和公司签订。这个对象里有很多类似这样的约束，采用建造模式来构建复杂的对象

/**
    * 保险合同对象
    */
public class InsuranceContract {
       //保险合同编号
   private String contractId;
       /**
        * 被保险人员的名称，同一份保险合同，要么跟人员签订，要么跟公司签订
        * 也就是说，“被保险人员”和“被保险公司”这两个属性，不可能同时有值
        */
       private String personName;
       //被保险公司的名称
   private String companyName;
       //保险开始生效日期
   private long beginDate;
       //保险失效日期，一定会大于保险开始生效日期
   private long endDate;
       //其他数据
   private String otherData;
       //私有构造方法
   private InsuranceContract(ConcreteBuilder builder){
           this.contractId = builder.contractId;
           this.personName = builder.personName;
           this.companyName = builder.companyName;
           this.beginDate = builder.beginDate;
           this.endDate = builder.endDate;
           this.otherData = builder.otherData;
       }
       /**
        * 保险合同的一些操作
        */
       public void someOperation(){
           System.out.println("当前正在操作的保险合同编号为【"+this.contractId+"】");
       }

       public static class ConcreteBuilder{
           private String contractId;
           private String personName;
           private String companyName;
           private long beginDate;
           private long endDate;
           private String otherData;
           /**
            * 构造方法，传入必须要有的参数
            * @param contractId     保险合同编号
            * @param beginDate        保险合同开始生效日期
            * @param endDate        保险合同失效日期
            */
           public ConcreteBuilder(String contractId,long beginDate,long endDate){
               this.contractId = contractId;
               this.beginDate = beginDate;
               this.endDate = endDate;
           }
           //被保险人员的名称
       public ConcreteBuilder setPersonName(String personName) {
               this.personName = personName;
               return this;
           }
           //被保险公司的名称
       public ConcreteBuilder setCompanyName(String companyName) {
               this.companyName = companyName;
               return this;
           }
           //其他数据
       public ConcreteBuilder setOtherData(String otherData) {
               this.otherData = otherData;
               return this;
           }
           /**
            * 构建真正的对象并返回
            * @return    构建的保险合同对象
            */
           public InsuranceContract build(){
               if(contractId == null || contractId.trim().length()==0){
                   throw new IllegalArgumentException("合同编号不能为空");
               }
               boolean signPerson = (personName != null && personName.trim().length() > 0);
               boolean signCompany = (companyName != null && companyName.trim().length() > 0);
               if(signPerson && signCompany){
                   throw new IllegalArgumentException("一份保险合同不能同时与个人和公司签订");
               }
               if(signPerson == false && signCompany == false){
                   throw new IllegalArgumentException("一份保险合同不能没有签订对象");
               }
               if(beginDate <= 0 ){
                   throw new IllegalArgumentException("一份保险合同必须有开始生效的日期");
               }
               if(endDate <=0){
                   throw new IllegalArgumentException("一份保险合同必须有失效的日期");
               }
               if(endDate < beginDate){
                   throw new IllegalArgumentException("一份保险合同的失效日期必须大于生效日期");
               }
               return new InsuranceContract(this);
           }
       }
   }

在本例中将具体建造者合并到了产品对象中，并将产品对象的构造函数私有化，防止客户端不使用构建器来构建产品对象，而是直接去使用new来构建产品对象所导致的问题。另外，这个构建器的功能就是为了创建被构建的对象，完全可以不用单独一个类。

在什么情况下使用建造模式
　　1. 需要生成的产品对象有复杂的内部结构，每一个内部成分本身可以是对象，也可以仅仅是一个对象（即产品对象）的一个组成部分。
　　2. 需要生成的产品对象的属性相互依赖。建造模式可以强制实行一种分步骤进行的建造过程，因此，如果产品对象的一个属性必须在另一个属性被赋值之后才可以被赋值，使用建造模式是一个很好的设计思想。
　　3. 在对象创建过程中会使用到系统中的其他一些对象，这些对象在产品对象的创建过程中不易得到。