栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【Spring笔记07】Spring中AOP的动态代理介绍

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【Spring笔记07】Spring中AOP的动态代理介绍

这篇文章,主要介绍一下动态代理模式,以及Spring框架中AOP采用的两种动态代理技术,分别是:JDK动态代理、CGLIB的动态代理。

目录

一、两种代理模式介绍

1.1、代理模式

1.2、静态代理

(1)创建抽象角色接口

(2)创建目标角色类

(3)创建代理角色类

(4)测试程序

1.3、动态代理

二、两种动态代理

2.1、JDK动态代理

(1)创建抽象角色接口

(2)创建具体角色类

(3)自定义InvocationHandler实现类

(4)创建代理工厂方法

(5)测试JDK动态代理

2.2、CGLIB动态代理

(1)创建目标类

(2)创建拦截器【代理逻辑】

(3)通过CGLIB创建代理对象

三、两种动态代理区别

四、Spring中动态代理


一、两种代理模式介绍

前一篇文章,介绍了Spring AOP的一些基础知识,我们说AOP底层是通过动态代理技术实现的,那么到底什么是动态代理技术呢???要理解动态代理,我们首先需要知道什么是代理,也就是我们说的代理模式,下面介绍一下代理模式。

1.1、代理模式

代理模式,是23种设计模式当中的一种,可以将代理模式理解为:找一个中间对象替我们完成一些目标功能。

举个栗子:

假设我们要买房子,那么我们就需要去到处找房子,找到房子之后,还需要办理一些手续,可以看到,这个过程可能非常的浪费时间,并且还不一定能找到满意的,如果我们想轻松一点,那么就可以找一个中间人替我们去找房子,找到房子之后,我们再去看是否满意这个房子,如果满意的话,我们就可以让这个中间人替我们安排那些手续,我们只要付钱就可以啦,这个过程是不是就感觉非常轻松呢,也不会浪费我们的时间,我们把这种方式,就叫做:代理模式。

这里的房子就是我们要找的目标对象,这个中间人就是我们的代理对象,我们通过代理对象去完成一些事情,而不需要知道代理是如何完成的,我们的目的就是要一个结果,至于过程如何,不需要我们关心。

代理模式中存在三个核心角色,分别如下:

  • 抽象角色(对象)
  • 目标角色(对象)
  • 代理角色(对象)

代理模式大致关系图如下所示:

 代理模式又分为两类,分别是:静态代理和动态代理。

下面详细介绍一下这两种代理模式的区别以及代码实现。

1.2、静态代理

静态代理,所谓的静态代理就是代理对象类是我们开发人员自己编写的,并且在编译之后,代理对象和目标对象就确定了代理关系,我们把这种发生在编译期间的代理称为:静态代理模式。

下面通过一个代理模式的具体代码,更加深入的了解一下静态代理。

(1)创建抽象角色接口
public interface AbstractInterface {
    
    void buyHouse();
}

(2)创建目标角色类
public class Target implements AbstractInterface {
    @Override
    public void buyHouse() {
        System.out.println("Target: 目标对象购买房子成功......");
    }
}

(3)创建代理角色类
public class Proxy implements AbstractInterface {
    
    private Target target;

    public Proxy(Target target) {
        this.target = target;
    }

    @Override
    public void buyHouse() {
        System.out.println("Proxy: 找代理对象帮我去购买房子......");
        target.buyHouse();
        System.out.println("Proxy: 代理对象帮我把房子购买好了......");
    }
}

(4)测试程序
public class TestProxy {
    public static void main(String[] args) {
        // 1、创建目标对象
        Target target = new Target();
        // 2、创建代理对象
        Proxy proxy = new Proxy(target);
        // 3、通过代理对象调用目标对象方法
        proxy.buyHouse();
    }
}

运行上面的程序,查看控制台输出结果如下所示。

通过输出结果,可以看到代理对象以及替我们完成了目标对象的访问,并且还添加了额外的功能(输出了一些信息),实际开发过程中,我们就可以在代理类方法里面,增加我们需要的业务逻辑,比如:添加日志打印,添加事务管理等等。

1.3、动态代理

从【1.2】部分可以看到静态代理有一个缺点,就是静态代理每次只能代理一种类型,如果我们新增一个类型的功能,那么此时就需要自己编写一个新的代理类,这样显然是不合适的,因为如果一个项目里面有几百个几千个功能需要采用代理,那么此时就需要编写几百个几千个代理类,这很明显不利于代码的维护。

那有什么方式可以解决这个问题呢???能不能代理类不用我们自己写,而是让系统自动给我们创建代理类以及代理对象呢???从这一点去考虑,我们就可以引入动态代理的概念。

什么是动态代理呢???

动态代理:说白了就是为了简化静态代理,让程序在运行的过程中自动的帮助我们创建相应的代理类对象,而不用开发人员自己新增代理类,这样就可以减少很多代码的编写,利于维护。

  • 动态代理的优点:代理对象不能开发人员创建,减少代码量,利于代码维护。
  • 动态代理的缺点:动态代理需要在程序运行过程中生成代理对象,所以运行效率没有静态代理好。

动态代理如何实现的呢???

既然代理类都不用我们开发人员自己创建了,那么在使用代理对象的时候,程序要如何获取到代理对象呢???这时候,就有个问题需要解决啦,那就是如何获取代理对象???

我们可以想一下,当我们使用对象的时候,一般都是通过【new】关键字进行创建对象,创建完成之后,我们就可以利用这个对象去调用相应的方法,但是现在我们都没有创建代理类,那就没有办法去创建代理对象,那怎么办???这个时候我们就要想到一个技术了,那就是反射机制。

动态代理有两种常见的实现方式,分别是:JDK动态代理、CGLIB动态代理。下面介绍一下两种动态代理技术。

二、两种动态代理

2.1、JDK动态代理

Java编程语言的JDK开发工具包里面已经给我们提供了一种动态代理实现方式,我们称为:JDK动态代理。

JDK动态代理

  • JDK动态代理是基于接口的代理,也就是说,被代理的类(目标对象类)必须实现某个接口,否则无法采用JDK动态代理技术。

下面看下如何使用JDK动态代理。

 JDK动态代理案例代码。

(1)创建抽象角色接口
public interface AbstractInterface {
    
    void buyHouse();
}

(2)创建具体角色类
public class Target implements AbstractInterface {
    @Override
    public void buyHouse() {
        System.out.println("Target: 目标对象购买房子成功......");
    }
}

(3)自定义InvocationHandler实现类
public class CustomInvocationHandler implements InvocationHandler {
    
    private Object target;

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

    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // proxy: 代理对象
        // method: 目标对象的方法
        // args: 目标方法的参数
        System.out.println("Proxy: 找代理对象帮我去购买房子......");
        // 通过反射机制调用方法
        Object ret = method.invoke(target, args);
        System.out.println("Proxy: 代理对象帮我把房子购买好了......");
        // 返回方法参数
        return ret;
    }
}

(4)创建代理工厂方法
public class ProxyFactory {

    
    public static Object getProxyInstance(Object target) {
        // 类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        // 接口类型
        Class[] interfaces = target.getClass().getInterfaces();
        // 动态代理具体执行的逻辑
        InvocationHandler invocationHandler = new CustomInvocationHandler(target);
        // 通过JDK提供的方法执生成代理对象
        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }

}

(5)测试JDK动态代理
public class TestProxy {
    public static void main(String[] args) {
        // 1、创建目标对象
        AbstractInterface target = new Target();
        // 2、创建代理对象
        AbstractInterface proxy = (AbstractInterface) ProxyFactory.getProxyInstance(target);
        // 3、通过代理对象调用方法
        proxy.buyHouse();
    }
}

运行上面测试程序,控制台可以查看到对应的输出结果。

 以上,就是JDK提供的动态代理,唯一条件是:被代理的类必须实现了某个接口,否则无法使用JDK动态代理。

2.2、CGLIB动态代理

JDK动态代理有一个缺点,那就是要求被代理的类必须实现接口,没有接口就没有办法使用JDK动态代理,为了解决JDK动态代理的缺点,我们可以利用CGLIB动态代理。

什么是CGLIB???

CGLIB,代码生成类库(Code Generation Library)。CGLIB就是利用ASM框架操作字节码文件,根据目标对象的字节码内容,生成一份新的字节码文件,也就是我们说的代理类字节码文件,然后我们在代理类字节码文件中添加一些额外的功能,从而实现了动态代理的功能。

  • CGLIB动态代理,是基于继承的代理方式,也就是说被代理的类必须能够被继承,否则CGLIB无法生成一个子类,也就无法实现代理逻辑。(即:类不能是final修饰的,CGLIB会重写所有不是final修饰的方法。)

CGLIB动态代理大致思想如下图所示:

 下面看下如何使用CGLIB完成动态代理。

注意:这里我是基于Spring的依赖编写的测试类,Spring框架中已经引入了CGLIB相关依赖,所以就不用重复引入;如果是普通的Java工程,那么就需要单独引入CGLIB的依赖。

(1)创建目标类
public class Target {

    
    public void buHouse() {
        System.out.println("Target: 目标对象购买房子成功......");
    }

}

(2)创建拦截器【代理逻辑】

拦截器的作用就是拦截到目标对象,然后添加一些额外的功能,再去调用目标方法。

public class CustomInterceptor implements MethodInterceptor {

    
    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // object: 目标对象
        // method: 目标对象方法
        // args: 目标方法的参数
        // methodProxy: cglib生成的代理对象
        System.out.println("CustomInterceptor: 通过CGLIB动态代理调用目标对象......");
        // 通过 cglib 生成的代理对象去调用目标对象方法
        Object ret = methodProxy.invokeSuper(object, args);
        System.out.println("CustomInterceptor: 通过CGLIB动态代理调用目标对象结束......");
        // 返回方法返回值
        return ret;
    }

}

(3)通过CGLIB创建代理对象
public class TestCglib {
    public static void main(String[] args) {
        // 1、创建 cglib 对象
        Enhancer enhancer = new Enhancer();
        // 2、设置代理对象的父类
        enhancer.setSuperclass(Target.class);
        // 3、设置代理对象的回调方法逻辑【增强逻辑】
        enhancer.setCallback(new CustomInterceptor());
        // 4、创建代理对象
        Target proxy = (Target) enhancer.create();
        // 5、通过代理对象调用方法
        proxy.buHouse();
    }
}

运行CGLIB测试程序,控制台可以查看到输出结果。

以上,就是通过CGLIB完成了动态代理的逻辑。

三、两种动态代理区别

JDK动态代理

  • 基于【接口】的代理,被代理的类必须实现接口。
  • 基于【反射机制】实现代理逻辑的调用。

CGLIB动态代理

  • 基于【继承】的代理,被代理的类必须能够被继承,也就是不能是【final】修饰的类。
  • 基于【ASM】操作字节码的方式实现代理逻辑的调用。
  • CGLIB不能对【final】修饰的方法进行代理。

四、Spring中动态代理

Spring首先会判断是否显式的指定采用JDK代理方式,如果指定了采用JDK代理方式,那就直接采用JDK代理方式。如果没有指定JDK动态代理方式,那么Spring就会判断被代理的类是否存在接口,如果被代理的target类存在接口,那么Spring框架就会采用JDK动态代理;如果被代理的target类没有接口,那么Spring框架就会采用CGLIB动态代理生成代理对象,下面我们来看下Spring动态代理的源码。

Spring中AOP就是基于动态代理实现,所以我们看下AOP的底层源码,就知道Spring是如何选择哪种代理方式的了。

  • Spring中AOP是在【DefaultAopProxyFactory】类里面进行判断选择哪种代理方式,源代码如下所示:
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    public DefaultAopProxyFactory() {
    }

	// 创建AOP代理对象
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// isOptimize: 标识是否显式采用JDK代理
		// isProxyTargetClass: 标识是否显式采用JDK代理
		// hasNoUserSuppliedProxyInterfaces: 判断是否提供代理接口
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
			// 都满足,则采用JDK代理
            return new JdkDynamicAopProxy(config);
        } else {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
				// 判断是否存在接口, 存在则采用JDK代理
				// 不存在接口, 则采用CGLIB代理
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }

    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class[] ifcs = config.getProxiedInterfaces();
        return ifcs.length == 0 || ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]);
    }
}

以上,就是Spring中AOP动态代理相关的介绍。

综上,这篇文章介绍完了,主要介绍一下动态代理模式,以及Spring框架中AOP采用的两种动态代理技术,分别是:JDK动态代理、CGLIB的动态代理。

【源代码地址:https://gitee.com/zhuyoubin/ssm_code/tree/master/spring/spring-demo07】

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936128.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号