一、代理模式

代理模式是一种比较好的理解的设计模式。简单来说就是 ：

1. 我们使用代理对象来增强目标对象(target obiect)，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
2. 将核心业务代码和非核心的公共代码分离解耦，提高代码可维护性，让被代理类专注业务降低代码复杂度。
   通常用代理实现比如拦截器，事务控制,还有测试框架 mock、用户鉴权、日志、全局异常处理等功能

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。
举个例子:客户找老板， 让秘书登记来访人员和时间， 记录来访用时，并且让秘书拒绝老板不想见的客户。 秘书充当代理角色。

二、静态代理

弊端：
静态代理中，我们对目标对象的每个方法的增强都是手动完成的(后面会具体演示代码)，非常不灵活(比如接口一旦新增加方法，目标对象和代理对象都要进行修改》且麻烦(需要对每个目标类都单独写一个代理类)。 实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

上面我们是从实现和应用角度来说的静态代理，从JVM 层面来说，静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

静态代理实现步骤:

1.定义一个接口及其实现类
2.创建一个代理类同样实现这个接口
3.将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

2.1 接口

public interface ISEO {
    // 接见
     void meeting();
}

2.2 定义接口实现类（目标类）

老板： 只要负责和客户谈项目

public class CEO implements  ISEO {
    // 会见
    @Override
    public void meeting()
    {
        System.out.println("和"+name+"谈成了34个亿的合作项目：给河道贴瓷砖！");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    // ..出差
    // ..

    // 客户名字
    private String name="";

    public CEO(String name) {
        this.name = name;
    }

}

2.3 创建代理类（同样实现接口）

public class CEOProxy implements ISEO  {
    // 目标类
    private ISEO ceo;
   @Override
    public void meeting() {

        System.out.println("秘书登记来访："+name+ LocalDateTime.now().toString());
        
        if(name.equals("徐庶")) {
            // 开始时间
            Date sdate = new Date();

            // 调用目标类方法
            ceo.meeting();

            // 结束时间
            Date edate = new Date();
            //  统计执行时间（毫秒）
            System.out.printf("会谈时间：%d 毫秒.", (edate.getTime() - sdate.getTime()));
        }
    }

    // 无法动态代理其他方法
    //


    private String name;
    public CEOProxy(String name) {
        this.name=name;
        this.ceo=new CEO(name);
    }

}

2.4 实际使用

public class MainTest  {

    @Test
    public void test(){
        // CTO
        ISEO proxy=new CEOProxy("徐庶");
        proxy.meeting();
    }
}

三、动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制）。

从JVM 角度来说，动态代理是在运行时动态生成类宁节码，并加载到JVM 中的。

说到动态代理，Spring AOP、RPC 框架应该是两个不得不的提的，它们的实现都依赖了动态代理。

动态代理在我们日常开发中使用的相对较小，但是在框架中的几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。

就 Java 来说，动态代理的实现方式有很多种，主流的： JDK 动态代理、CGLIB 动态代理等等。

我们这里还是简单个绍一下其使用以及和JDK 动态代理的对比。

3.1 JDK动态代理机制

在 Java 动态代理机制中InvocationHandler 接口和 Proxy 类是核心。
Proxy 类中使用频率最高的方法是: newProxyInstance()，Proxy.这个方法主要用来生成一个代理对象。

这个方法一共有 3 个参数:
1.loader :类加载器，用于加载代理对象
2.interfaces: 被代理类实现的一些接口;
3.h:实现了 InvocationHandler 接口的对象:

要实现动态代理的话，还必须需要实现 InvocationHandler 来自定义处理逻辑。当我们的动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现 InvocationHandler 接口类的 invoke 方法来调用。

invoke() 方法有下面三个参数:

1.proxy :动态生成的代理类
2.method:与代理类对象调用的方法相对应
3.args: 当前 method 方法的参数

也就是说: 你通过 Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现 InvocationHandler 接口的类的 invoke() 方法。你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

JDK 动态代理类使用步骤

1.定义一个接口及其实现类;
2.自定义 InvocationHandler 并重写 invoke 方法，在 invoke 方法中我们会调用原生方法 (被代理类的方法)并自定义一些处理逻辑；
3.通过 Proxy.newProxyInstance(ClassLoader loader，Class<?>[] interfaces,InvocationHandler h)方法创建代理对象

1.定义接口

public interface IDao {
    public void select();

}

2.定义接口

public class Dao implements IDao{

    @Override
    public void select() {
        insert();
        System.out.println("-----select-----");
    }

    public void insert() {
         System.out.println("-----insert-----");
    }

    public final void delete() {
        System.out.println("delete from ...");
    }
}

3.定义？JDK动态代理类

public class DaoJdkProxy implements InvocationHandler {


    private  Object targetObject;
    public DaoJdkProxy(Object target) {
         this.targetObject=target;
    }

    public DaoJdkProxy() {
    }

    // 代理所有方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //System.out.println("proxy.....");
        // 开启事务  ...
        // 记录开始
        // 调用目标方法
       return method.invoke(targetObject, args);
        //  记录结束时间

        //
    }
}

invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。
5. 具体使用

 public static void main(String[] args) {
        //将生成的代理类文件存到项目根目录
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

        IDao dao =(IDao) Proxy.newProxyInstance(
                    Dao.class.getClassLoader(),        // 代理类加载器
                    Dao.class.getInterfaces(),         // 代理的接口
                    new DaoJdkProxy(new Dao())         // 代理处理类
        );

        System.out.println(dao.getClass().getName());
        dao.select();
       /* 
        耗时测试
       long l = System.currentTimeMillis();
        for (int i=0;i<999999999;i++){
            dao.select();
        }
        long e = System.currentTimeMillis();

        // 3696
        System.out.println(e-l);*/
    }
}

通过 Proxy.newProxyInstance() 方法获取某个类的代理对象

3.2 CGLIB动态代理

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB，例如 Spring 中的AOP 模块中: 如果目标对象实现了接口，则默认采用JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer是核心。

你需要自定义 MethodInterceptor 并重写 intercept 方法， intercept 用于拦截增强被代理类的方法。

1.obj:被代理的对象(需要增强的对象)
2.method :被拦截的方法 (需要增强的方法）
3.args:方法入参
4.methodProxy :用于调用原始方法

你可以通过 Enhancer 类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

CGLIB 动态代理类使用步骤

1.定义一个类;
2.自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和JDK 动态代理中的 invoke 方法类似;
3.通过 Enhancer 类的 create()创建代理类

不同于JDK 动态代理不需要额外的依赖。CGLIB(Code Generation Library) 实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖 （Spring AOP会自动添加依赖不需要我们关心）。

<!--CGLib动态代理-->
<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.1</version>
</dependency>

1.依然使用之前的Dao类作为目标类
2. 自定义MethodInterceptor（方法拦截器）

public class CglibProxy implements MethodInterceptor {

    // 传入被代理目标类Class
    public CglibProxy(Class<?> target) {
        this.target = target;
    }

    public CglibProxy() {
    }

    Class<?> target;

    // obj是生成的代理后的子类  ，
    // method是调用的方法 ，args是方法入参 ，
    // proxy是MethodProxy代理对象   要理解cglib ， 重点了解MethodProxy
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {



        System.out.println("begin intercept");
        //  这样就直接调用具体方法
        //  proxy.invoke(target.newInstance(),args);

        //invokeSuper 会通过FastClass, 也就是调用本类方法会再次代理
        proxy.invokeSuper(obj, args);


        //System.out.println(obj.getClass());
        //Spring直接执行的责任链调用，  相当于
        System.out.println("end intercept");
        return obj;
    }
}

3.具体使用

public class Client {
    public static void main(String[] args) {


        //将生成的代理类文件存到项目根目录
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./");
        //实例化增强器
        Enhancer enhancer = new Enhancer();
        //设置需要代理的目标类
        enhancer.setSuperclass(Dao.class);
        //enhancer.setInterfaces(new Class[]{IDao.class});
        //设置拦截对象 回调的实现类
        enhancer.setCallback(new CglibProxy(Dao.class));
        //使用create 返回Object 生成代理类并返回实例
        Dao dao = (Dao) enhancer.create();
        //select优先级高 使用DaoProxy

        System.out.println(dao.getClass().getName());
        /*
        测试耗时*/
        /* long l = System.currentTimeMillis();
        for (int i=0;i<999999999;i++){
            dao.select();
        }
        long e = System.currentTimeMillis();
        // 4777 3696
        System.out.println(e-l);*/

        //无法代理被final修饰的方法
        //dao.delete();
        dao.select();

    }
}

3.2、JDK 动态代理和 CGLIB 动态代理对比

1.JDK 动态代理只能只能代理实现了接口的类，
而 CGLIB 可以代理未实现任何接口的类。
另外CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final 类型的类和方法。
所以可以根据是否实现接口选择JDK或CGLIB, 但是用Spring AOP来实现的话， 无需关心底层会自动根据被代理目标类是否实现接口自动选择JDK或CGLIB，

但是SpringBoot2.x 后默认是使用CgLib作为默认的动态代理实现， 为什么呢？想知道的同学点点赞，赞超过100后续给大家更新

2.就二者的效率来说：
● 代理类生成阶段：
Jdk由于只需生成$proxy 一个代理类， 而Cglib需要生成多个代理相关class， 所以jdk更胜一筹。
● 调用阶段
jdk通过反射、cglib通过fastclass对代理的方法生成索引，然后通过调用父类的方式直接调用。
在jdk1.8之前反射的性能不佳， cglib完胜， 在jdk1.8后对反射性能做了优化、加入了缓存等，所以不分伯仲（可以自己去执行下我代码中的耗时测试，执行10亿次，耗时相差不大）。

四、静态代理和动态代理的对比

1.灵活性:动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的!

2.JVM 层面:静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到JVM 中的。

动态代理技术对于一个经常写开源或是中间件的人来说，是一个神器。这种特性提供了一种新的解决方式。从而使得代码更加优雅而简单。

五、总结

这篇文章中主要介绍了代理模式的两种实现: 静态代理以及动态代理。涵盖了静态代理和动态代理实战静态代理和动态代理的区别、JDK 动态代理和 Cglib 动态代理区别等内容。

文章就写到这里，这个还有配套代码，需要可以加文末方式取！