静态代理，jdk动态代理以及Cglib区别

     众所周知，Spring AOP中涉及到了动态代理模式，那么有动态代理相应的就会有静态代理。那么动态代理分为哪几种，相对应的区别又是什么呢？

     首先什么是代理？

     找一个东西或者一个人去帮你做事，比如常说的中介就是一个代理，各大经销商的代理商等等。JAVA中的代理即是指将自己的事情委派给别人帮忙去完成。

     静态代理：代理的是程序员已经创建好的类，也就是说当前仅有一个对象能被成功代理。上代码看下

     首先是一个需要代理的接口类

     该类描述了两个方法，一个是eat()，一个是run();

public interface UserAction {

    void eat();

    void run();
}

     接下来是该类的实现类，较为简单的实现方式，仅仅打印内容而已。  

public class UserActionImpl implements UserAction {

    @Override
    public void eat() {
        System.out.println("吃饭");
    }

    @Override
    public void run() {
        System.out.println("跑步");
    }
}

    接口已经实现完成，剩下的即是代理对象了。上述的过程中静态代理和JDK的动态代理还没有区别。区别在于下面

public class UserActionStaticProxy implements UserAction{

    private UserAction userAction;

    public UserActionStaticProxy(UserAction userAction){
        this.userAction = userAction;
    }

    @Override
    public void eat() {
        System.out.println("静态代理eat方法开始");
        userAction.eat();
        System.out.println("静态代理eat方法结束");
    }

    @Override
    public void run() {
        System.out.println("静态代理run方法开始");
        userAction.run();
        System.out.println("静态代理run方法结束");
    }
}

  从上述代码可以看到，我们实现了接口类并定义了一个新的类 UserActionStaticProxy   。然后定义了他的有参构造方法，将接口类传入即可。方法重写的同时加入了方法的监控。

public static void main(String[] args) {
        UserAction userAction = new UserActionStaticProxy(new UserActionImpl());
        userAction.eat();
    }

   在调用的时候，我们可以看到传入了UserActionImpl类去转换为UserAction类（向下转型），而后可以直接调用他的方法即可。运行上述方法以后即执行了 Proxy 类下的eat方法。甚至于我们可以在 Proxy 类下的eat方法调用一次 this.run() 方法，可以自己拼接为自己所想要的方式，有点和策略模式靠近了。（下图是在eat方法中加入了this.run()方法）

        从静态代理模式中可以看出来，如果我们需要代理多个类的话，那么就需要新建对应的接口实现类(Imp.class)和对应的代理类(Proxy,class)。所以实现起来会比较繁琐，因此就应运而生出了动态代理。

       动态代理和静态代理的本质区别其实不是很大，都需要接口以及接口的实现类，动态代理解决了需要重复新增大量的单体代理文件，而是把所有的对象都在一个地方进行了代理，也就是涉及到了JAVA中的反射机制。

      可以看下动态代理的代码：

    

public class LogHandler implements InvocationHandler {

    private Object object;

    public Object newProxyInstance(Object object){
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("动态代理" + method.getName() + "开始");
        Object ret = method.invoke(object,args);
        System.out.println("动态代理" + method.getName() + "结束");
        return ret;
    }
}

  可以看到，动态代理的时候，我们将对象替换成了所有对象的父类------Object类，在代理类的同时，我们通过反射Proxy.newProxyInstance 获取了该类的对象。而后使用了java对应的invoke方法去执行被代理类的方法。

   对应的执行的主方法：    

public static void main(String[] args) {
        UserAction userAction1 = (UserAction)new LogHandler().newProxyInstance(new UserActionImpl());
        userAction1.eat();
    }

   执行的结果：

   因此可以看到，静态代理和动态代理的区在于代理类的区别，静态代理在代码扩容时，每增加一个接口类需要代理，那么就需要新增一个对应的代理类。而动态代理的好处在于需要新增代理接口时，不需要新增代理类，可以直接通过反射的方式调用被代理类。从上述就可以看出，代理的好处就是对方法的增强，可以在方法的前后进行一系列的操作，比如打印日志，验证权限，方法之后可以统一返回格式，统一异常捕获等等......（其实也就是AOP能做的事情）。所以动态代理相比于静态代理最本质的区别就在于我们需要对一个新的接口类代理时，不需要再去增加繁琐的代理类了。

   前文提到，动态代理又分为JDK的动态代理以及CGLIB的动态代理。JDK的动态代理是依据的JAVA强大的反射机制。而CGLIB动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理，也就是说生成被代理类的一个子类将其方法覆盖，以达到代理的目的。

    AOP是会自动切换这两种动态代理的类型的，具体的区别如下：

   1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP 

   2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

   3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

 这里借用别人的CGLIB代码来看下具体的区别

public class UserAction {

    public void eat(){
       System.out.println("CGLIB动态代理吃饭");
    }
}


public class CglibProxy implements MethodInterceptor {
    private Object target;//需要代理的目标对象
    
    //重写拦截方法
    @Override
    public Object intercept(Object obj, Method method, Object[] arr, MethodProxy proxy) throws Throwable {
        System.out.println("Cglib动态代理，监听开始！");
        Object invoke = method.invoke(target, arr);//方法执行，参数：target 目标对象 arr参数数组
        System.out.println("Cglib动态代理，监听结束！");
        return invoke;
    }
    //定义获取代理对象方法
    public Object getCglibProxy(Object objectTarget){
        //为目标对象target赋值
        this.target = objectTarget;
        Enhancer enhancer = new Enhancer();
        //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(objectTarget.getClass());
        enhancer.setCallback(this);// 设置回调 
        Object result = enhancer.create();//创建并返回代理对象
        return result;
    }
    
    public static void main(String[] args) {
        CglibProxy cglib = new CglibProxy();//实例化CglibProxy对象
        UserAction user =  (UserAction) cglib.getCglibProxy(new UserAction());//获取代理对象
        user.eat();//执行方法
    }
    
}

 代码本质上其实和JDK的动态代理的区别并不是很大，而JDK的动态代理是基于接口的，必须要对应接口的实现类才可以实现JDK的动态代理，而CGLIB弥补了这方面的缺点，CGLIB是基于类的继承关系，因此在没有接口的实现下我们可以使用CGLIB去实现动态代理。