动态代理实现AOP-反射的应用

最新推荐文章于 2023-03-09 16:33:49 发布

不专业得Cook

最新推荐文章于 2023-03-09 16:33:49 发布

阅读量951

点赞数

分类专栏：【Java】 -----【Java 基础】

本文链接：https://blog.csdn.net/r_s_x/article/details/100670643

版权

【Java】同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

-----【Java 基础】

6 篇文章 0 订阅

订阅专栏

文章目录

- - invoke方法

反射应用

要理解AOP需要这么几个步骤：
反射——invoke（）——代理——AOP。
在上一篇已经介绍了基础的反射是什么，和常见的API是如何使用的在此基础上，说明一下invoke（）方法的使用。

invoke方法

invoke方法用于调用运行时类的指定结构。

通过Class类的getMethod（String name，Class…parameterTypes）方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
使用Object invoke（Object obj，Object[] args）进行调用，并向方法中传递要设置的obj对象的参数信息。

在这里插入图片描述

Object invoke（Object obj，Object[] args）说明

Object对应原方法的返回值，若原方法无返回值，此时返回null
若原方法为静态方法，此时形参Object obj可为null
若原方法形参列表为空，则Object[] args为null
若原方法声明为private，则需要在此调用此invoke（）方法前，显示调用方法对象的setAccessible（true）方法，将可访问private的方法。

AOP

代理分为静态代理和动态代理。动态代理一般有两种方式实现，基于JDK和Cglib的实现。我们所说的AOP是使用动态代理实现的。
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP最直观的效果是在不改变当前代码的前提下，动态的添加自己想要实现的效果，非常强大。

AOP是用来解决某些特定问题的，AOP关注的是系统的“截面”，在适当的时候“拦截”程序的执行流程，把程序的预处理和后期处理交给某个拦截器来完成。例如，访问数据库时需要记录日志，如果使用AOP的编程思想，那么在处理业务流程时不必在去考虑记录日志，而是把它交给一个专门的例子记录模块去完成。这样，程序员就可以集中精力去处理业务流程，而不是在实现业务代码时嵌入日志记录代码，实现业务代码与非业务代码的分别维护。在AOP术语中，这称为关注点分离。AOP的常见应用有日志拦截、授权认证、数据库的事务拦截和数据审计等。

下面用JDK动态代理实现一个简单的AOP示例。

实现示例

JDK和Cglib的区别

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokerHandler来处理。
而Cglib动态代理是利用asm开源包，对代理对象的class文件加载进来，通过修改其字节码生成子类处理。

如果目标对象实现了接口，默认情况下采用JDK的动态代理实现AOP
如果目标对象实现了接口，可以强制使用Cglib实现AOP
如果目标对象没有实现接口，必须采用Cglib库，spring会自动在JDK动态代理和Cglib之间转换

JDK动态代理和Cglib字节码生成的区别：

JDK动态代理只能对实现了接口的类生成代理，而不能针对类
Cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
因此是继承，在该类或方法中最好不要使用final。

静态代理

首先实现一个静态代理。通过静态代理与动态代理的比较可以更直观的认识动态代理带来的好处与优点。
静态代理是代理类和被代理类在编译期间就已经被确定下来了。

/**
 * 静态代理举例
 *
 * 特点：代理类和被代理类在编译期间，就确定下来了。
 */
interface ClothFactory{

    void produceCloth();

}

//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;//用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");

        factory.produceCloth();

        System.out.println("代理工厂做一些后续的收尾工作");

    }
}

//被代理类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();

    }
}

代理工厂做一些准备工作
Nike工厂生产一批运动服
代理工厂做一些后续的收尾工作

动态代理（JDK）

要先思考两个问题：
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。

被代理的类

interface Human{

    void getBelief();

    void eat(String food);

}
//被代理类
class SuperMan implements Human{


    @Override
    public void getBelief() {
        System.out.println("I'm sure I'll see you again!");
    }

    @Override
    public void eat(String food) {
        System.out.println("我还是喜欢吃" + food);
    }
}

想要增强的动作

class HumanUtil{

  public void methodOne(){
        System.out.println("嗨，好久不见啊");

    }

    public void methodTwo(){
        System.out.println("你还好吗");
    }

}

创建代理工厂

class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }

}

实现InvocationHandler

class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值

    public void bind(Object obj){
        this.obj = obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

       HumanUtil util = new HumanUtil();
        util.methodOne();

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj,args);

        util.methodTwo();

        //上述方法的返回值就作为当前类中的invoke()的返回值。
        return returnValue;

    }
}

测试

public class ProxyTest {

    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        proxyInstance.getBelief();
        proxyInstance.eat("三汁焖锅");

    }
}

输出结果：

嗨，好久不见啊
I'm sure I'll see you again!
你还好吗
嗨，好久不见啊
我还是喜欢吃三汁焖锅
你还好吗

感谢大佬们：
https://www.cnblogs.com/leifei/p/8263448.html
https://blog.csdn.net/q982151756/article/details/80513340

不专业得Cook

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
动态代理实现AOP-反射的应用

要理解AOP需要这么几个步骤：反射——invoke（）——代理——AOP。在上一篇已经介绍了基础的反射是什么，和常见的API是如何使用的在此基础上，说明一下invoke（）方法的使用。invoke方法invoke方法用于调用运行时类的指定结构。通过Class类的getMethod（String name，Class…parameterTypes）方法取得一个Method对象，并设置此方...
复制链接

扫一扫