Spring的静，动 态代理（jdk,cglib）

JAVA的动态代理 
代理模式 
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 

动态代理：在程序运行时，运用反射机制动态创建而成。 

下面我们来看一下静态代理：下面分别是接口，实现类，代理类，测试类

package cn.happy.spring08staticproxy;/** * Created by linlin on 2017/7/31. */public interface Subject {    public void request();}

package cn.happy.spring08staticproxy;/** * Created by linlin on 2017/7/31. */public class RealSubject implements Subject {    public void request() {        System.out.println("request");    }}

package cn.happy.spring08staticproxy;/** * Created by linlin on 2017/7/31. */public class ProxySubject implements Subject{private Subject subject;    public void request() {        System.out.println("================before=============");        subject.request();    }    public Subject getSubject() {        return subject;    }    public void setSubject(Subject subject) {        this.subject = subject;    }}

   @Test    public void test(){        ProxySubject proxys=new ProxySubject();Subject sub=new RealSubject();proxys.setSubject(sub);proxys.request();    }




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

下面是JDK的动态代理：关于jdk的动态代理，他是JDK本身的 ，必须实现接口，
首先我要说的就是接口，为什么JDK的动态代理是基本接口实现的呢？
　　因为通过使用接口指向实现类的实例的多态实现方式，可以有效的将具体的实现与调用之间解耦，便于后期修改与维护。
再具体的说就是我们在代理类中创建一个私有成员变量（private修饰），使用接口来指向实现类的对象（纯种的多态体现，向上转型的体现），然后在该代理类中的方法中使用这个创建的实例来调用实现类中的相应方法来完成业务逻辑功能。
这么说起来，我之前说的“将具体实现类完全隐藏”就不怎么正确了，可以改成，将具体实现类的细节向调用方完全隐藏（调用方调用的是代理类中的方法，而不是实现类中的方法）。
　　这就是面向接口编程，利用java的多态特性，实现程序代码的解耦。
如果你了解静态代理，那么你会发现动态代理的实现其实与静态代理类似，都需要创建代理类，但是不同之处也很明显，创建方式不同！
　　不同之处体现在静态代理我们知根知底，我们知道要对哪个接口、哪个实现类来创建代理类，所以我们在编译前就直接实现与实现类相同的接口，直接在实现的方法中调用实现类中的相应（同名）方法即可；而动态代理不同，我们不知道它什么时候创建，也不知道要创建针对哪个接口、实现类的代理类（因为它是在运行时因需实时创建的）。
　　虽然二者创建时机不同，创建方式也不相同，但是原理是相同的，不同之处仅仅是：静态代理可以直接编码创建，而动态代理是利用反射机制来抽象出代理类的创建过程。
package cn.happy.spring09jdkproxy;/** * Created by linlin on 2017/7/31. */public interface ISome {    public String str();}

package cn.happy.spring09jdkproxy;/** * Created by linlin on 2017/7/31. */public class Some implements ISome{    public String str() {        System.out.println("str");return "proxy";    }}

package cn.happy.spring09jdkproxy;/** * Created by linlin on 2017/7/31. */public class SomeSer implements ISome{    public String str() {        return "呵呵";    }}
    @Testpublic void testjdk(){       final ISome s=new Some();        ISome proxy=(ISome) Proxy.newProxyInstance(s.getClass().getClassLoader(), s.getClass().getInterfaces(), new InvocationHandler() {            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                System.out.println("==============================before=======");           Object result=method.invoke(s,args);                return result;            }        });String r=proxy.str();       System.out.println(r);    }




cglib的动态代理：
什么是cglib
     CGLIB是一个强大的高性能的代码生成包。
      1>它广泛的被许多AOP的框架使用，例如：Spring AOP和dynaop，为他们提供方法的interception（拦截）；
       2>hibernate使用CGLIB来代理单端single-ended(多对一和一对一)关联（对集合的延迟抓取，是采用其他机制实现的）；
       3>EasyMock和jMock是通过使用模仿（moke）对象来测试java代码的包。
     它们都通过使用CGLIB来为那些没有接口的类创建模仿（moke）对象。
  CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM(Java字节码操控框架)，来转换字节码并生成新的类。除了CGLIB包，脚本语言例如 Groovy和BeanShell，也是使用ASM来生成java的字节码。当不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。所以cglib包要依赖于asm包，需要一起导入。

cglib是一个字节码操纵库，底层基于ASM框架。虽然JDK同样提供了动态代理功能，但是必须将需要代理的方法写在接口中，由主体类继承，很不灵活，而且性能不如cglib。下面是一个使用cglib动态代理的例子。
package cn.happy.spring10cglibproxy;/** * Created by linlin on 2017/7/31. */public class SomeService {    public void doSome(){        System.out.println("========dosome");    }}

    @Test    public void testcglib(){        Enhancer enhancer=new Enhancer();        final SomeService ser=new SomeService();        enhancer.setSuperclass(ser.getClass());        enhancer.setCallback(new MethodInterceptor() {            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                System.out.println("======cglib===");                methodProxy.invoke(ser,objects);                return null;            }        });    SomeService proxy=(SomeService)enhancer.create();    proxy.doSome();    }



小结：
　第一点：静态代理需要实现与实现类相同的接口，而动态代理需要实现的是固定的Java提供的内置接口（一种专门提供来创建动态代理的接口）InvocationHandler接口，因为java在接口中提供了一个可以被自动调用的方法invoke，这个之后再说。
　　　　第二点：private Object object;
　　　　　　　　public UserProxy(Object obj){this.object = obj;}
　　这几行代码与静态代理之中在代理类中定义的接口指向具体实现类的实例的代码异曲同工，通过这个构造器可以创建代理类的实例，创建的同时还能将具体实现类的实例与之绑定（object指的就是实现类的实例，这个实例需要在测试类中创建并作为参数来创建代理类的实例），实现了静态代理类中private Iuser user = new UserImpl();一行代码的作用相近，这里为什么不是相同，而是相近呢，主要就是因为静态代理的那句代码中包含的实现类的实例的创建，而动态代理中实现类的创建需要在测试类中完成，所以此处是相近。
　　　　第三点：invoke(Object proxy, Method method, Object[] args)方法，该方法是InvocationHandler接口中定义的唯一方法，该方法在调用指定的具体方法时会自动调用。其参数为：代理实例、调用的方法、方法的参数列表
　　在这个方法中我们定义了几乎和静态代理相同的内容，仅仅是在方法的调用上不同，不同的原因与之前分析的一样（创建时机的不同，创建的方式的不同，即反射），Method类是反射机制中一个重要的类，用于封装方法，该类中有一个方法那就是invoke(Object object,Object...args)方法，其参数分别表示：所调用方法所属的类的对象和方法的参数列表，这里的参数列表正是从测试类中传递到代理类中的invoke方法三个参数中最后一个参数（调用方法的参数列表）中，在传递到method的invoke方法中的第二个参数中的（此处有点啰嗦）。
　　　　第四点：测试类中的异同
　　静态代理中我们测试类中直接创建代理类的对象，使用代理类的对象来调用其方法即可，若是别的接口（这里指的是别的调用方）要调用Iuser的方法，也可以使用此法
动态代理中要复杂的多，首先我们要将之前提到的实现类的实例创建（补充完整），然后利用这个实例作为参数，调用代理来的带参构造器来创建“代理类实例对象”，这里加引号的原因是因为它并不是真正的代理类的实例对象，而是创建真正代理类实例的一个参数，这个实现了InvocationHandler接口的类严格意义上来说并不是代理类，我们可以将其看作是创建代理类的必备中间环节，这是一个调用处理器，也就是处理方法调用的一个类，不是真正意义上的代理类，可以这么说：创建一个方法调用处理器实例。
　　下面才是真正的代理类实例的创建，之前创建的”代理类实例对象“仅仅是一个参数
　　　　Iuser proxy = (Iuser) Proxy.newProxyInstance(Iuser.class.getClassLoader(), new Class[]{Iuser.class}, h);
　　这里使用了动态代理所依赖的第二个重要类Proxy，此处使用了其静态方法来创建一个代理实例，其参数分别是：类加载器（可为父类的类加载器）、接口数组、方法调用处理器实例
　　这里同样使用了多态，使用接口指向代理类的实例，最后会用该实例来进行具体方法的调用即可。