SSM框架之Spring（4）AOP

淩亂°似流年 2022-02-03 16:43 289阅读 0赞

# Spring（4）AOP #

## 1、AOP概述 ##

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

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的  
基础上，对我们的已有方法进行增强。

**作用：**  
在程序运行期间，不修改源码对已有方法进行增强。  
**优势：**  
减少重复代码、提高开发效率、维护方便

## 2、动态代理 ##

### 2.1、动态代理的特点 ###

字节码随用随创建，随用随加载。  
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。  
装饰者模式就是静态代理的一种体现。

### 2.2、动态代理的两种方式 ###

基于接口的动态代理

提供者：JDK 官方的 Proxy 类。  
要求：被代理类最少实现一个接口。

基于子类的动态代理  
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。  
要求：被代理类不能用 final 修饰的类（最终类）。

#### 2.2.1、基于接口的动态代理 ####

被代理的类

public interface IProducer { 
        public void saleProduct(float money);
    
        public void afterService(float money);
    }
    
    
    
    
    ============================================
        
    public class Producer implements IProducer { 
        public void saleProduct(float money){ 
            System.out.println("售出产品，价格：" + money);
        }
    
        public void afterService(float money){ 
            System.out.println("提供售后服务，价格：" + money);
        }
    }

使用 JDK 官方的 Proxy

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class client { 
        public static void main(String[] args) { 
            final Producer producer = new Producer();
            //producer.saleProduct(10000f);
    
            /** * 动态代理： * 特点：字节码随用随创建，随用随加载 * 资源：在不修改源码的情况下对方法增强 * 分类： * 基于接口的动态代理 * 基于子类的动态代理 * 基于接口： * 涉及到类：proxy * 提供者：JDK官方 * 如何创建代理对象： * 使用proxy中的newPoxyInstance方法 * 创建代理对象的要求： * 被代理对象必须有接口，如果没有则不能使用 * newProxyInstance参数： * classLoader:类加载器 * 用于加载代理对象的字节码，和被代理对象使用相同的类加载器。固定写法 * Class[]：字节码数组 * 让代理对象和被代理对象拥有相同方法。写法固定 * InvocationHandler:用于增强的代码 * 它让我们写如何代理，一般写该接口的实现类，通常情况是匿名内部类，但不是必须的 * 此接口谁用谁写 */
            IProducer proxyProduec = (IProducer)Proxy.newProxyInstance(producer.getClass().getClassLoader()
                    , producer.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        /** * 作用：执行的被代理对象的方法都会经过此方法 * @param proxy 代理对象的引用 * @param method 当前执行的方法 * @param args 被代理对象方法的参数 * @return 被代理对象方法的返回值 * @throws Throwable */
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            Object rtValue = null;
                            Float money = (Float)args[0];
                            if("saleProduct".equals(method.getName())){ 
                                rtValue = method.invoke(producer, money * 0.8f);
                            }
                            return rtValue;
                        }
                    });
            proxyProduec.saleProduct(10000f);
        }
    
    }

#### 22.2、基于子类的动态代理 ####

被代理的类

public class Producer { 
        public void saleProduct(float money){ 
            System.out.println("售出产品，价格：" + money);
        }
    
        public void afterService(float money){ 
            System.out.println("提供售后服务，价格：" + money);
        }
    }

使用 CGLib 的 的 Enhancer

import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    import java.lang.reflect.Method;
    
    public class client { 
        public static void main(String[] args) { 
            final Producer producer = new Producer();
            //producer.saleProduct(10000f);
    
            /** * 动态代理： * 特点：字节码随用随创建，随用随加载 * 资源：在不修改源码的情况下对方法增强 * 分类： * 基于接口的动态代理 * 基于子类的动态代理 * 基于接口： * 涉及到类：Enhancer * 提供者：第三方 * 如何创建代理对象： * 使用Enhancer中的create方法 * 创建代理对象的要求： * 代理类不是最终类 * create参数： * Class：字节码 * 指定被代理对象的字节码 * Callback：提供增强代码 * 写如何代理，一般是写一个该接口实现类 * 此接口谁用谁写 * 一般写的是该接口的子接口实现类MethodInterceptor */
            Producer p = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() { 
                /** * 作用：执行的被代理对象的方法都会经过此方法 * @param obj * @param method * @param args * 以上三个参数与基于接口的代理作用相同 * @param proxy 当前方法的代理对象 * @return * @throws Throwable */
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
                    Object rtValue = null;
                    Float money = (Float)args[0];
                    if("saleProduct".equals(method.getName())){ 
                        rtValue = method.invoke(producer, money * 0.8f);
                    }
                    return rtValue;
                }
            });
            p.saleProduct(10000f);
        }
    
    }

## 3、spring中的AOP ##

### 3.1、AOP相关术语 ###

**Joinpoint( 连接点):**  
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

**Pointcut( 切入点):**  
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

**Advice( 通知/ 增强):**  
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。  
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

**Introduction( 引介):**  
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

**Target( 目标对象):**  
代理的目标对象。

**Weaving( 织入):**  
是指把增强应用到目标对象来创建新的代理对象的过程。  
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

**Proxy （代理）**:  
一个类被 AOP 织入增强后，就产生一个结果代理类。

**Aspect( 切面):**  
是切入点和通知（引介）的结合。

### 3.2、AOP的工作流程 ###

**开发阶段（我们做的）**

编写核心业务代码，把公用代码抽取出来，制作成通知。在配置文件中，声明切入点与通知间的关系，即切面。

**运行阶段（Spring 框架完成的）**

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

**关于代理的选择**

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

### 3.3、基于 XML 的 的 AOP ###

基于案例描述

案例：在service类的方法执行时加入日志

service类

public interface IAccountService { 
        /** * 保存账户 */
        void saveAccount();
    
        /** * 更新账户 * @param i * @return */
        void updateAccount(int i);
    
        /** * 删除账户 * @return */
        int deleteAccount();
    }
    
    ===================================
    
    public class AccountServiceImpl implements IAccountService { 
        public void saveAccount() { 
            System.out.println("执行了保存");
        }
    
        public void updateAccount(int i) { 
            System.out.println("执行了更新" + i);
        }
    
        public int deleteAccount() { 
            System.out.println("执行了删除");
            return 0;
        }
    }

Logger日志

/** * 用于记录日志的工具类 */
    public class Logger { 
    
        public void printLog(){ 
            System.out.println("Logger类中的printLog执行日志记录。。。");
        }
    }

配置文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="accountService" class="wf.service.impl.AccountServiceImpl"></bean>
    
        
        <bean id="logger" class="wf.utils.Logger"></bean>
        
        <aop:config>
            <aop:aspect id="logAdvice" ref="logger">
                <aop:before method="printLog" pointcut="execution(* wf.service.impl.*.*(..))"></aop:before>
            </aop:aspect>
        </aop:config>
    
    </beans>

#### 3.3.1、AOP中通知的配置 ####

import org.aspectj.lang.ProceedingJoinPoint;
    
    /** * 用于记录日志的工具类 */
    public class Logger { 
    
        /** * 前置通知 */
        public void beforePrintLog(){ 
    
            System.out.println("前置通知Logger类中的beforePrintLog执行日志记录。。。");
        }
    
        /** * 后置通知 */
        public void afterReturningPrintLog(){ 
    
            System.out.println("后置通知Logger类中的afterReturningPrintLog执行日志记录。。。");
        }
    
        /** * 异常通知 */
        public void afterThrowingPrintLog(){ 
    
            System.out.println("异常通知Logger类中的afterThrowingPrintLog执行日志记录。。。");
        }
    
        /** * 最终通知 */
        public void afterPrintLog(){ 
    
            System.out.println("最终通知Logger类中的afterPrintLog执行日志记录。。。");
        }
    
        /** * 环绕通知 * 当配置了环绕通知，切入点方法没有执行，而只通知方法执行了 * 分析： * 通过对比动态代理中的环绕通知，发现动态代理的环绕通知有明确的切入点方法调用，而现在写的方法没有 * 解决： * spring框架提供了一个接口：ProceedingJoinPoint 接口，该接口有一个procced()方法，改方法明确了切入点方法调用 * 该接口可作为切入点方法的参数，在实际执行中spring框架会通过该接口的实现类供我们使用 * spring框架中的环绕通知： * 它是spring框架提供的一种可以在代码中手动控制增强方法何时执行的方式 */
        public Object aroundPrintLog(ProceedingJoinPoint pjp){ 
            Object rtValue = null;
            try { 
                Object[] args = pjp.getArgs();//获取要执行方法的参数
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。前置");
                rtValue = pjp.proceed(args);//执行切入点方法
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。后置");
                return rtValue;
            }catch (Throwable t){ 
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。异常");
                throw new RuntimeException(t);
            }finally { 
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。最终");
            }
    
    
    
        }
    }

配置文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="accountService" class="wf.service.impl.AccountServiceImpl"></bean>
    
    
        <bean id="logger" class="wf.utils.Logger"></bean>
        
        <aop:config>
            
            <aop:pointcut id="pt" expression="execution(* wf.service.impl.*.*(..))"></aop:pointcut>
            
            <aop:aspect id="logAdvice" ref="logger">
    
                
    
                
    
                
    
                
    
                
                <aop:around method="aroundPrintLog" pointcut-ref="pt"></aop:around>
            </aop:aspect>
        </aop:config>
    
    </bean

### 3.3、基于注解的配置 ###

被代理类

package wf.service.impl;
    
    import org.springframework.stereotype.Service;
    import wf.service.IAccountService;
    
    /** * 账户的服务层实现类 */
    @Service("accountService")
    public class AccountServiceImpl implements IAccountService { 
        public void saveAccount() { 
    
            System.out.println("执行了保存");
    // int i = 1/0;
        }
    
        public void updateAccount(int i) { 
            System.out.println("执行了更新" + i);
        }
    
        public int deleteAccount() { 
            System.out.println("执行了删除");
            return 0;
        }
    }

切面类

package wf.utils;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    import org.springframework.stereotype.Component;
    
    /** * 用于记录日志的工具类 */
    @ComponentScan("wf")
    @EnableAspectJAutoProxy
    @Component("logger")
    @Aspect//表示当前类是一个切面类
    public class Logger { 
    
        @Pointcut("execution(* wf.service.impl.*.*(..))")
        public void pt(){ }
    
        /** * 前置通知 */
        @Before("pt()")
        public void beforePrintLog(){ 
    
            System.out.println("前置通知Logger类中的beforePrintLog执行日志记录。。。");
        }
    
        /** * 后置通知 */
        @AfterReturning("pt()")
        public void afterReturningPrintLog(){ 
    
            System.out.println("后置通知Logger类中的afterReturningPrintLog执行日志记录。。。");
        }
    
        /** * 异常通知 */
        @AfterThrowing("pt()")
        public void afterThrowingPrintLog(){ 
    
            System.out.println("异常通知Logger类中的afterThrowingPrintLog执行日志记录。。。");
        }
    
        /** * 最终通知 */
        @After("pt()")
        public void afterPrintLog(){ 
    
            System.out.println("最终通知Logger类中的afterPrintLog执行日志记录。。。");
        }
    
        /** * 环绕通知 * 当配置了环绕通知，切入点方法没有执行，而只通知方法执行了 * 分析： * 通过对比动态代理中的环绕通知，发现动态代理的环绕通知有明确的切入点方法调用，而现在写的方法没有 * 解决： * spring框架提供了一个接口：ProceedingJoinPoint 接口，该接口有一个procced()方法，改方法明确了切入点方法调用 * 该接口可作为切入点方法的参数，在实际执行中spring框架会通过该接口的实现类供我们使用 * spring框架中的环绕通知： * 它是spring框架提供的一种可以在代码中手动控制增强方法何时执行的方式 */
        @Around("pt()")
        public Object aroundPrintLog(ProceedingJoinPoint pjp){ 
            Object rtValue = null;
            try { 
                Object[] args = pjp.getArgs();//获取要执行方法的参数
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。前置");
                rtValue = pjp.proceed(args);//执行切入点方法
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。后置");
                return rtValue;
            }catch (Throwable t){ 
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。异常");
                throw new RuntimeException(t);
            }finally { 
                System.out.println("Logger类中的aroundPrintLog执行日志记录。。。最终");
            }
    
    
    
        }
    }

测试类

package test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import wf.service.IAccountService;
    import wf.utils.Logger;
    
    public class AopTest { 
        public static void main(String[] args) { 
            //1.获取容器
    // ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            ApplicationContext ac = new AnnotationConfigApplicationContext(Logger.class);
            //2.获取容器对象
            IAccountService as = ac.getBean("accountService", IAccountService.class);
            //3.执行方法
            as.saveAccount();
    // as.updateAccount(3);
    // as.deleteAccount();
        }
    }

[Link 1]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%88%87%E9%9D%A2%E7%BC%96%E7%A8%8B/6016335
[Link 2]: https://baike.baidu.com/item/%E9%A2%84%E7%BC%96%E8%AF%91/3191547
[OOP]: https://baike.baidu.com/item/OOP
[Spring]: https://baike.baidu.com/item/Spring
[Link 3]: https://baike.baidu.com/item/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/4035031
[Link 4]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E5%BA%A6/2603938