设计模式-创建型之建造者模式

建造者模式

• 作用
  – 用于组装具有复杂结构的实例；
  – 将制造细节与创建分离开来(复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示)；
• UML图
  
• 对比工厂(模板)方法：
  – Builder只是将算法、建造流程的定义放在了一个叫指挥者中，责任需要改变，只需新增Director。
  – 模板方法，责任全放在了父类里，如果责任需要改变，则必须要修改父类中的责任方法了，这样就修改了原来的代码，不利于复用，这也是两者的本质区别。
  – Builder 模式符合最少知道原则（迪米特法则），当我们创建这个复杂的对象时，我只是使用Director，对于Buildr则是一无所知，你创建的过程和创建的是什么我不关心,实现了对象的构建与表示的解耦，同样的构建过程可以创建不同的表示（我的理解：工厂方法也可以做到这一点，我觉得设计模式其实是有很多功能、效果相似之处，只是遵从的原则不同、侧重点不同）。
• 代码实现

//产品接口
public interface Product {
}
//产品实现类
public class MyProduct implements Product {

    private String name;

    private String type;

    public String getType() {
        return type;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }
}
//抽象建造者
public abstract class Builder {

    public abstract void first();

    public abstract void second();

    public abstract Product getProduct();
}
//具体建造者
public class ConcreteBuilder extends Builder {

    MyProduct product = new MyProduct();

    @Override
    public void first() {
        this.product.setName("product");
    }

    @Override
    public void second() {
        this.product.setType("type");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}
//指挥者
public class Director {

    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

    public Product concrete(){
        builder.first();
        builder.second();
        return builder.getProduct();
    }
}
//测试类
public class Test {

    public static void main(String[] args) {
        Director director = new Director(new ConcreteBuilder());
        Product product = director.concrete();
        System.out.println(product);
    }
}

特点：建造复杂的对象；
优点：将对象的建造和表示解耦；符合最少知道原则；封装性好；

• 变异的建造者模式
  其实上面的例子比较简单，Builder是用来构建复杂结构的对象。
  下面写一个我们见过的典型的例子，大家应该在开发中见过很多链式方法调用，其中这种方式就是一种典型Builder模式，使用方便，简单易懂。

public class MyHttpUrl {

    private String scheme;

    private String port;

    private String host;
    
    //使用静态内部类来实现；省去指挥者这一角色
    static class Builder {
        
        private MyHttpUrl myHttpUrl;
        
        public Builder build() {
            myHttpUrl = new MyHttpUrl();
            return this;
        }
        
        public Builder setScheme(String scheme){
            myHttpUrl.scheme = scheme;
            return this;
        }

        public Builder setHost(String host){
            myHttpUrl.host = host;
            return this;
        }
        
        public Builder setPort(String port){
            myHttpUrl.port = port;
            return this;
        }
        
        public MyHttpUrl getMyHttpUrl(){
            return myHttpUrl;
        }
    }
}
//使用
public class Test {

    public static void main(String[] args) {
        MyHttpUrl myHttpUrl = new MyHttpUrl.Builder()
                .build()
                .setScheme("http://")
                .setHost("127.0.0.1")
                .setPort("123")
                .getMyHttpUrl();
    }
}