代理模式

定义：为其他对象提供一种代理以控制对这个对象的访问

角色：

Subject抽象主题角色：抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。

RealSubject具体主题角色：也叫做被委托角色、被代理角色。它才是冤大头，是业务逻辑的具体执行者。

Proxy代理主题角色：也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。

    //抽象主题类
    public interface Subject {
         //定义一个方法
         public void request();
    }

    public class RealSubject implements Subject {
         //实现方法
         public void request() {
                 //业务逻辑处理
         }
    }

    public class Proxy implements Subject {
         //要代理哪个实现类
         private Subject subject = null;

         //默认被代理者
         public Proxy(){
                 this.subject = new Proxy();
         }

         //代理的构造函数
         public Proxy(Subject _subject){
                 this.subject = _subject;
         }

         //实现接口中定义的方法
         public void request() {
                 this.before();
                 this.subject.request();
                 this.after();
         }

         //预处理
         private void before(){
                 //do something
         }

         //善后处理
         private void after(){
                 //do something
         }
    }

关于代理模式和装饰模式：

装饰模式就是代理模式的一个特殊应用，两者的共同点是都具有相同的接口，不同点则是代理模式着重对代理过程的控制，而装饰模式则是对类的功能进行加强或减弱，它着重类的功能变化。

例：

代理模式：一个著名的短跑运动员有自己的代理人。如果你很仰慕他，你找运动员说“你跑个我看看”，运动员肯定不搭理你，不过你找到他的代理人就不一样了，你可能和代理人比较熟，可以称兄道弟，这个忙代理人还是可以帮的，于是代理人同意让你欣赏运动员的练习赛

    public interface IRunner {
         //运动员的主要工作就是跑步
         public void run();
    }

    public class Runner implements IRunner {
         public void run() {
                 System.out.println("运动员跑步：动作很潇洒");
         }
    }

    //代理人
    public class RunnerAgent implements IRunner {
         private IRunner runner;
         public RunnerAgent(IRunner _runner){
                 this.runner = _runner;
         }
         //代理人是不会跑的
         public void run() {
                 Random rand = new Random();
                 if(rand.nextBoolean()){
                         System.out.println("代理人同意安排运动员跑步");
                         runner.run();
                 }else{
                         System.out.println("代理人心情不好，不安排运动员跑步");
              }
         }
    }

    public class Client {
         public static void main(String[] args) {
                 //定义一个短跑运动员
                 IRunner liu = new Runner();
                 //定义liu的代理人
                 IRunner agent = new RunnerAgent(liu);
                 //要求运动员跑步
                 System.out.println("====客人找到运动员的代理要求其去跑步===");
                 agent.run();
         }
    }

装饰模式：装饰模式是对类功能的加强，怎么加强呢？增强跑步速度！在屁股后面安装一个喷气动力装置

    public class RunnerWithJet implements IRunner {
         private IRunner runner;
         public RunnerWithJet(IRunner _runner){
                 this.runner = _runner;
         }
         public void run() {
                 System.out.println("加快运动员的速度：为运动员增加喷气装置");
                 runner.run();
         }
    }

代理模式是把当前的行为或功能委托给其他对象执行，代理类负责接口限定：是否可以调用真实角色，以及是否对发送到真实角色的消息进行变形处理，它不对被主题角色（也就是被代理类）的功能做任何处理

装饰模式是在要保证接口不变的情况下加强类的功能，它保证的是被修饰的对象功能比原始对象丰富（当然，也可以减弱），但不做准入条件判断和准入参数过滤，如是否可以执行类的功能，过滤输入参数是否合规等，这不是装饰模式关心的。

动态代理：

    public interface Buy {
        void buyHouse(long money);
    }

    public class User implements Buy {
        @Override
        public void buyHouse(long money) {
            System.out.println("买房了，用了"+money+" 钱 ");
        }
    }

    public class DynamiclProxy implements InvocationHandler {
        //真正要买房的对象
        private Buy mObject;

        public DynamiclProxy(Buy mObject) {
            this.mObject = mObject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (method.getName().equals("buyHouse")){
                //如果方法是买房的话，那么先坑点钱
                long money= (long) args[0];//取出第一个参数，因为我们是知道参数的
                long newMoney= (long) (money*0.99);
                System.out.println("坑了我们:"+(money-newMoney)+"钱");
                args[0]=newMoney;//坑完再赋值给原来的参数
                /**
                 * 调用真实对象去操作
                 */
                return method.invoke(mObject,args);
            }
           //如果有其他方法，也可以跟上面这样判断
            return null;
        }
    }

    public class ProxyClient {
        public static void main(String[] args){
            Buy buy=new User();
            UserProxy proxy=new UserProxy(buy);
            proxy.buyHouse(1000000);

            System.out.println("动态代理测试");
            Buy dynamicProxy= (Buy) Proxy.newProxyInstance(buy.getClass().getClassLoader(),
                    buy.getClass().getInterfaces(),new DynamiclProxy(buy));
            dynamicProxy.buyHouse(1000000);
        }
    }

    //相当于
    public class UserProxy implements Buy {

        private Buy mBuy;
        public UserProxy(Buy mBuy) {
            this.mBuy = mBuy;
        }

        @Override
        public void buyHouse(long money) {
            long newMoney= (long) (money*0.99);
            System.out.println("这里坑点血汗钱，坑了我们:"+(money-newMoney)+"钱");
            mBuy.buyHouse(newMoney);
        }
    }

动态代理，顾名思义是动态的，Java中的动态一般指的是在运行时的状态，是相对编译时的静态来区分，就是在运行时生成一个代理对象帮我们干活；