一、定义

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

二、模板方法模式结构图

建造者

角色	类别	说明
Builder	接口或抽象类	抽象的建造者，不是必须的
ConcreateBuilder	具体的建造者	可以有多个「因为每个建造风格可能不一样」
Product	普通的类	具体的产品「即被建造的对象」
Director	导演也叫指挥者	统一指挥建造者去建造目标，导演不是必须的

三、模式的实现

public class Product {

    private List<String> parts = new ArrayList<>();
    public void addPart(String part) {
        parts.add(part);
    }

    public void showProduct() {
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

public abstract class Builder {

    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract Product getResult();

}

public class ConcreteBuilderOne extends Builder {

    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.addPart("部件A");
    }

    @Override
    public void buildPartB() {
        product.addPart("部件B");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

public class ConcreteBuilderTwo extends Builder {
    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.addPart("部件A");
    }

    @Override
    public void buildPartB() {
        product.addPart("部件B");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

public class Director {
    public void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}

public static void main(String[] args) {
        Director director = new Director();
        Builder builderOne = new ConcreteBuilderOne();
        Builder builderTwo = new ConcreteBuilderTwo();

        director.construct(builderOne);
        Product p1 = builderOne.getResult();
        p1.showProduct();

        director.construct(builderTwo);
        Product p2 = builderTwo.getResult();
        p2.showProduct();
    }

四、使用的案例

dubbo 源码中获取内存cache的一段逻辑就是用了建造者模式，接着直接贴上源码对照着上面的四部分。
分析：构建cache都要先缓存到一个map中去，get的时候先从map获取，获取不到，在构建，然后放入map。整个流程是固定的，只是放入的Cache有多种。

Product

public interface Cache {

    void put(Object key, Object value);

    Object get(Object key);

}

public class LruCache implements Cache {
    
    private final Map<Object, Object> store;

    public LruCache(String url) {
        final int max = 1000;
        //TODO 1 LinkedHashMap可以做成lru格式的
        this.store = new LinkedHashMap<Object, Object>() {
            private static final long serialVersionUID = -3834209229668463829L;
            @Override
            protected boolean removeEldestEntry(Entry<Object, Object> eldest) {
                return size() > max;
            }
        };
    }

    @Override
    public void put(Object key, Object value) {
        synchronized (store) {
            store.put(key, value);
        }
    }

    @Override
    public Object get(Object key) {
        synchronized (store) {
            return store.get(key);
        }
    }

}

Builder

public abstract class AbstractCacheFactory implements CacheFactory {
    
    private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();

    @Override
    public Cache getCache(String url) {
        String key = url;
        Cache cache = caches.get(key);
        if (cache == null) {
            caches.put(key, createCache(url));
            cache = caches.get(key);
        }
        return cache;
    }

    protected abstract Cache createCache(String url);

}

ConcreteBuliderOne

public class LruCacheFactory extends AbstractCacheFactory {

    @Override
    protected Cache createCache(String url) {
        return new LruCache(url);
    }

}

ConcreteBuliderTwo

public class JCacheFactory extends AbstractCacheFactory {

    protected Cache createCache(URL url) {
        return new JCache(url);
    }

}
Director

public class Director {
    public Cache construct(AbstractCacheFactory abstractCacheFactory) {
       return abstractCacheFactory.getCache("cache");
    }
}

public class Director {
    public Cache construct(AbstractCacheFactory abstractCacheFactory) {
       return abstractCacheFactory.getCache("cache");
    }
}
public static void main(String[] args) {
        Director director = new Director();
        AbstractCacheFactory abstractCacheFactory = new LruCacheFactory();
        Cache cache = director.construct(abstractCacheFactory);
    }