java的代理模式有两种，一种是jdk自带的动态代理，一种是cglib动态代理。

1、jdk动态代理：

   RealSubject  "卖书" 1"说话" "张三"  JdkProty .subject = Object invoke(Object proxy, Method method, Object[] args) "调用代理类" (method.getName().equals("sellBook" invoke = ("调用了卖书的方法"  (method.getName().equals("speak"="调用的是说话的方法"    = = =

 使用jdk动态代理的前提条件：被代理的类一定要有实现的接口

/**
 * java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口用来完成动态代理。
 * InvocationHandler接口：
 * 当我们通过代理对象调用一个方法时，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法进行调用
 * Proxy类
 * 该类提供了一个创建动态代理对象的方法
 */

　2、cglib动态代理

Cglib 动态代理是针对代理的类, 动态生成一个子类, 然后子类覆盖被代理类中的方法, 如果是private或是final类修饰的方法,则不会被重写。

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

使用cglib动态代理需要导包：cglib-nodep-2.2.2.jar

/**
 * 1.创建真实类对象 */public class Ennigeer {//可以被代理的方法public int eat() {
        System.out.println("工程师在吃饭");return 1;
    }//final修饰的方法不会被cglib生成的子类覆盖，可以通过代理类调用，但是不能执行代理类的方法public final String work() {
        System.out.println("工程师在工作");return "hello";
    }//private修饰的方法不会被生成的子类覆盖，不能通过代理类调用private void play() {
        System.out.println("工程师在玩");
    }
}public class CglibProxy implements MethodInterceptor {/** * 该intercept方法类似于jdk的invoke方法发
     * @param o         被代理类对象
     * @param method    被代理类的方法对象
     * @param objects   传进去的参数
     * @param methodProxy 代理方法的代理对象
     * @return * @throws Throwable     */@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法调用之前");
        Object invoke = methodProxy.invokeSuper(o, objects);
        System.out.println("方法调用之后");return invoke;
    }/** * 得到代理类
     * @param obj 被代理类对象
     * @return     代理类对象     */public Object getProxy(Object obj) {//创建加强器，用来创建被代理类的对象Enhancer enhancer = new Enhancer();//为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）        enhancer.setSuperclass(obj.getClass());//设置回调，对代理类上所有方法的调用，都会调用CallBack(),而CallBack()方法则需要intercept方法进行拦截enhancer.setCallback(this);//创建被代理类对象的特殊格式的对象return enhancer.create();
    }
}public class TestDemo {public static void main(String[] args) {
        Ennigeer ennigeer = new Ennigeer();
        CglibProxy cglibProxy = new CglibProxy();
        Ennigeer proxy = (Ennigeer) cglibProxy.getProxy(ennigeer);int eat = proxy.eat();//可以被代理的方法String work = proxy.work();//不能被代理的方法,可以调用该方法，但是不能代理        System.out.println(eat);
        System.out.println(work);
    }
}

/**
 *  net.sf.cglib.proxy.MethodInterceptor接口：是最通用的回调（callback）类型，
 *  它经常被AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法。
 * public Object intercept(Object proxy, Method method, Object[] params, MethodProxy methodProxy) 
 * proxy：代理的对象；
 * method：委托类执行的方法；
 * params：方法中的参数；
 * methodProxy：代理的方法
 * 由于性能的原因，对原始方法的调用我们使用CGLIB的net.sf.cglib.proxy.MethodProxy对象，而不是反射中一般使用java.lang.reflect.Method对象
 */

两种代理方式的比较：

　　CGLib动态代理创建代理实例速度慢，但是运行速度快；JDK动态代理创建实例速度快，但是运行速度慢。如果实例是单例的，推荐使用CGLib方式动态代理，反之则使用JDK方式进行动态代理。Spring的实例默认是单例，所以这时候使用CGLib性能高。 

　　JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；

　　CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；

 　　静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；