10.基于XML的AOP开发

基于XML的AOP开发

1.入门例子

1.1 导入相关坐标

         <!--Spring 包中已经为AspectJ提供了实现-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.12</version>
        </dependency>

        <!--aspect 的织入
        aspectjweaver-1.8.13.jar:是AspectJ框架所提供的规范。
        -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

1.2 创建目标接口和目标类（内部有切点）

package com.lxg.aspectj;

public interface UserDao {
    public void addUser();
    public void deleteUser();
}

package com.lxg.aspectj;

public class UserDaoImpl implements UserDao{
    public void addUser() {
        System.out.println("添加用户");
    }

    public void deleteUser() {
        System.out.println("删除用户");
    }
}

1.3 创建切面类

package com.lxg.aspectj.xml;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {

    //前置通知
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知：模拟执行权限检查");
        System.out.println("目标类是："+joinPoint.getTarget());
        System.out.println(",被织入增强处理的方法是："+joinPoint.getSignature().getName());
    }

    //后置通知
    public void afterReturning(JoinPoint joinPoint){
        System.out.println("前置通知：模拟记录日志。。。");
        System.out.println("目标类是："+joinPoint.getTarget());
    }

    /**
     * 环绕通知
     * proceedingJoinPoint 是JoinPoint的子接口，表示可执行目标方法。
     * 1.必须是Object类型的返回值
     * 2.必须接收一个参数，类型为ProceedingJoinPoint
     * 3.必须是throws Throwable
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务");
        //执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        //结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务");
        return obj;
    }

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

    //最终通知
    public void myAfter(){
        System.out.println("最终通知：模拟方法结束后释放资源...");
    }
}

1.4 在XML中配置目标类和切面类

    <!--1.目标类-->
    <bean id="userDao" class="com.lxg.aspectj.UserDaoImpl"></bean>

    <!--2.切面类-->
    <bean id="myAspect" class="com.lxg.aspectj.xml.MyAspect"></bean>

1.5 在XML中配置织入关系

<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--1.目标类-->
    <bean id="userDao" class="com.lxg.aspectj.UserDaoImpl"></bean>

    <!--2.切面类-->
    <bean id="myAspect" class="com.lxg.aspectj.xml.MyAspect"></bean>

    <!--3.AOP编程-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="aspect" ref="myAspect">
            <!--配置切入点-->
            <aop:pointcut id="myPointCut" expression="execution(* com.lxg.aspectj.*.*(..))"/>
            <!--配置通知-->
                <!--前置通知-->
                <aop:before method="myBefore" pointcut-ref="myPointCut"></aop:before>
                <!--后置通知-->
                <aop:after-returning method="afterReturning" pointcut-ref="myPointCut"
                    returning="returnVal"></aop:after-returning>
                <!--环绕通知-->
                <aop:around method="myAround" pointcut-ref="myPointCut"></aop:around>
                <!--异常通知-->
                <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"></aop:after-throwing>
                <!--最终通知-->
                <aop:after method="myAfter" pointcut-ref="myPointCut"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

1.6 测试

package com.lxg.aspectj.xml;

import com.lxg.aspectj.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestXMLAspectj {
    public static void main(String[] args) {
        //初始化Spring容器，加载配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从容器中获取UserDao实例
        UserDao userDao = app.getBean("userDao", UserDao.class);
        //执行添加用户方法
        userDao.addUser();
    }
}

运行结果：

前置通知：模拟执行权限检查
目标类是：com.lxg.aspectj.UserDaoImpl@56de5251
,被织入增强处理的方法是：addUser
环绕开始：执行目标方法之前，模拟开启事务
添加用户
最终通知：模拟方法结束后释放资源...
环绕结束：执行目标方法之后，模拟关闭事务
前置通知：模拟记录日志。。。
目标类是：com.lxg.aspectj.UserDaoImpl@56de5251

2.XML配置AOP详解

2.1 切面配置

<aop:aspect id="aspect" ref="myAspect">

id: 用于定义该切面的唯一标识
ref: 引用普通的Spring Bean ，定义切面类

2.2 配置切入点

<aop:pointcut>

**id: ** 唯一标识
expression: 切入点表达式

切入点表达式的写法：
表达式语法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

• 访问修饰符可以省略
• 返回值类型、包名、类名、方法名可以使用星号* 代表任意
• 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
• 参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表
  如：

execution(public void com.itheima.aop.Target.method())
execution(void com.itheima.aop.Target.*(..))
execution(* com.itheima.aop.*.*(..))
execution(* com.itheima.aop..*.*(..))
execution(* *..*.*(..))

2.3 通知的配置

语法：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

名称	标签	说明
前置通知	aop:before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	aop:after-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	aop:around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	aop:throwing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	aop:after	用于配置最终通知。无论增强方式执行是否有异常都会执行

通知的常用属性及其描述

属性	描述
pointcut	指定切入点表达式，Spring将在匹配该表达式的连接点时织入该通知
pointcut-ref	指定一个已经存在的切入点名称，如配置代码中的myPointcut.
method	指定一个方法名称，指定将切面Bean中的增强方法转换为增强处理
throwing	只对元素有效，用于指定一个形参名，异常通知方法可以通过该形参访问目标方法所抛出的异常。
returning	只对元素有效，用于指定一个形参名，后置通知方法可以通过该形参访问目标方法的返回值。

2.4 后置通知和最终通知的异同

aop:after-returning:后置通知
aop:after:最终通知
相同点： 都是在目标方法执行之后执行。
区别： 后置通知只有在目标方法成功执行后才会被织入，而最终通知不论目标方法如何结束（包括成功执行和异常终止），他都会被织入。

另外，如果程序没有异常，异常通知将不会执行。