jdk动态代理详解(通俗易懂,5分钟带你快速理解动态代理)全网最简

相信很多小伙伴都不理解动态代理,
它是怎么代理的?怎么用?听了很多课程还是不会
我这次用最简单通俗易懂的代码来解释jdk动态代理,希望各位小伙伴能听懂,喜欢就点个赞在走吧!

活不多说,直接上代码.
第一种: 最简代码(需要会lambda,反射知识才能看懂)

public static void main(String[] args) { //主方法
    ClacInterface myClac = new MyClac(); //被代理的对象
    //生成了一个代理类对象proxyBean
    ClacInterface proxyBean = (ClacInterface)Proxy.newProxyInstance(
         //第一个参数被代理类的类加载器
          myClac.getClass().getClassLoader(), 
          //第二个参数myClac的所以实现接口
          myClac.getClass().getInterfaces(),
          //第三参数是InvocationHandler 这里是lambda简化的匿名内部类写法
          (a, b, c) -> {
              System.out.println("我代理了myClac对象");
              return b.invoke(myClac, c);
            } );
     System.out.println("proxyBean.add(1, 3) = " + proxyBean.add(1, 3));
  }

输出结果:

接口

pulic interface ClacInterface {
   int add(int a ,int b );
}

实现类

public class MyClac implements ClacInterface{
  @Override
  public int add(int a, int b) {
    System.out.println("a+b"+"="+(a+b));
    return a+b;
  }
}

使用动态代理的目的: 增强代理对象的方法
上面的代码就实现了动态代理, 通过jdkProxy类生成了一个proxyBean(这个对象就是代理对象)
然后执行了被代理对象MyClac中的方法.
这也就是动态代理,运行时生成了一个代理对象!

哈哈,可能很多小伙伴看到这是一脸懵逼,我把上面代码都详细解释和改造成第二版

第二版(详细解释每一步具体意思)

public static void main(String[] args) {
    //创建接口的实现类对象,也就是被代理对象
    ClacInterface myClac = new MyClac();
    //获取被代理实现类对象的Class对象
    Class<? extends ClacInterface> clazz = myClac.getClass();
    //第一个参数,被代理对象的类加载器
    ClassLoader classLoader = clazz.getClassLoader();
    //第二个参数,被代理对象实现的所有接口数组
    Class<?>[] interfaces = clazz.getInterfaces();
    //通过调用Proxy.newProxyInstance的方法来创建一个代理类对象来代理myClac对象
    ClacInterface proxyBean = (ClacInterface)Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
      //第三个参数InvocationHandler的实现类,这里用了匿名内部类的方式
      @Override
      //重写InvocationHandler的invoke方法,他有三个参数可以供我们使用
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //第一个参数proxy 可以通过proxy.getClass().getClassName() 来查看对象,是一个匿名的Proxy的代理类
        System.out.println("proxy.getClass().getName() = " + proxy.getClass().getName());
        System.out.println("前置增强------");
        //第二个参数method 也就是被代理对象myClac对象的方法,可以通过method调用myClac的方法
        //第三个参数args 也就是MyClac方法执行时传入的实际参数
        //method.invoke的返回值就是myClac方法的返回值
        Object invoke = method.invoke(myClac, args);
        System.out.println("后置增强------");
        return invoke;
      }
    });
    System.out.println("proxyBean.add(1, 3) = " + proxyBean.add(1, 3));
  }

输出结果

到这里,我觉得很多小伙伴可能已经理解了动态代理代码怎么实现,也有可能是一脸懵,所以我在文末总结了下jdk动态代理:

java反射包中的Proxy类可以调用newProxyInstance创建一个代理类对象.
传入三个参数,
一个是代理类的类加载器,
一个是实现的所有接口数组,
一个调用处理器的实现类.
创建好了代理对象,代理对象就可以执行被代理类实现的接口的方法,在执行方法时,会先去执行调用处理器实现类中的invoke方法,invoke方法就可以对被代理类进行功能增强.