《设计模式之禅》读书笔记（三）

一.建造者模式

建造者模式(Build Pattern):将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者有以下几个角色：
* Product 产品类
* Builder抽象建造者 规范产品的组建，一般是由其子类实现
* ConcreteBuilder具体建造者 实现抽象类定义所有方法，并且返回一个组建好的对象。
* Director导演类 负责安排已有模块的顺序，然后告诉Builder开始建造
使用场景：
* 1.相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式；
* 2.多个部件或零件，都可以装配到同一个对象中，但产生的结果又不同；
* 3.产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能；
* 4.在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到。
与工厂模式区别：
* 建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗的说就是零件的装配， 顺序不同产生的对象也不同；
* 工厂模式则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。

   /**
     * 产品类
     */
    public class Product{
        public void doSomething(){
        }
    }

    /**
     * 抽象建造者
     */
    public abstract class Builder{
        public abstract void setPart();
        public abstract Product buildProduct();

    }

    /**
     * 具体建造者
     */
    public class ConcreteProduct extends  Builder{
        private Product product = new Product();
        @Override
        public void setPart() {
            //产品类的内部逻辑
        }

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

    /**
     * 导演类
     */
    public class Director{
        private Builder mBuilder = new ConcreteProduct();
        public Product getAProduct(){
            mBuilder.setPart();
            //设置不同的零件，产生不同的产品
            return mBuilder.buildProduct();
        }
    }

二.代理模式

代理模式：为其他对象提供一种代理以控制对这个对象的访问。
代理模式的三个角色：
* 1.Subject 抽象主题角色 可以是抽象类也可以是接口， 是一个最普通的业务类型定义，无特殊要求。
* 2.RealSubject 具体主题角色
* 3.Proxy代理主题角色

 public interface Subject {
        public void method();
    }

    public class RealSubject implements Subject {
        @Override
        public void method() {

        }
    }

    public class Proxy implements Subject {
        private Subject mSubject = null;

        public Proxy() {
            this.mSubject = new Proxy();
        }

        public Proxy(Object... objects) {
        }

        @Override
        public void method() {
            before();
            mSubject.method();
            after();
        }

        private void before() {
        }

        private void after() {
        }
    }

动态代理：动态代理是根据被代理的接口生成所有的方法，也就是说给定一个接口，动态代理会宣传“我已经实现该接口下所有方法了”。这里需要实现InvocationHandler接口，通过这个接口，所有方法都由该Handler来处理， 即所有被代理的方法都由InvocationHandler接管实际处理任务。

 public class MyInvocationHandler implements InvocationHandler {

        //被代理实类
        Object target = null;

        public MyInvocationHandler(Object _obj) {
            this.target = _obj;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
            Object result = method.invoke(this.target, objects);
            return result;
        }
    }

    //动态代理类
    public static class DynamicProxy<T> {
        public static <T> T newProxyInstance(ClassLoader loader, Class<T>[] interfaces, InvocationHandler h) {
            return (T) java.lang.reflect.Proxy.newProxyInstance(loader, interfaces, h);
        }
    }

    public static class SubjectDynamicProxy extends DynamicProxy {
        public static <T> T newProxyInstance(Subject subject) {
            ClassLoader cl = subject.getClass().getClassLoader();
            Class<?>[] classes = subject.getClass().getInterfaces();
            InvocationHandler mHandler = new MyInvocationHandler(subject);
            return newProxyInstance(cl, classes, mHandler);
        }
    }

    //场景类
    public class Client {
        Subject mSubject = new RealSubject();
        Subject proxy = SubjectDynamicProxy.newProxyInstance(mSubject);
        proxy.method();
    }