Spring AOP

最新推荐文章于 2024-08-10 06:00:00 发布

地球魔

最新推荐文章于 2024-08-10 06:00:00 发布

阅读量61

点赞数

CC 4.0 BY-SA版权

文章标签： spring 代理模式 java

本文链接：https://blog.youkuaiyun.com/diskindom/article/details/133098597

Spring AOP

在这里插入图片描述

一、代理模式

代理模式在 Java 开发中是⼀种⽐较常⻅的设计模式。设计⽬的旨在为服务类与客⼾类之间插⼊其他功能，插⼊的功能对于调⽤者是透明的，起到伪装控制的作⽤。如租房的例⼦：房客、中介、房东。对应于代理模式中即：客⼾类、代理类、委托类（被代理类）。

为某⼀个对象（委托类）提供⼀个代理（代理类），⽤来控制对这个对象的访问。

委托类和代理类有⼀个共同的⽗类或⽗接⼝。

代理类会对请求做预处理、过滤，将请求分配给指定对象。

代理模式的两个设计原则：

代理类与委托类具有相似的⾏为（共同）
代理类增强委托类的⾏为

在这里插入图片描述

常⽤的代理模式：

静态代理
动态代理

二、静态代理

某个对象提供⼀个代理，代理⻆⾊固定，以控制对这个对象的访问。

代理类和委托类有共同的⽗类或⽗接⼝，这样在任何使⽤委托类对象的地⽅都可以⽤代理对象替代。

代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执⾏完请求后的后续处理。

1.代理的三要素

有共同的⾏为（结婚） - 接⼝
⽬标⻆⾊（新⼈） - 实现⾏为
代理⻆⾊（婚庆公司） - 实现⾏为增强⽬标对象⾏为

2.静态代理的特点

⽬标⻆⾊固定
在应⽤程序执⾏前就得到⽬标⻆⾊
代理对象会增强⽬标对象的⾏为
有可能存在多个代理引起"类爆炸"（缺点）

3.静态代理的实现

定义⾏为（共同）定义接⼝

/**
 * 定义接口 - 定义行为
 */
public interface Marry {

    public void toMarry();

}

⽬标对象（实现⾏为）

/**
 * 静态代理 -> 目标角色（真实角色）
 *      实现行为
 */
public class You implements Marry {
    // 实现行为
    @Override
    public void toMarry() {
        System.out.println("我要结婚了...");
    }
}

代理对象（实现⾏为、增强⽬标对象的⾏为）

/**
 * 静态代理 -> 代理角色
 *      1. 实现行为
 *      2. 增强用户行为
 */
public class MarryCompanyProxy implements Marry {

    // 目标对象
    private Marry target;
    // 通过带参构造器传递目标对象
    public MarryCompanyProxy(Marry target) {
        this.target = target;
    }

    // 实现行为
    @Override
    public void toMarry() {

        // 用户行为增强
        before();

        // 调用目标对象中的方法
        target.toMarry();

        // 用户行为增强
        after();

    }

    @Override
    public String toMarry02() {
        return null;
    }

    /**
     * 用户行为增强
     */
    private void after() {
        System.out.println("新婚快乐，百年好合！");
    }

    /**
     * 用户行为增强
     */
    private void before() {
        System.out.println("婚礼现场正在布置中...");
    }
}

通过代理对象实现⽬标对象的功能

        // 目标对象
        You you = new You();
        // 代理对象
        MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
        // 通过代理对象调用目标对象中的方法
        marryCompanyProxy.toMarry();

静态代理对于代理的⻆⾊是固定的，如dao层有20个dao类，如果要对⽅法的访问权限进⾏代理，此时需要创建20个静态代理⻆⾊，引起类爆炸，⽆法满⾜⽣产上的需要，于是就催⽣了动态代理的思想

三、动态代理

相⽐于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运⾏时，由Java反射机制动态产⽣。

它会根据需要，通过反射机制在程序运⾏期，动态的为⽬标对象创建代理对象，⽆需程序员⼿动编写它的源代码。

动态代理不仅简化了编程⼯作，⽽且提⾼了软件系统的可扩展性，因为反射机制可以⽣成任意类型的动态代理类。

代理的⾏为可以代理多个⽅法，即满⾜⽣产需要的同时⼜达到代码通⽤的⽬的。

动态代理的两种实现⽅式：

JDK 动态代理
CGLIB动态代理

1.动态代理的特点

⽬标对象不固定
在应⽤程序执⾏时动态创建⽬标对象
代理对象会增强⽬标对象的⾏为

2.JDK动态代理

注意：JDK动态代理的⽬标对象必须有接⼝实现

注：JDK的动态代理依靠接⼝实现，如果有些类并没有接⼝实现，则不能使⽤JDK代理。s

newProxyInstance

Proxy类：

Proxy类是专⻔完成代理的操作类，可以通过此类为⼀个或多个接⼝动态地⽣成实现类，此类提供了如下操作⽅法：

 public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

返回⼀个指定接⼝的代理类的实例⽅法调⽤分派到指定的调⽤处理程序。 (返回代理对象)

loader：类加载器⼀个ClassLoader对象，定义了由哪个ClassLoader对象来对⽣成的代理对象进⾏加载

interfaces：接口数组⼀个Interface对象的数组，表示的是我将要给我需要代理的对象提供⼀组什么接⼝，如果我提供了⼀组接⼝给它，那么这个代理对象就宣称实现了该接⼝(多态)，这样我就能调⽤这组接⼝中的⽅法了

target.getClass().getInterfaces()：目标对象的接口数组

h：InvocationHandler接口（传入InvocationHandler接口的实现类，⼀个InvocationHandler接⼝，表示代理实例的调⽤处理程序实现的接⼝。每个代理实例都具有⼀个关联的调⽤处理程序。对代理实例调⽤⽅法时，将对⽅法调⽤进⾏编码并将其指派到它的调⽤处理程序的 invoke ⽅法（传⼊InvocationHandler接⼝的⼦类）

获取代理对象

public class JdkHandler implements InvocationHandler {

    // 目标对象
    private Object target; // 目标对象的类型不固定，创建时动态生成
    // 通过带参构造器传递目标对象
    public JdkHandler(Object target) {
        this.target = target;
    }


    /**
     * 1. 调用目标对象的方法 （返回Object）
     * 2. 增强目标对象的行为
     * @param proxy 调用该方法的代理实例
     * @param method 目标对象的方法
     * @param args 目标对象的方法所需要的的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("invoke方法的proxy参数：" + proxy.getClass().getName());

        // 用户的增强行为
        System.out.println("===============方法执行前");

        // 调用目标对象中的方法 （返回Object）
        Object object = method.invoke(target,args);

        // 用户的增强行为
        System.out.println("方法执行后===============");

        return object;
    }

    /**
     * 获取代理对象
     *  public static Object newProxyInstance(ClassLoader loader,
     *                                       Class[] interfaces,
     *                                       InvocationHandler h)
     *   loader：类加载器
     *   interfaces：接口数组
     *          target.getClass().getInterfaces()：目标对象的接口数组
        h：InvocationHandler接口（传入InvocationHandler接口的实现类）
     *
     * @return
     */
    public Object getProxy(){
        Object object = Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
        System.out.println("getProxy返回的代理对象：" + object.getClass().getName());
        return  object;
    }


}

通过代理对象实现⽬标对象的功能

// ⽬标对象
You you = new You();
// 获取代理对象
JdkHandler jdkHandler = new JdkHandler(you);
Marry marry = (Marry) jdkHandler.getProxy();
// 通过代理对象调⽤⽬标对象中的⽅法
marry.toMarry();

Java动态代理类中的invoke是怎么调⽤的？

在⽣成的动态代理类 $P ro x y 0. c l a ss 中，构造⽅法调⽤了⽗类 P ro x y . c l a ss 的构造⽅法，给成员变量 in v oc a t i o n H an d l er 赋值，$ Proxy0.class的static模块中创建了被代理类的⽅法，调⽤相应⽅法时⽅法体中调⽤了⽗类中的成员变量InvocationHandler的invoke()⽅法。

2.CGLIB 动态代理

JDK的动态代理机制只能代理实现了接⼝的类，⽽不能实现接⼝的类就不能使⽤JDK的动态代理，cglib是针对类来实现代理的，它的原理是对指定的⽬标类⽣成⼀个⼦类，并覆盖其中⽅法实现增强，但因为采⽤的是继承，所以不能对final修饰的类进⾏代理。

添加依赖

在pom.xml⽂件中引⼊cglib的相关依赖

    <!-- cglib -->
    <!-- https://mvnrepository.com/artifact/cglib/cglib -->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2.2</version>
    </dependency>

定义类

实现MethodInterceptor接⼝

public class CglibInterceptor implements MethodInterceptor {

    // 目标对象
    private Object target;
    // 通过构造器传入目标对象
    public CglibInterceptor(Object target) {
        this.target = target;
    }

    /**
     * 获取代理对象
     * @return
     */
    public Object getProxy(){
        // 通过Enhancer对象中的create()方法生成一个类，用于生成代理对象
        Enhancer enhancer = new Enhancer();
        // 设置父类 （将目标类作为代理类的父类）
        enhancer.setSuperclass(target.getClass());
        // 设置拦截器 回调对象为本身对象
        enhancer.setCallback(this);
        // 生成代理类对象，并返回给调用者
        return enhancer.create();
    }


    /**
     * 拦截器
     *    1. 目标对象的方法调用
     *    2. 行为增强
     * @param o cglib动态生成的代理类的实例
     * @param method    实体类所调用的都被代理的方法的引用
     * @param objects   参数列表
     * @param methodProxy   生成的代理类对方法的代理引用
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        // 增强行为
        System.out.println("===================方法前执行");

        // 调用目标类中的方法
        Object object = methodProxy.invoke(target, objects);

        // 增强行为
        System.out.println("方法后执行===================");

        return object;
    }
}

调⽤⽅法

		 You you = new You();
        // 得到拦截器
        CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
        // 得到代理对象
        Marry marry  = (Marry) cglibInterceptor.getProxy();
        // 通过代理对象调用目标对象中的方法
        marry.toMarry();


        /*通过Cglib动态代理实现：没有接口实现的类*/
        User user = new User();
        CglibInterceptor cglibInterceptor02 = new CglibInterceptor(user);
        User u = (User) cglibInterceptor02.getProxy();
        u.test();

JDK代理与CGLIB代理的区别

JDK动态代理实现接⼝，Cglib动态代理继承思想
JDK动态代理（⽬标对象存在接⼝时）执⾏效率⾼于Ciglib
如果⽬标对象有接⼝实现，选择JDK代理，如果没有接⼝实现选择Cglib代理

四、Spring AOP

Aspect Oriented Programing ⾯向切⾯编程，相⽐较 oop ⾯向对象编程来说，Aop关注的不再是程序代码中某个类，某些⽅法，⽽aop考虑的更多的是⼀种⾯到⾯的切⼊，即层与层之间的⼀种切⼊，所以称之为切⾯。联想⼤家吃的汉堡（中间夹⾁）。那么aop是怎么做到拦截整个⾯的功能呢？考虑前⾯学到的servlet filter /* 的配置，实际上也是aop 的实现。

AOP能做什么？

AOP主要应⽤于⽇志记录，性能统计，安全控制,事务处理等⽅⾯，实现公共功能性的重复使⽤。

AOP的特点

降低模块与模块之间的耦合度，提⾼业务代码的聚合度。（⾼内聚低耦合）
提⾼了代码的复⽤性。
提⾼系统的扩展性。（⾼版本兼容低版本）
可以在不影响原有的功能基础上添加新的功能

AOP的底层实现

动态代理（JDK + CGLIB）

AOP基本概念

Joinpoint（连接点）

被拦截到的每个点，spring中指被拦截到的每⼀个⽅法，spring aop⼀个连接点即代表⼀个⽅法的执⾏。

Pointcut（切⼊点）

对连接点进⾏拦截的定义（匹配规则定义规定拦截哪些⽅法，对哪些⽅法进⾏处理），spring 有专⻔的表达式语⾔定义

Advice（通知）

拦截到每⼀个连接点即（每⼀个⽅法）后所要做的操作

前置通知（前置增强）— before() 执⾏⽅法前通知
返回通知（返回增强）— afterReturn ⽅法正常结束返回后的通知
异常抛出通知（异常抛出增强）— afetrThrow()
最终通知 — after ⽆论⽅法是否发⽣异常，均会执⾏该通知。
环绕通知 — around 包围⼀个连接点（join point）的通知，如⽅法调⽤。这是最强⼤的⼀种通知类型。环绕通知可以在⽅法调⽤前后完成⾃定义的⾏为。它也会选择是否继续执⾏连接点或直接返回它们⾃⼰的返回值或抛出异常来结束执⾏。

Aspect（切⾯）

切⼊点与通知的结合，决定了切⾯的定义，切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么，切⾯则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切⾯则是横切关注点抽象。

Target（⽬标对象）

被代理的⽬标对象

Weave（织⼊）

将切⾯应⽤到⽬标对象并⽣成代理对象的这个过程即为织⼊

Introduction（引⼊）

在不修改原有应⽤程序代码的情况下，在程序运⾏期为类动态添加⽅法或者字段的过程称为引⼊

五、Spring AOP的实现

1.Spring AOP环境搭建

坐标依赖引⼊

    <!-- Spring的相关依赖 -->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>

    <!--Spring AOP-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
    </dependency>

添加spring.xml的配置

添加命名空间

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

2.注解实现

定义切⾯

/**
 * 切面
 *      切入点和通知的抽象
 *      定义 切入点  和 通知
 *         切入点：定义要拦截哪些类的哪些方法
 *         通知：定义了拦截之后方法要做什么
 */
@Component // 将对象交给IOC容器进行实例化
@Aspect // 声明当前类是一个切面
public class LogCut {

    /**
     * 切入点
     *      定义要拦截哪些类的哪些方法
     *      匹配规则，拦截什么方法
     *
     *      定义切入点
     *          @Pointcut("匹配规则")
     *
     *      Aop切入点表达式
     *          1. 执行所有的公共方法
     *              execution(public *(..))
     *         2. 执行任意的set方法
     *              execution(* set*(..))
     *         3. 设置指定包下的任意类的任意方法 （指定包：com.xxxx.service）
     *              execution(* com.xxxx.service.*.*(..))
     *         4. 设置指定包及子包下的任意类的任意方法 （指定包：com.xxxx.service）
     *             execution(* com.xxxx.service..*.*(..))
     *
     *        表达式中的第一个*
     *              代表的是方法的修饰范围  （public、private、protected）
     *              如果取值是*，则表示所有范围
     */
    @Pointcut("execution(* com.xxxx.service..*.*(..))")
    public void cut(){

    }

    /**
     * 声明前置通知，并将通知应用到指定的切入点上
     *      目标类的方法执行前，执行该通知
     */
    @Before(value = "cut()")
    public void before() {
        System.out.println("前置通知...");
    }

    /**
     * 声明返回通知，并将通知应用到指定的切入点上
     *      目标类的方法在无异常执行后，执行该通知
     */
    @AfterReturning(value = "cut()")
    public void afterReturn(){
        System.out.println("返回通知...");
    }

    /**
     * 声明最终通知，并将通知应用到指定的切入点上
     *      目标类的方法在执行后，执行该通知 （有异常和无异常最终都会执行）
     */
    @After(value = "cut()")
    public void after(){
        System.out.println("最终通知...");
    }

    /**
     * 声明异常通知，并将通知应用到指定的切入点上
     *      目标类的方法在执行异常时，执行该通知
     */
    @AfterThrowing(value = "cut()", throwing = "e")
    public void afterThrow(Exception e){
        System.out.println("异常通知...  ===== 异常原因：" + e.getMessage());
    }


    /**
     * 声明环绕通知，并将通知应用到指定的切入点上
     *      目标类的方法执行前后，都可通过环绕通知定义响应的处理
     *          需要通过显式调用的方法，否则无法访问指定方法 pjp.proceed();
     * @param pjp
     * @return
     */
    @Around(value = "cut()")
    public Object around(ProceedingJoinPoint pjp)  {
        System.out.println("环绕通知-前置通知...");

        Object object = null;
        //object = pjp.proceed();

        try{
            // 显式调用对应的方法
            object = pjp.proceed();
            System.out.println(pjp.getTarget());
            System.out.println("环绕通知-返回通知...");
        } catch (Throwable throwable){
            throwable.printStackTrace();
            System.out.println("环绕通知-异常通知...");
        }
        System.out.println("环绕通知-最终通知...");

        return object;
    }

}

配置⽂件（spring.xml）

        <!-- 配置AOP代理 -->
        <aop:aspectj-autoproxy/>

3.XML实现

定义切⾯

/**
 * 切面
 *      切入点和通知的抽象
 *      定义 切入点  和 通知
 *         切入点：定义要拦截哪些类的哪些方法
 *         通知：定义了拦截之后方法要做什么
 */
@Component // 将对象交给IOC容器进行实例化
public class LogCut02 {

    /**
     * 切入点
     *      定义要拦截哪些类的哪些方法
     *      匹配规则，拦截什么方法
     *
     */
    public void cut(){

    }

    /**
     * 声明前置通知，并将通知应用到指定的切入点上
     *      目标类的方法执行前，执行该通知
     */
    public void before() {
        System.out.println("前置通知...");
    }

    /**
     * 声明返回通知，并将通知应用到指定的切入点上
     *      目标类的方法在无异常执行后，执行该通知
     */
    public void afterReturn(){
        System.out.println("返回通知...");
    }

    /**
     * 声明最终通知，并将通知应用到指定的切入点上
     *      目标类的方法在执行后，执行该通知 （有异常和无异常最终都会执行）
     */
    public void after(){
        System.out.println("最终通知...");
    }

    /**
     * 声明异常通知，并将通知应用到指定的切入点上
     *      目标类的方法在执行异常时，执行该通知
     */
    public void afterThrow(Exception e){
        System.out.println("异常通知...  ===== 异常原因：" + e.getMessage());
    }


    /**
     * 声明环绕通知，并将通知应用到指定的切入点上
     *      目标类的方法执行前后，都可通过环绕通知定义响应的处理
     *          需要通过显式调用的方法，否则无法访问指定方法 pjp.proceed();
     * @param pjp
     * @return
     */
    public Object around(ProceedingJoinPoint pjp)  {
        System.out.println("环绕通知-前置通知...");

        Object object = null;
        //object = pjp.proceed();

        try{
            // 显式调用对应的方法
            object = pjp.proceed();
            System.out.println(pjp.getTarget());
            System.out.println("环绕通知-返回通知...");
        } catch (Throwable throwable){
            throwable.printStackTrace();
            System.out.println("环绕通知-异常通知...");
        }
        System.out.println("环绕通知-最终通知...");

        return object;
    }



}

配置⽂件（spring.xml）

<!-- aop 相关配置 -->
<aop:config>
   <!-- aop 切面 -->
   <aop:aspect ref="logCut02">
       <!-- 定义 aop 切入点 -->
       <aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*(..))"/>
       <!-- 配置前置通知，设置前置通知对应的方法名及切入点 -->
       <aop:before method="before" pointcut-ref="cut"/>
       <!-- 配置返回通知，设置返回通知对应的方法名及切入点 -->
       <aop:after-returning method="afterReturn" pointcut-ref="cut"/>
       <!-- 配置最终通知，设置最终通知对应的方法名及切入点 -->
       <aop:after method="after" pointcut-ref="cut"/>
       <!-- 配置异常通知，设置异常通知对应的方法名及切入点 -->
       <aop:after-throwing method="afterThrow" pointcut-ref="cut" throwing="e" />
       <!-- 配置环绕通知，设置环绕通知对应的方法名及切入点 -->
       <aop:around method="around" pointcut-ref="cut"/>
    </aop:aspect>
</aop:config>