Spring 框架——AOP编程

柔光的暖阳◎ 2022-05-17 06:28 238阅读 0赞

# 一、介绍 #

## 1、基本概念 ##

aop( aspect oriented programming ) 面向切面(方面)编程,是对所有对象或者是一类对象编程,核心是( 在不增加代码的基础上， 还增加新功能 )。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

*  AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
 *  经典应用：事务管理、性能监视、安全检查、缓存 、日志等
 *  Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码

*  AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

## 2、AOP联盟通知类型 ##

AOP联盟为通知Advice定义了org.aopalliance.aop.Advice，Spring按照通知Advice在目标类方法的连接点位置，可以分为5类：

*  前置通知 org.springframework.aop.MethodBeforeAdvice：在目标方法执行前实施增强
 *  后置通知 org.springframework.aop.AfterReturningAdvice：在目标方法执行后实施增强
 *  环绕通知 org.aopalliance.intercept.MethodInterceptor：在目标方法执行前后实施增强
 *  异常抛出通知 org.springframework.aop.ThrowsAdvice：在方法抛出异常后实施增强
 *  引介通知 org.springframework.aop.IntroductionInterceptor：在目标类中添加一些新的方法和属性

注意：其中环绕通知是功能最全的通知，如下

try{
       //代码写在这相当于前置通知
       //执行目标方法   （环绕通知，必须手动执行目标方法）
       //代码写在这相当于后置通知
    } catch(){
       //代码写在这相当于抛出异常通知
    }

## 3、AOP实现原理 ##

aop底层将采用代理机制进行实现：

方式一：接口 + 实现类 ：spring采用 jdk 的动态代理Proxy。

方式二：实现类：spring 采用 cglib字节码增强。

# 二、AOP的实现 #

## 1、手动方式  ##

### 1.JDK动态代理 ###

首先目标类如下：

public interface UserService {
        public void addUser();
        public void updateUser();
        public void deleteUser();
    }
    public class UserServiceImpl implements UserService {
        @Override
        public void addUser() {
            System.out.println("a_proxy.a_jdk addUser");
        }
        @Override
        public void updateUser() {
            System.out.println("a_proxy.a_jdk updateUser");
        }
        @Override
        public void deleteUser() {
            System.out.println("a_proxy.a_jdk deleteUser");
        }
    }

现在要在目标类中的每个方法执行前后都要加上如下切面类中的两个方法：

public class MyAspect {
        public void before(){
            System.out.println("开始");
        }
        public void after(){
            System.out.println("结束");
        }
    }

之后要新建一个自己的Bean工厂，目的是实例化目标类（这里采用动态代理技术，来返回代理对象）：

public class MyBeanFactory {
        public static UserService createService(){
            //1 目标类
            final UserService userService = new UserServiceImpl();
            //2切面类
            final MyAspect myAspect = new MyAspect();
                    //3代理类
            UserService proxService = (UserService)Proxy.newProxyInstance(MyBeanFactory.class.getClassLoader(), 
                                    userService.getClass().getInterfaces(), 
                                    new InvocationHandler() {   
                                        @Override
                                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                            myAspect.before();//前执行
                                            Object obj = method.invoke(userService, args);//执行目标类的方法
                                            myAspect.after();//后执行
                                            return obj;
                                        }
                                    });
            return proxService;
        }
    }

那么在测试类中调用userService的方法时，所有方法的前后都会加上代理对象中添加的方法：

@Test
    public void demo01(){
        UserService userService = MyBeanFactory.createService();
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }

会打印出：开始=》a\_proxy.a\_jdk addUser"=》结束。。。

### 2.CGLIB字节码增强 ###

如果使用CGLIB字节码增强方式则目标类没有接口，只有实现类。采用字节码增强框架 cglib，在运行时 创建目标类的子类，从而对目标类进行增强。需要导入的jar包为：

*  核心：hibernate-distribution-3.6.10.Final\\lib\\bytecode\\cglib\\cglib-2.2.jar
 *  依赖：struts-2.3.15.3\\apps\\struts2-blank\\WEB-INF\\lib\\asm-3.3.jar

注意：spring-core..jar 已经整合以上两个内容，故只需导入spring核心包即可

那么它的目标类如下（没有接口）：

public class UserServiceImpl {
        public void addUser() {
            System.out.println("a_proxy.b_cglib addUser");
        }
        public void updateUser() {
            System.out.println("a_proxy.b_cglib updateUser");
        }
        public void deleteUser() {
            System.out.println("a_proxy.b_cglib deleteUser");
        }
    }

而它的切面类和测试类与上面一样，只是Bean工厂类有区别：

public class MyBeanFactory {    
        public static UserServiceImpl createService(){
            //1 目标类
            final UserServiceImpl userService = new UserServiceImpl();
            //2切面类
            final MyAspect myAspect = new MyAspect();
            // 3.代理类 ，采用cglib，底层创建目标类的子类
            //3.1 核心类
            Enhancer enhancer = new Enhancer();
            //3.2 确定父类
            enhancer.setSuperclass(userService.getClass());
            // 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
            enhancer.setCallback(new MethodInterceptor(){
                @Override
                public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                    myAspect.before();//前
                    Object obj = method.invoke(userService, args);//执行目标类的方法                
                    myAspect.after();//后
                    return obj;
                }
            });
            //3.4 创建代理
            UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
            return proxService;
        }
    }

注意：intercept() 方法等效于 jdk代理中的invoke()方法，其中参数1、参数2、参数3与invoke一样；参数4：表示的是methodProxy 方法的代理

## 2、spring编写代理（半自动） ##

让spring 创建代理对象，从spring容器中手动的获取代理对象。现在其目标实现类如下：

public interface UserService {
        public void addUser();
        public void updateUser();
        public void deleteUser();
    }
    public class UserServiceImpl implements UserService {
        @Override
        public void addUser() {
            System.out.println("b_factory_bean addUser");
        }
        @Override
        public void updateUser() {
            System.out.println("b_factory_bean updateUser");
        }
        @Override
        public void deleteUser() {
            System.out.println("b_factory_bean deleteUser");
        }
    }

而它的切面类如下：

public class MyAspect implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation mi) throws Throwable {
            System.out.println("前");        
            Object obj = mi.proceed();//手动执行目标方法
            System.out.println("后");
            return obj;
        }
    }

注意：在切面类中确定通知，需要实现不同接口，接口就是规范，从而就确定方法名称。这里采用“环绕通知”，需要实现的接口为MethodInterceptor

现在就需要在spring配置文件中配置其代理对象：

<bean id="userServiceId" class="com.shen.factory_bean.UserServiceImpl"></bean>
    
    <bean id="myAspectId" class="com.shen.factory_bean.MyAspect"></bean>
    
    
    <bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.shen.factory_bean.UserService"></property>
        <property name="target" ref="userServiceId"></property>
        <property name="interceptorNames" value="myAspectId"></property>
    </bean>

说明：在配置代理类中使用工厂bean（FactoryBean），底层调用 getObject() 返回特殊bean，其中ProxyFactoryBean 就是用于创建代理工厂bean，生成特殊代理对象的。下面说明其属性值：

*  interfaces : 确定接口们的，通过<array>可以设置多个值，这里只有一个值时，故只用一个value=""
 *  target : 确定目标类的
 *  interceptorNames : 通知切面类的名称，类型String\[\]，也可以通过<array>设置多个值（注意这里不是ref而是value）
 *  optimize :强制使用cglib（<property name="optimize" value="true"></property>），如果没有这个值的话，如果目标类有接口，采用jdk动态代理；如果没有接口，采用cglib 字节码增强；而如果声明 optimize = true ，无论是否有接口，都采用cglib

下面就是测试类：

public class TestFactoryBean {
        @Test
        public void demo01(){
            String xmlPath = "com/shen/factory_bean/beans.xml";
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("proxyServiceId");//获得代理类
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }
    }

注意：这里获取的是代理类的bean值而不是目标类（不是很好）

## 3、spring aop编程（全自动） ##

从spring容器获得目标类，如果配置aop，spring将自动生成代理。这里要确定目标类需要使用aspectj 切入点表达式，在这里其切面类和目标类和上例都一样，需要改的只是配置文件（要添加命名空间部分的代码）：

<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="userServiceId" class="com.shen.spring_aop.UserServiceImpl"></bean>
        
        <bean id="myAspectId" class="com.shen.spring_aop.MyAspect"></bean>
        
        <aop:config proxy-target-class="true">
            <aop:pointcut expression="execution(* com.shen.spring_aop.*.*(..))" id="myPointCut"/>
            <aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
        </aop:config>
    </beans>

说明：

1.在配置aop编程时使用 <aop:config>进行配置，其中如果加上proxy-target-class="true" 声明时强制使用cglib代理（否则无接口使用【同上】）

2.<aop:pointcut> 切入点 ，从目标对象获得具体方法，这里切入点表达式说明：

execution   (            \*              com.itheima.c\_spring\_aop.      \*             .             \*                (..)           )

选择方法        返回值任意                         包                     类名任意           方法名任意   参数任意

3.<aop:advisor> 特殊的切面，只有一个通知（advice-ref 通知引用）和 一个切入点（pointcut-ref 切入点引用）

在测试类中：

public class TestSpringAOP {
        @Test
        public void demo01(){
            String xmlPath = "com/shen/spring_aop/beans.xml";
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);            
            UserService userService = (UserService) applicationContext.getBean("userServiceId");//获得目标类
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }
    }

注意：这里获取的是目标类而不在是代理类

# 三、AspectJ #

## 1、基本介绍 ##

### 1.概念说明 ###

AspectJ是一个基于Java语言的AOP框架，Spring2.0以后新增了对AspectJ切点表达式支持，@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面。新版本Spring框架，建议使用AspectJ方式来开发AOP。

### 2.AspectJ 通知类型 ###

在aop联盟定义的通知类型中，具有特性接口，必须实现，从而确定方法名称。而在aspectj 通知类型中只定义类型名称以及方法格式。其中AspectJ定义的通知类型总共有6种：

*  before：前置通知(应用：各种校验)，在方法执行前执行，如果通知抛出异常，阻止方法运行
 *  afterReturning：后置通知(应用：常规数据处理)，方法正常返回后执行，如果方法中抛出异常，通知无法执行，必须在方法执行后才执行，所以可以获得方法的返回值。
 *  around：环绕通知(应用：可以做任何事情)，方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法
 *  afterThrowing：抛出异常通知(应用：包装异常信息)，方法抛出异常后执行，如果方法没有抛出异常，无法执行
 *  after：最终通知(应用：清理现场)，方法执行完毕后执行，无论方法中是否出现异常

注意：其中环绕等价于如下：

try{
         //前置：before
        //手动执行目标方法
        //后置：afterRetruning
    } catch(){
        //抛出异常 afterThrowing
    } finally{
        //最终 after
    }

## 2、切入点表达式 ##

### 1.execution() ###

用于描述方法的 ，语法如下：

execution(修饰符  返回值  包.类.方法名(参数) throws异常)

详解：

*  修饰符，一般省略

public 公共方法

\* 任意

*  返回值，不能省略

void 返回没有值

String 返回值字符串

\* 任意

*  包，可以省略

com.shen.crm 固定包

com.shen.crm.\*.service crm包下面子包任意 （例如：com.shen.crm.staff.service）

com.shen.crm.. crm包下面的所有子包（含自己及子孙，即crm以下的所有内容）

com.shen.crm.\*.service.. crm包下面任意子包，固定目录service，service目录任意包

*  类，可以省略

UserServiceImpl 指定类

\*Impl 以Impl结尾

User\* 以User开头

\* 任意

*  方法名，不能省略

addUser 固定方法

add\* 以add开头

\*Do 以Do结尾

\* 任意

*  (参数)

() 无参

(int) 一个整型

(int ,int) 两个

(..) 参数任意

*  throws ,可省略，一般不写。

举例：execution(\* com.shen.crm.\*.service..\*.\*(..))

注意：在配置文件中可以写成如下形式

<aop:pointcut expression="execution(* com.shen.*WithCommit.*(..)) || 
                              execution(* com.shen.*Service.*(..))" id="myPointCut"/>

即expression的最可以在多个切入点表达式中获取

### 2.within() ###

匹配包或子包中的方法(了解)

举例：within(com.shen.aop..\*)

### 3.this() ###

匹配实现接口的代理对象中的方法(了解)

举例：this(com.shen.aop.user.UserDAO)

### 4.target() ###

匹配实现接口的目标对象中的方法(了解)

举例：target(com.shen.aop.user.UserDAO)

### 5.args() ###

匹配参数格式符合标准的方法(了解)

举例：args(int,int)

### 6.bean(id) ###

对指定的bean所有的方法(了解)

举例：bean('userServiceId')

## 3、具体实现 ##

首先目标类如下：

public interface UserService {
        public void addUser();
        public String updateUser();
        public void deleteUser();
    }
    public class UserServiceImpl implements UserService {
        public void addUser() {
            System.out.println("aspect.a_xml addUser");
        }
        public void updateUser() {
            System.out.println("aspect.a_xml updateUser");
        }
        public void deleteUser() {  
            System.out.println("aspect.a_xml deleteUser");
        }
    }

而其切面类如下（这里的切面类不在需要实现额外的接口）：

public class MyAspect {
    
    }

测试类如下：

public class TestAspectXml {
        @Test
        public void demo01(){
            String xmlPath = "com/shen/d_aspect/a_xml/beans.xml";
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("userServiceId");//获得目标类
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }
    }

而在配置文件中因为要使用AspectJ表达式故同样要引入命名空间：

说明：

*  <aop:aspect> 将切面类 声明为“切面”，从而获得通知（方法）

ref 切面类引用

*  <aop:pointcut> 声明一个切入点，所有的通知都可以使用。

expression 切入点表达式

id 名称，用于其它通知引用

### 1.基于XML ###

1.前置通知

首先要在切面类中添加前置通知：

public void myBefore(JoinPoint joinPoint){
            System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
        }

说明：通知方法中参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等，如这里在测试中将打印出目标方法的名称

那么在配置文件中：

<aop:before method="myBefore" pointcut-ref="myPointCut"/>

说明：

*  method : 通知，即方法名（注意要和类中一致）
 *  pointcut-ref ： 切入点引用，可以与其他通知共享切入点。

2.后置通知

首先要在切面类中添加后置通知：

public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }

说明：参数2：类型Object，参数名可以任意但在配置文件中保持一致，代表的是目标方法执行后返回的值，如修改目标方法addUser:

public String addUser() {
        System.out.println("aspect.a_xml addUser");
            return "你好"
    }

将会打印出”你好“

那么在配置文件中：

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />

说明：returning 通知方法第二个参数的名称，如这里是ret

3 .环绕通知

首先要在切面类中添加环绕通知：

public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        Object obj = joinPoint.proceed();//手动执行目标方法 
        System.out.println("后");
        return obj;
    }

说明：返回值类型为Object；方法名任意；参数为org.aspectj.lang.ProceedingJoinPoint；需要抛出异常；必须要手动执行目标方法

那么在配置文件中：

<aop:around method="myAround" pointcut-ref="myPointCut"/>

4.抛出异常通知

首先要在切面类中添加抛出异常通知：

public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }

说明：参数2表示获得异常信息，类型Throwable ，参数名由throwing="e" 配置，例如：在方法updateUser中加入（int i/0;）执行到这将不在向下执行并打印出抛出异常通知：具体异常信息

那么在配置文件中：

<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>

说明：throwing 对应通知方法的第二个参数名称

5.最终通知

首先要在切面类中添加抛出异常通知：

public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }

那么在配置文件中：

<aop:after method="myAfter" pointcut-ref="myPointCut"/>

### 2.基于注解 ###

基于注解的方法就是要把xml文件中的配置内容替换掉，首先要在配置文件中配置扫描注解内容（添加新的命名空间）：

接下来就是替换，首先替换如下代码：

<bean id="userServiceId" class="com.shen.aspect.a_xml.UserServiceImpl"></bean>
    
    <bean id="myAspectId" class="com.shen.aspect.a_xml.MyAspect"></bean>

在目标类前面：

@Service("userServiceId")
    public class UserServiceImpl implements UserService {
    
    }

在切面类前面：

@Component
    public class MyAspect {
    
    }

注意：在这里不需要再配置beanid，原因后面解释。

之后就要替换aop部分的文件：

<aop:config>
        <aop:aspect ref="myAspectId">
            <aop:pointcut expression="execution(* com.shen.aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut"/>
            
        </aop:aspect>
    </aop:config>

<aop:config>自动执行，不需要管，aspect替代如下：

@Component
    @Aspect
    public class MyAspect {
    
    }

说明：正因为和切面类配置在一个地方，所以前面的切面类的beanid才不需要配置。

此外还要替换pointcut 其做法就是在切面中新加一个方法（其中方法名代表的就是id）：

//声明公共切入点
    @Pointcut("execution(* com.shen.aspect.b_anno.UserServiceImpl.*(..))")
    private void myPointCut(){
    
    }

1.替换前置通知

之前的配置文件如下：

<aop:before method="myBefore" pointcut-ref="myPointCut"/>

如果前面没有配置公共切入点也可以，如下：

//切入点当前有效
    @Before("execution(* com.shen.aspect.b_anno.UserServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }

2.替换后置通知

之前的配置文件如下：

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />

现在如下：

@AfterReturning(value="myPointCut()" ,returning="ret")
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }

3.替换环绕通知

之前的配置文件如下：

<aop:around method="myAround" pointcut-ref="myPointCut"/>

现在如下：

@Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();
        System.out.println("后");
        return obj;
    }

4.替换抛出异常通知

之前的配置文件如下：

<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>

现在如下：

@AfterThrowing(value="execution(* com.shen.aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }

5.替换最终通知

之前的配置文件如下：

<aop:after method="myAfter" pointcut-ref="myPointCut"/>

现在如下：

@After("myPointCut()")
    public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }

附：AOP常见术语

*  target：目标类，需要被代理的类。例如：UserService
 *  Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
 *  PointCut 切入点：已经被增强的连接点。例如：addUser()
 *  advice 通知/增强，增强代码。例如：after、before
 *   Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
 *  proxy 代理类
 *  Aspect(切面): 是切入点pointcut和通知advice的结合

一个线是一个特殊的面。

一个切入点和一个通知，组成成一个特殊的面。