Spring笔记——AOP（XML方式）

相比于注解方法，使用XML配置方式有如下几个优点：
☞ 如果应用没有使用1.5以上的JDK版本，那么应用只能使用XML配置方式来管理切面、切入点和增强处理等
☞ 采用XML配置方式时，对早期的Spring用户来说更加习惯，而且这种方式允许使用纯粹的POJO来支持AOP。当使用AOP作为工具来配置企业服务时，XML会是一个很好的选择。当使用XML风格时，我们可以在配置文件中清晰的看出系统中存在哪些切面。

使用XML配置方式，则存在如下几个缺点：
☞ 使用XML配置方式不能将切面、切入点、增强处理等封装到一个地方。当我们需要查看切面、切入点、增强处理时，必须同时结合Java文件和XML配置文件来查看；但使用@AspectJ时，则只需一个单独的类文件即可看到切面、切入点和增强处理的全部信息
☞ XML配置方式比@AspectJ方式有更多的限制：仅支持”singleton”切面Bean，不能在XML中组合多个命名连接点的声明

在Spring配置文件中，所有切面、切入点和增强处理都必须定义在<aop:config.../>元素内部。<beans.../>元素下可以包含多个<aop:config.../>元素，一个<aop:config.../>可以包含pointcut、advisor和aspect元素，且这三个元素必须按照此顺序来定义。

1.配置切面

定义切面使用<aop:aspect.../>元素，使用该元素来定义切面时，其实质是将一个已有的Spring Bean转换成切面Bean，所以需要先定义一个普通的Spring Bean。
配置<aop:aspect.../>元素时可以指定如下是三个属性：
☞ id：定义该切面的标识名
☞ ref：指定以指定ref属性所引用的普通Bean作为切面Bean
☞ order：指定该切面Bean的优先级，该属性的作用与前面@AspectJ中@Order、Order接口作用完全一样，order属性值越小，该切面对应的优先级越高

如下配置片段定义了一个切面：

<aop:config>
    <!-- 将容器中的afterAdviceBean转换成切面Bean，切面Bean的新名称为afterAdviceAspect -->
    <aop:aspect id="afterAdviceAspect" ref="afterAdviceBean">
        ...
    </aop:aspect>
</aop:config>
<!-- 定义一个普通Bean实例，该Bean实例将作为Aspect Bean -->
<bean id="afterAdviceBean" class="main.java.aspect.AfterAdviceTest"></bean>

2.配置增强处理

与使用@AspectJ完全一样，使用XML一样可以配置Before、After、AfterReturning、AfterThrowing和Around5种增强处理，而且完全支持和@Aspect完全一样的语义
使用XML配置增强处理分别依赖于如下几个元素：
☞ <aop:before.../>：配置before增强处理
☞ <aop:after.../>：配置after增强处理
☞ <aop:after-returning.../>：配置after-returning增强处理
☞ <aop:after-throwing.../>：配置after-throwing增强处理
☞ <aop:around.../>：配置around增强处理

上面这些元素都不支持使用子元素，但通常可以指定如下属性。
☞ pointcut：概属性指定一个切入表达式，Spring将在匹配该表达式的连接点时织入该增强处理
☞ pointcut-ref：该属性指定一个已经存在的切入点名称，通常pointcut和pointcut-ref两个属性只需要使用其中之一
☞ method：该属性指定一个方法名，指定切面Bean的该方法将作为增强处理
☞ throwing：该属性只对<aop:after-throwing.../>元素有效，用于指定一个形参名，AfterThrowing增强处理方法可通过该形参访问目标方法所抛出的异常
☞ returning：该属性只对<aop:after-returning.../>元素有效，用于指定一个形参名，AfterReturuning增强处理方法可通过该形参访问目标方法的返回值

XML配置方式和@AspectJ方式一样支持组合切入点表达式，但XML配置方式不再使用简单的&&、||和！作为组合运算，而是使用如下三个组合运算符：and、or、和not

public class FourAdviceTest {
    // 定义Around增强处理
    public Object processTx(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("Around增强：执行目标方法之前，模拟开始事物...");
        // 访问执行目标方法的参数
        Object[] args = jp.getArgs();
        // 当执行目标方法的参数存在
        // 且第一个参数是字符串参数
        if (args != null && args.length > 0 && args[0].getClass() == String.class) {
            // 改变第一个目标方法的第一个参数
            args[0] = "被改变的参数";
        }
        // 执行目标方法，并保存目标方法执行后的返回值
        Object rvt = jp.proceed(args);
        System.out.println("Around增强：执行目标方法之前，模拟结束事物...");
        return rvt + "新曾的内容";
    }

    // 定义Bfore增强处理
    public void authority(JoinPoint jp) {
        System.out.println("Before增强：模拟执行权限检查");
        // 返回被织入增强处理的目标方法
        System.out.println("Before增强处理：被织入增强处理的目标方法为：" + jp.getSignature().getName());
        // 访问执行目标方法的参数
        System.out.println("Before增强：目标方法的参数为：" + Arrays.toString(jp.getArgs()));
        System.out.println("Before增强：被织入增强处理的目标对象为：" + jp.getTarget());
    }

    // 定义AfterReturning增强处理
    public void log(JoinPoint jPoint, Object rvt) {
        System.out.println("AfterReturning增强：获取目标方法返回值：" + rvt);
        System.out.println("AfterReturning增强：模拟日志记录功能...");
        // 返回被织入增强处理的目标方法
        System.out.println("AfterReturning增强：被织入增强处理的目标方法为：" + jPoint.getSignature().getName());
        // 访问执行目标方法的参数
        System.out.println("AfterReturning增强：目标方法的参数为：" + Arrays.toString(jPoint.getArgs()));
        // 访问被增强处理的目标对象
        System.out.println("AfterReturning增强：被织入增强处理的目标对象为：" + jPoint.getTarget());
    }

    public void release(JoinPoint jp) {
        System.out.println("After增强：模拟方法结束后的释放资源...");
        // 被返回织入增强处理的目标方法
        System.out.println("After增强：被织入增强处理的目标方法为：" + jp.getSignature().getName());
        // 访问执行目标方法的参数
        System.out.println("After增强：目标方法的参数为：" + Arrays.toString(jp.getArgs()));
        // 访问被增强处理的目标对象
        System.out.println("After增强：被织入增强处理的目标对象为：" + jp.getTarget());
    }
}

public class SecondAdviceTest {
    // 定义Before增强处理
    public void authority(String aa) {
        System.out.println("目标方法的参数为：" + aa);
        System.out.println("①号Before增强：模拟执行权限检查");
    }
}

<?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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <aop:config>
        <!-- 将的fourAdviceBean转换成切面Bean，切面Bean的新名称为fourAdviceAspect，指定该切面的优先级为2 -->
        <aop:aspect id="fourAdviceAspect" ref="fourAdviceBean" order="2">
            <!-- 定义一个After增强处理，直接指定切入点表达式，以切面Bean中的release()方法作为增强处理方法 -->
            <aop:after pointcut="execution(* main.java.service.*.*(..))" method="release" />
            <!-- 定义一个Before增强处理，直接指定切入点表达式，以切面Bean中的authority()方法作为增强处理方法 -->
            <aop:before pointcut="execution(* main.java.service.*.*(..))" method="authority" />
            <!-- 定义一个AfterReturning增强处理， 直接指定切入点表达式，以切面Bean中的log()方法作为增强处理方法 -->
            <aop:after-returning pointcut="execution(* main.java.service.*.*(..))" method="log" returning="rvt" />
            <!-- 定义一个Around增强处理， 直接指定切入点表达式，以切面Bean中的processTx()方法作为增强处理方法 -->
            <aop:around pointcut="execution(* main.java.service.*.*(..))" method="processTx" />
        </aop:aspect>

        <!-- 将secondAdviceBean转换成切面Bean，切面Bean的新名称为：secondAdviceAspect，指定该切面的优先级为1，改切面里的增强处理将被优先织入 -->
        <aop:aspect id="secondAdviceAspect" ref="secondAdviceBean" order="1">
            <!-- 定义一个Before增强处理，直接指定切入点表达式，以切面Bean中的authority()方法作为增强处理方法，且该参数必须为String类型 -->
            <aop:before pointcut="execution(* main.java.service.*.*(..)) and args(aa)" method="authority"/>
        </aop:aspect>
    </aop:config>
    <!-- 定义一个普通组件Bean -->
    <bean id="chinese" class="main.java.service.impl.Chinese"/>
    <!-- 定义一个普通Bean实例，该Bean实例将被作为Aspect Bean -->
    <bean id="fourAdviceBean" class="main.java.aspect.FourAdviceTest" />
    <!-- 再定义一个普通Bean实例，该Bean实例将被作为Aspect Bean -->
    <bean id="secondAdviceBean" class="main.java.aspect.SecondAdviceTest" />
</beans>

3.配置切入点

Spring提供了<aop:pointcut.../>元素来定义切入点。当把<aop:pointcut.../>作为<aop:config.../>的子元素定义时，表明该切入点可被多个切面共享；当把<aop:pointcut.../>作为<aop:aspect.../>的子元素定义时，表明该切入点只能在对应的切面中有效。
配置<aop:pointcut.../>元素时通常需要指定如下两个属性：
☞ id：指定该切入点的标识名
☞ expression：指定该切入点关联的切入点表达式

如下配置片段定义了一个简单的切入点：

<!-- 定义一个简单切入点 -->
<aop:pointcut id="myPointcut" expression="execution(* main.java.service.*.*(..))" />

上面的配置片段既可作为<aop:config.../>的子元素，用于配置全局切入点；也可作为<aop:aspect.../>的子元素，用于配置仅对该切面有效的切入点。