设计模式笔记三代理模式

每日一文

捭阖之道，以阴阳试之，故与阳言者依崇高，与阴言者依卑小。以下求小，以高求大。由此言之，无所不出，无所不入，无所不可。可以说人，可以说家，可以说国，可以说天下。
关于开放和封闭的规律都要从有阳两方面来试验。因此，给从阳的方面来游说的人以崇高的待遇，而给从阴的方面来游说的人以卑下的待遇。用卑下的来求索微小，以崇高来求索博大。由此看来，没有什么不能出去，没有什么不能进来，没有什么办不成的。用这个道理，可以说服人，可以说服家，可以说服国，可以说服天下。

代理模式

---

作用

原有类的行为基础上，加入一些多出的行为，甚至完全替换原有的行为。

代理模式中的角色：

• 抽象对象：声明与丑代理对象一样的街口，使用目标对象的地方完全可以由代理对象替代。
• 目标对象：被代理的对象
• 代理对象：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

两种形式：

• 静态代理:

指程序员创建好代理类，编译时直接生成代理类的字节码文件。

特点：

代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。而且代理类只能为特定的接口(Service)服务。

示例：

1. 统一的抽象接口：

package com.bankht.Proxy;
public abstract class AbstractObject {
      // 操作
      public abstract void operation();
}

2. 目标类：

package com.bankht.Proxy;
public class RealObject extends AbstractObject {
      @Override
      public void operation() {
        // 一些操作
        System.out.println("一些操作");
      }
 }

3. 静态代理类：对目标类的封装

package com.bankht.Proxy;
public class ProxyObject extends AbstractObject {
      RealObject realObject = new RealObject();

      @Override
      public void operation() {
        // 调用目标对象之前可以做相关操作
        System.out.println("before");
        realObject.operation();
        // 调用目标对象之后可以做相关操作
        System.out.println("after");
      }
}

4. 客户端调用:

package com.bankht.Proxy;
public class Client {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AbstractObject obj = new ProxyObject();
        obj.operation();
      }
}

• 动态代理：

代理类可代理一系列类的特定方法，代理类需要实现InvocationHandler接口。

特点：

如果需要委托类处理某一业务，那么我们就可以先在代理类中，对客户的权限、各类信息先做判断，如果不满足某一特定条件，则将其拦截下来，不让其代理。

示例：

1. 代理的接口：代码引用需要空行
   package com.example.patternproxy;

       import java.util.Date;
       
       /**
        * Created on 2017/3/11.
        * Desc：代理的接口
        * Author：Eric.w
        */
       
       public interface DateSerice {
       
           String queryDate();
       
           int cauOld(Date startdate);
       }
   

2. 被代理的类：

    package com.example.patternproxy;
   
    import android.util.Log;
   
    import java.text.SimpleDateFormat;
    import java.util.Date;
   
    /**
    * Created on 2017/3/11.
    * Desc：
    * Author：Eric.w
    */
   
    public class DateServiceImp implements DateSerice {
   
       SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
   
       @Override
       public String queryDate() {
           Date date = new Date();
           Log.e("pattern", "时间是：" + myFmt.format(date));
           return myFmt.format(date);
       }
   
       @Override
       public int cauOld(Date startdate) {
           return new Date().getYear() - startdate.getYear();
       }
   
       public String ownMethod() {
           Log.e("pattern", "ownMethod：");
           return "admin";
       }
    }
   

3. 代理类

• 动态代理有一个强制性要求，就是被代理的类必须实现了某一个接口，或者本身就是接口，就像我们的Connection。
  道理其实很简单，这是因为动态代理生成的代理类是继承Proxy类的，并且会实现被你传入newProxyInstance方法的所有接口，所以我们可以将生成的代理强转为任意一个代理的接口或者Proxy去使用，但是Proxy里面几乎全是静态方法，没有实例方法，所以转换成Proxy意义不大，几乎没什么用。假设我们的类没有实现任何接口，那么就意味着你只能将生成的代理类转换成Proxy，那么就算生成了，其实也没什么用，而且就算你传入了接口，可以强转，你也用不了这个没有实现你传入接口的这个类的方法。
  你可能会说，假设有个接口A，那我将接口A传给newProxyInstance方法，并代理一个没实现接口A的类B，但类B与接口A有一样的方法可以吗？
  答案是可以的，并且JDK的动态代理只认你传入的接口，只要你传入，你就可以强转成这个接口，这个一会解释，但是你无法在invoke方法里调用method.invoke方法，也就是说，你只能全部替换A接口的方法，而不能使用类B中原有与接口A方法描述相同的方法，这是因为invoke中传入的Method的class信息是接口A，而类B因为没实现接口A，所以无法执行传入的Method，会抛出非法参数异常。
• 上面我们运行就会发现接口的方法全部都只能输出一个很2的字符串了。如果是要继续使用TestClass的方法也不是不行，只要你确认你传入的类包括了所有你传入的接口的方法，只是没实现这些接口而已，那么你可以在invoke中这样使用。

public Object invoke(Object proxy, Method method, Object[] args) throws    Throwable {
          System.out.println("before");
          Method sourceMethod = source.getClass().getDeclaredMethod(method.getName(),  method.getParameterTypes());
        sourceMethod.setAccessible(true);
          Object result = sourceMethod.invoke(source, args);
          System.out.println("after");
          return result;
    }

这就与你实现接口的表现行为一致了，但是我们本来就只需要一句method.invoke就可以了，就因为没实现接口就要多写两行，所以这种突破JDK动态代理必须实现接口的行为就有点画蛇添足了。因为你本来就实现了该接口的方法，只是差了那一句implements而已。
上面写这个例子只是为了解释LZ当初的疑惑，因为LZ曾一度认为不实现接口就不能使用动态代理。

4. 代码

    import android.util.Log;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * Created on 2017/3/11.
     * Desc：
     * Author：Eric.w
     */
    
    public class DateProxy implements InvocationHandler {
    
        private Object target;
    
        public DateProxy(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (DateSerice.class.isAssignableFrom(proxy.getClass()) &&
                    method.getName().equals("queryDate")) {
                //调用代理
                Log.e("pattern", "方法来自代理！");
                return null;
            }
            //不调用代理
            return method.invoke(proxy, args);
        }
    
        /**
         * 返回被代理的类实例
         *
         * @return
         */
        public Object getProxyInstance() {
            return Proxy.newProxyInstance(target.getClass().getClassLoader()
                    , target.getClass().getInterfaces()
                    , this);
        }
    }

讲解动态代理的原理