大话设计模式读书笔记（五） 代理模式

上篇内容说到小菜去和娇娇约会，在本章中，小菜约会回来，和大鸟谈到娇娇是有男朋友的。并且聊到了娇娇的男朋友在追娇娇的过程。通过帮助卓贾谊同学东西的方法追求到了娇娇。而引出了代理模式。

代理模式Proxy：

代理模式（Proxy）：为其他对象提供一种代理，已控制这种对这个对象的访问。

代理模式UMl类图：

代理模式代码如下：

//接口public interface Subject {public void request();}

//所代理的真实的类public class RealSubject implements Subject{@Overridepublic void request() {System.out.println("我是真实的");}}

//代理public class Proxy implements Subject{private RealSubject rs ;@Overridepublic void request() {System.out.println("我是代理");if(null == rs){rs = new RealSubject();}rs.request();}}

代理模式的应用：

1、远程代理，也就是为对象在不同的地址空间提供一个局部代表。这样可以隐藏一个对象存在于不同的地址空间的事实。

例如在使用Webservice时，通过WebService插件在项目中自动生成的文件和类，其实他们就是代理，这样就可以使程序调用代理就可以解决远程访问的问题。

2、虚拟代理，当需要创建开销很大的对象。通过它来存放实例化需要很长时间的真是对象。例如：在打开图片较多的网页是，先显示文字和一些图片框，然后在一点点加载图片。而这些框框就是代理了真是图片，用来存储真是图片的地址和尺寸。

3、安全代理，用来控制不同对象的访问权限。

3、只能指引，指调用真是的对象时，代理处理另外一些事。例如 Spring AOP。

------------------------------------------------------------------分割线--------------------------------------------------------------------------

Spring AOP中的代理模式：

下面内容转自推酷，网址：http://www.tuicool.com/articles/ANZvi2Q

两种代理

按照代理的创建时期，代理类可以分为两种。

静态代理

由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。上面的例子就是静态代理，与动态代理相比，静态代理有一些局限性，比如：有多少目标类就有多少proxy；在目标类中有多少方法，在代理类中就有多少方法。

动态代理

在程序运行时，运用反射机制动态创建而成。JDK动态代理中包含一个类和一个接口：

1. InvocationHandler接口：

   public interface InvocationHandler { public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; } /*参数说明： Object proxy：指被代理的对象。 Method method：要调用的方法 Object[] args：方法调用时所需要的参数 */

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

1. Proxy类：

   Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

   public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException  /*参数说明： ClassLoader loader：类加载器 Class<?>[] interfaces：得到全部的接口 InvocationHandler h：得到InvocationHandler接口的子类实例  */

与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

JDK动态代理

public interface Subject {      public void request();  }

public class SubjectImpl implements Subject {      public void request(){     System.out.println("RealSubject");    }}

public class SubjectProxy implements InvocationHandler {      private Object target;      /**      * 绑定委托对象并返回一个代理类      * @param target      * @return      */      public Object bind(Object target) {          this.target = target;          //取得代理对象          return Proxy.newProxyInstance(target.getClass().getClassLoader(),                  target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)      }        @Override      /**      * 调用方法      */      public Object invoke(Object proxy, Method method, Object[] args)              throws Throwable {          Object result=null;          System.out.println("事物开始");          //执行方法          result=method.invoke(target, args);          System.out.println("事物结束");          return result;      }    }

public static void main(String[] args) {          SubjectProxy proxy = new SubjectProxy();          Subject subjectProxy = (Subject) proxy.bind(new SubjectImpl());          subjectProxy.request();      }

DK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

CGLIB动态代理

public interface Subject {      public void request();  }

public class SubjectImpl{      public void request(){     System.out.println("RealSubject");    }}

public class SubjectCglib implements MethodInterceptor {      private Object target;      /**      * 创建代理对象      *       * @param target      * @return      */      public Object getInstance(Object target) {          this.target = target;          Enhancer enhancer = new Enhancer();          enhancer.setSuperclass(this.target.getClass());          // 回调方法          enhancer.setCallback(this);          // 创建代理对象          return enhancer.create();      }        @Override      // 回调方法      public Object intercept(Object obj, Method method, Object[] args,              MethodProxy proxy) throws Throwable {          System.out.println("事物开始");          proxy.invokeSuper(obj, args);          System.out.println("事物结束");          return null;      }    }

public static void main(String[] args) {      SubjectCglib cglib=new SubjectCglib();      SubjectImpl subjectCglib=(SubjectImpl)cglib.getInstance(new SubjectImpl());      subjectCglib.request();  }

Spring两种代理方式

1. 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。 
   优点：因为有接口，所以使系统更加松耦合 
   缺点：为每一个目标类创建接口
2. 若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。 
   优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。 
   缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。 
   动态代理是Spring AOP技术的基础，掌握了动态代理，接下来学习AOP会更加得心应手。