jdk动态代理(AOP)从入门到精通（全）

目录

前言

整篇文章的代码源码如下
代码源码

  • 理解什么是动态代理以及动态代理能干什么
  1. 使用jdk的反射机制，创建对象的能力， 创建的是代理类的对象。 而不用你创建类文件。不用写java文件
  2. 动态：在程序执行时，调用jdk提供的方法才能创建代理类的对象
  • 代理类似中介，可以起到一个保护作用而且可以通过代理访问不能访问的目标
  • 动态代理可以做什么？ 可以在不改变原来目标方法功能的前提下， 可以在代理中增强自己的功能代码

比如 发现一个项目中的功能有某个缺点，不能完全满足自我项目的需要，需要添加额外的功能。（GoNong.class , GoNong gn = new GoNong(), gn.print();）
则需要用代理实现 gn.print（）调用时， 增加自己代码， 而不用去改原来的 GoNong文件。
具体的测试案例可以通过博文后面的模板

在这里插入图片描述

补充idea快捷键 改写接口类 ctrl+o

1.了解代理模式

代理模式的定义：
代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。

代理模式的作用：

  1. 功能增强：原有功能添加额外功能
  2. 控制访问： 代理类不让你访问目标

代理模式分类：
有两种模式分别为静态代理和动态代理
1.静态代理：实现简单理解容易，主要通过手工创建一个java类，表示代理类。同时所需要代理的目标类是明确的

例如A类（用户） -B类中介- C类（目标）
具体实现的代码逻辑：

  1. 创建一个接口，定义接口方法，表明B与C类的共同方法
  2. 创建C类，实现接口方法
  3. 创建B类，也就是代理，需要实现接口方法
  4. 创建A类，调用B中介的方法

2.动态代理：

  • 在程序执行过程中，使用jdk的反射机制，创建代理类对象， 并动态的指定要代理目标类（一种创建java对象的能力），不用自我创建B类，就可以自动创建代理类对象
  • 通过反射机制创建对象

2. 静态代理案例

实现步骤：

  1. 创建一个接口，定义卖u盘的方法， 表示你的厂家和商家做的事情。
  2. 创建厂家类，实现1步骤的接口
  3. 创建商家，就是代理，也需要实现1步骤中的接口。
  4. 创建客户端类，调用商家的方法买一个u盘。

用户访问B类（访问A类），而用户不能直接访问A类

接口类

// 表示功能的，厂家，商家都要完成的功能
public interface UsbSell {

    //定义方法 参数 amount:表示一次购买的数量，暂时不用
    //返回值表示一个u盘的价格。
    float sell(int amount);

    //可以多个其它的方法
    //void print();
}

C类目标类的改写接口类方法如下

//目标类： 金士顿厂家, 不接受用户的单独购买。
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        System.out.println("目标类中的方法调用 , UsbKingFactory 中的sell ");
        //一个128G的u盘是 85元。
        //后期根据amount ，可以实现不同的价格，例如10000个，单击是80， 50000个75
        return 85.0f;
    }
}

B类中介改写接口类方法如下
通过代理类中介来实现的接口方法都是

  1. 目标类C类中方法的调用
  2. 功能增强

需要先访问C类，才能给A类

//taobao是一个商家，代理金士顿u盘的销售。
public class TaoBao implements UsbSell {

    //声明 商家代理的厂家具体是谁
    private UsbKingFactory factory = new UsbKingFactory();

    @Override
    //实现销售u盘功能
    public float sell(int amount) {

        //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
        float price = factory.sell(amount); //厂家的价格。
        //商家 需要加价， 也就是代理要增加价格。
        price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
        //在目标类的方法调用后，你做的其它功能，都是增强的意思。
        System.out.println("淘宝商家，给你返一个优惠券，或者红包");

        //增加的价格
        return price;
    }
}

代理测试类

//创建代理的商家taobao对象
TaoBao taoBao = new TaoBao();
//通过代理类，实现购买u盘，增加了优惠券，红包等等
float price = taoBao.sell(1);
System.out.println("通过淘宝的商家，购买u盘单价："+price);

代码案例可以知道静态代理的优缺点
当你的项目中，目标类和代理类很多时候，有以下的缺点：
1）当目标类增加了， 代理类B类可能也需要成倍的增加。 代理类数量过多。
2） 当你的接口中功能增加了 或者修改了，会影响众多的实现类。比如目标C类，代理B类都需要修改。不修改可不行，因为接口的实现类必须都要实现。

3. 动态代理

为了解决静态的缺点，产生了动态代理
当静态代理的目标类C很多的时候，可以使用动态代理
即动态代理的优点是：

  • 代理类很少
  • 修改接口方法，不会影响代理类

动态代理的实现方式有两种：一种是jdk动态代理，一种是cdlib动态代理

  • 所谓jdk动态代理，是使用java反射包中的类和接口实现动态代理的功能。反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy
  • 所谓cdlib动态代理。是通过继承目标类。在子类中重写父类同名方法，实现功能修改（重写的方法不能是final）

3.1 入门案例

正常接口类与接口类的实现逻辑是：
接口类

public interface HelloService {

    // 根 name 打招呼
    public void sayHello(String name);
    //public void sayHello(Integer i);
}

接口实现类

public class HelloServiceImpl  implements HelloService {
    @Override
    public void sayHello(String name) {
        System.out.println("你好："+name);
    }
}

测试类：

public class TestApp {
    public static void main(String[] args){
        HelloService service = new HelloServiceImpl();
        service.sayHello("张三");
        }
}

通过反射机制执行该方法的测试类如下

  • 获取对应类的class对象，获取相应的method对象管理中的方法即可getMethod("方法名", 返回类型.class);该函数返回一个method对象
  • method类中的invoke方法：invoke(对象, 方法执行的参数值);返回值是一个object，invoke需要抛出异常

具体意思是执行method对象类的方法，具体设置该方法的参数

public class TestApp {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//使用反射机制执行sayHello方法。 核心Method（类中的方法）
HelloService target = new HelloServiceImpl();
//获取sayHello名称对于的Method类对象
Method method =  HelloService.class.getMethod("sayHello", String.class);

//通过Method可以执行sayHello方法调用
Object ret = method.invoke(target, "李四");
//表达的意思就是 执行target对象sayHello,参数是李四


	}
}

如果此时有另一个抽象类改写该接口，只需要在测试类下面加一下函数即可

HelloService service2 = new HelloServiceImpl2();
// 执行service2对象method（sayHello）方法，参数是“李四”
Object ret = method.invoke(service2, "李四");

3.2 原理实现

反射包 java.lang.reflect , 里面有三个类 ： InvocationHandler , Method, Proxy

  • InvocationHandler （调用处理器）就一个方法invoke（），表示代理对象要执行的代理类方法。也就是中介类，调用目标方法以及增强其功能

该方法的invoke的原型是public Object invoke(Object proxy, Method method, Object[] args)。
参数：

  1. Object proxy:jdk创建的代理对象，无需赋值。
  2. Method method:目标类中的方法，jdk提供method对象的
  3. Object[] args：目标类中方法的参数， jdk提供的

InvocationHandler 接口：重写具体invoke的方法，表明接口功能：
具体如何调用该方法：

  1. 创建类实现接口InvocationHandler
  2. 重写invoke（）方法， 把原来静态代理中代理类要完成的功能都写在此处
  • Method类：目标类中的方法Method.invoke();为method的方法

该invoke与上面的invoke不同，上方的invoke是接口方法
具体函数调用method.invoke(目标对象，方法的参数)
比如上方的函数Object ret = method.invoke(service2, "李四");
等同于静态代理中的float price = factory.sell(amount); //厂家的价格。

  • Proxy类：核心的对象，创建代理对象。之前创建对象都是 new 类的构造方法()

静态方法 newProxyInstance()
创建代理对象， 等同于静态代理中的TaoBao taoBao = new TaoBao();
该方法函数的原型是public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
参数说明:

  1. ClassLoader loader 类加载器，负责向内存中加载对象的。 使用反射获取对象的ClassLoader。比如类a，a.getCalss().getClassLoader(), 目标对象的类加载器
  2. Class<?>[] interfaces： 接口， 目标对象实现的接口，也是反射获取的
  3. InvocationHandler h : 我们自己写的，代理类要完成的功能
  4. 返回值是代理类对象Object，得到一个目标对象

具体实现动态代理的步骤为：

  1. 创建接口，定义目标类要完成的功能
  2. 创建目标类实现接口
  3. 创建InvocationHandler接口的实现类，在invoke方法中完成代理类的功能（调用目标方法，增强功能）
  4. 使用Proxy类的静态方法，创建代理对象。 并把返回值转为接口类型。

3.3 深层案例

通过结合以上步骤以及原理，实现一个动态代理的案例
接口类

//目标接口
public interface UsbSell {

    float sell(int amount);

    void print();
}

改写接口的目标类

//目标类
public class UsbKingFactory implements UsbSell {
    @Override
    public float sell(int amount) {
        //目标方法
        System.out.println("目标类中，执行sell目标方法");
        return 85.0f;
    }

    @Override
    public void print() {

    }
}

此处与静态代理不同的是，动态代理改写InvocationHandler，实现代理类的功能

  • 创建一个目标对象，而且需要给一个构造函数
//必须实现InvocationHandler接口，完成代理类要做的功能（1.调用目标方法，2.功能增强）
public class MySellHandler implements InvocationHandler {

    private Object target = null;

    //动态代理：目标对象是活动的，不是固定的，需要传入进来。
    //传入是谁，就给谁创建代理。
    public MySellHandler(Object target) {
        //给目标对象赋值
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object res  = null;
        //向厂家发送订单，告诉厂家，我买了u盘，厂家发货
        //float price = factory.sell(amount); //厂家的价格。
        res =  method.invoke(target,args); //执行目标方法



        //商家 需要加价， 也就是代理要增加价格。
        //price = price + 25; //增强功能，代理类在完成目标类方法调用后，增强了功能。
        if( res != null ){
            Float price = (Float)res;
            price = price + 25;
            res = price;
        }

        //在目标类的方法调用后，你做的其它功能，都是增强的意思。
        System.out.println("淘宝商家，给你返一个优惠券，或者红包");
        //记录数据库

        //增加的价格
        return res;

    }
}

具体的测试类

  • 先创建代理对象，使用proxy
  • 以下的创建代理对象是固定的参数
public class MainShop {

    public static void main(String[] args) {
        //创建代理对象，使用Proxy
        //1. 创建目标对象
        // UsbKingFacotry  factory = new UsbKingFactory();
        UsbSell factory = new UsbKingFactory();
        //2.创建InvocationHandler对象
        InvocationHandler handler = new MySellHandler(factory);

        //3.创建代理对象
        UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),
                handler);

        //com.sun.proxy.$Proxy0 : 这是jdk动态代理创建的对象类型。
    	System.out.println("proxy:"+proxy.getClass().getName());
        //4.通过代理执行方法
        float price = proxy.sell(1);
        System.out.println("通过动态代理对象，调用方法："+price);
    }
}

3.4 步骤流程

在这里插入图片描述

动态代理的执行步骤

  1. 创建目标对象，通过接口以及多态
  2. 创建InvocationHandler对象
  3. 创建代理类对象，返回值是一个接口类的目标类对象（获取类的加载器，获取类的接口，InvocationHandler对象），该步骤是固定值
  4. 执行代理类中的方法

具体代码执行的步骤是

  • 通过proxy对象（jdk自带的，他的类是com.sun.proxy.$Proxy0
    通过调用方法传参proxy.sell(1);到invoke中，原型为public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    sell对应该参数中的method，args代表参数为1。此时的sell对应的是接口中的方法参数

  • 通过method类的invoke改写接口，调用该目标类的方法，以及增加额外的功能。具体调用目标类方法为 method.invoke(target,args);。target对应的方法是改写后的接口方法sell

  • 调用改写后的接口sell，得到的返回值为85，在增加额外的功能，变成110.返回110的参数给执行代理的方法

动态代理模板

  1. 创建目标对象 接口类 接口对象 =new 接口实现类();
  2. 创建InvocationHandler对象InvocationHandler handler = new MySellHandler(接口类对象);
  3. 创建代理对象接口类 proxy = (接口类) Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(),handler);
  4. 通过代理执行方法proxy.方法();

具体代码案例：

//1. 创建目标对象
// UsbKingFacotry  factory = new UsbKingFactory();
UsbSell factory = new UsbKingFactory();
//2.创建InvocationHandler对象
InvocationHandler handler = new MySellHandler(factory);

//3.创建代理对象
UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
        factory.getClass().getInterfaces(),
        handler);

//com.sun.proxy.$Proxy0 : 这是jdk动态代理创建的对象类型。
System.out.println("proxy:"+proxy.getClass().getName());
//4.通过代理执行方法
float price = proxy.sell(1);

4. 模板总结

通过案例来加深模板印象

接口类

public interface HelloService {

    //打印报告， 报表
    int print(String name);
}

接口实现类

public class GoNeng implements HelloService {
    @Override
    public int print(String name) {
        System.out.println("其它人写好的个功能方法");
        return 2;
    }
}

改写InvocationHandler代理类

public class MyInvocationHandler implements InvocationHandler {

    private Object target = null;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //调用目标方法， 执行print()得到 2
        Object res = method.invoke(target,args); //2
        //需要乘以 2的结果
        if( res != null){
            Integer num = (Integer)res;
            res = num * 2;
        }

        return res;
    }
}

测试接口类

public class MyApp {

    public static void main(String[] args) {
       // GoNeng gn = new GoNeng();
        //int num = gn.print("销售");
       // System.out.println("num="+num);

        GoNeng goNeng = new GoNeng();
        InvocationHandler handler = new MyInvocationHandler(goNeng);

        System.out.println("goNeng.getClass().getInterfaces()="+goNeng.getClass().getInterfaces()[0].getName());
        HelloService proxy = (HelloService) Proxy.newProxyInstance( goNeng.getClass().getClassLoader(),
                goNeng.getClass().getInterfaces(),handler);

        int num = proxy.print("市场");
        System.out.println("我们期望的 num ==" + num);

    }
}
版权声明：本文为weixin_47872288原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。