java 动态代理

1. 代理模式
   代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象
   代理分为静态代理 和动态代理
2. 静态代理
   静态代理,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.
   步骤
   1.通过实现InvocationHandler接口来自定义自己的InvocationHandler;
    
   2.通过Proxy.getProxyClass获得动态代理类
    
   3.通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)
    
   4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入
    
   5.通过代理对象调用目标方法
     接口：
   

   public interface Person {
       public  void say();
   }
   实现类：
   

   public class Boy implements Person {
       public void say() {
           System.out.println("boy say hello....");
       }
   }

   代理实现类：

   public class ProxyPerson implements Person {
       private  Person  target;
       public  ProxyPerson(Person target){
           this.target=target;
       }
       public void say() {
           System.out.println("Proxy start ....");
           target.say();
           System.out.println("Proxy end ....");
   
       }
   }
   测试类：
   

   public class App 
   {
       public static void main( String[] args )
       {
           System.out.println( "静态 Proxy test !" );
           //目标
           Boy person= new Boy();
           //建立代理
           ProxyPerson proxyPerson=new ProxyPerson(person);
           //执行代理方法
           proxyPerson.say();
   
       }
   }

   总结：

   优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展.
   缺点: 因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，一旦接口增加方法,目标对象与代理对象都要维护。

   解决此问题可以使用动态代理类
3. 动态代理
   代理对象,不需要实现接口
   动态代理类：
   

   public class ProxyFactory {
       //目标
       private Object target;
       public ProxyFactory(Object target){
           this.target=target;
       }
       //给目标对象生成代理对象
       public Object getProxyInstance(){
           //使用Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)返回某个对象的代理对象
           return Proxy.newProxyInstance(
                   target.getClass().getClassLoader(),
                   target.getClass().getInterfaces(),
                   /**
                    * InvocationHandler接口只定义了一个invoke方法，因此对于这样的接口，我们不用单独去定义一个类来实现该接口，
                    * 而是直接使用一个匿名内部类来实现该接口，new InvocationHandler() {}就是针对InvocationHandler接口的匿名实现类
                    * 在invoke方法编码指定返回的代理对象干的工作
                    * proxy : 把代理对象自己传递进来
                    * method：把代理对象当前调用的方法传递进来
                    * args:把方法参数传递进来
                    *
                    * 当调用代理对象的方法时，
                    * 实际上执行的都是invoke方法里面的代码，
                    * 因此我们可以在invoke方法中使用method.getName()就可以知道当前调用的是代理对象的哪个方法
                    */
                   new InvocationHandler() {
                       @Override
                       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                           System.out.println("————————————————————————Proxy start");
                           //执行目标对象方法
                           Object returnValue = method.invoke(target, args);
                           System.out.println("————————————————————————Proxy end  ");
                           return returnValue;
                       }
                   }
           );
       }
   }

   测试:

   //动态代理
    System.out.println( "动态代理 Proxy test !" );
    //目标
    Boy person= new Boy();
    //建立代理
    Person proxyFactory = (Person) new ProxyFactory(person).getProxyInstance();
   //代理对象 class com.sun.proxy.$Proxy0
    System.out.println(proxyFactory.getClass());
    //执行代理方法
    proxyFactory.say();

   总结：    优点：代理类不需要实现接口，    缺点：被代理类必须实现接口 代理类是继承了Proxy类的，这就是说明了为什么使用JDK动态代理不能实现继承式动态代理，原因是Java不允许多继承，而生成的代理类本身就已经继承了Proxy类。如果被代理类没有实现接口呢？？这里就需要用到cglib代理类，上述的动态代理是jdk的动态代理
   Java JDK 动态代理使用及实现原理分析
   
   

   cglib代理类

cglib 动态代理：
需要引入 cglib.jar

    代理类：

public class CglibProxyFactory  implements MethodInterceptor {
    private  Object target;
    public  CglibProxyFactory(Object target){
        this.target=target;
    }

    public  Object getProxyInstance(){
        // 工具类
        Enhancer enhancer= new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //回调函数
        enhancer.setCallback(this);
        //创建子类
        return  enhancer.create();

    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("—————————cglib———————————————Proxy start");
        //执行目标对象方法
        Object returnValue = method.invoke(target, objects);
        System.out.println("———————————cglib—————————————Proxy end  ");
        return returnValue;
    }
}

测试：

//cglib 代理
Person cglibproxyFactory = (Person) new CglibProxyFactory(person).getProxyInstance();
//代理对象 com.chf.proxy.Boy$$EnhancerByCGLIB$$a1a0404c
System.out.println(cglibproxyFactory.getClass());
//执行代理方法
cglibproxyFactory.say();
深入理解CGLIB动态代理机制

Cglib动态代理实现原理

三种代理方式之间对比。

代理方式	实现	优点	缺点	特点
JDK静态代理	代理类与委托类实现同一接口，并且在代理类中需要硬编码接口	实现简单，容易理解	代理类需要硬编码接口，在实际应用中可能会导致重复编码，浪费存储空间并且效率很低	好像没啥特点
JDK动态代理	代理类与委托类实现同一接口，主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的，在invoke方法中将对方法进行增强处理	不需要硬编码接口，代码复用率高	只能够代理实现了接口的委托类	底层使用反射机制进行方法的调用
CGLIB动态代理	代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法。在代理方法中，它会判断是否存在实现了MethodInterceptor接口的对象，若存在则将调用intercept方法对委托方法进行代理	可以在运行时对类或者是接口进行增强操作，且委托类无需实现接口	不能对final类以及final方法进行代理	底层将方法全部存入一个数组中，通过数组索引直接进行方法调用