基于XML的AOP开发以及使用AOP处理事务

最新推荐文章于 2022-05-22 19:26:16 发布

喝茶君

最新推荐文章于 2022-05-22 19:26:16 发布

阅读量214

点赞数

分类专栏：学习笔记文章标签： java spring 编程语言 aop 大数据

本文链接：https://blog.csdn.net/gsq123sohu/article/details/109603217

版权

学习笔记专栏收录该内容

19 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring中的AOP概念，包括面向切面编程的定义、作用和优势，以及AOP的基本概念如连接点、切入点、通知等。接着，通过XML配置方式演示了AOP的快速入门，包括导入依赖、创建目标接口和类、定义增强类、配置织入关系以及编写测试代码。最后，探讨了如何使用AOP处理事务，包括创建通知类、配置JDBC和Spring设置。

摘要由CSDN通过智能技术生成

一、AOP简介

1.1、什么是AOP

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态
代理实现程序功能的统一维护的一种技术。

1.2、AOP的作用及其优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强。
优势：减少重复代码，提高开发效率，并且便于维护。

1.3、AOP的底层实现

实际上，AOP的底层是通过Spring提供的的动态代理技术实现的。
在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介
入，在去调用目标对象的方法，从而完成功能的增强。

1.4、AOP的相关概念

现在就明确在Spring中有这么一种技术，能够在不修改方法代码的基础上对方法功能进行增强就行了。
Joinpoint（连接点）：有可能被增强的方法
Pointcut（切入点）：实际被增强的方法
Advice（通知/ 增强）：封装增强业务逻辑的方法
Aspect（切面）：切点+通知
Weaving（织入）：将切点与通知结合的过程

1.5、AOP开发需要明确的事项

需要编写的内容
编写核心业务代码（目标类的目标方法）
编写切面类，切面类中有通知（增强功能方法）
在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合
换一种说法：
谁是切点（切点表达式配置）
谁是增强（切面类中的增强方法）
将切点和通知进行织入配置

二、基于XML的AOP开发

2.1、快速入门

主要步骤：

导入Jar包；
创建目标接口和目标类；
创建增强类；
将目标类和增强类的对象创建权交给Spring；
配置织入关系
测试

2.1.1、导入Jar包

2.1.2、创建目标接口和目标类

2.1.3、创建增强类

2.1.4、将目标类和增强类的对象创建权交给Spring

 <!--配置目标对象-->
    <bean id="manWaiter" class="com.hpe.aop.impl.ManWaiter"/>
    <!--配置增强对象-->
    <bean id="aspect" class="com.hpe.aop.WaiterAspect"/>

2.1.5、配置织入关系

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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="manWaiter" class="com.hpe.aop.impl.ManWaiter"/>
    <!--配置增强对象-->
    <bean id="aspect" class="com.hpe.aop.WaiterAspect"/>
    <!--配置织入-->
    <aop:config>

        <aop:aspect ref="aspect">
            <!--配置waiter的food方法执行时要使用waiterAspect的before方法进行前置增强-->
            <!--
                aop：before  配置前置增强
                method：指定增强使用的方法
                pointcut：配置切点表达式
                execution([修饰符] 返回值类型 包名.类名.方法名(参数))
                1) 访问修饰符可以省略
                2) 返回值类型、包名、类名、方法名可以使用星号*代表任意
                3) 包名与类名之间两个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
                4) 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
            -->
            <!--只给food()添加了增强-->
            <!--<aop:before method="before" pointcut="execution(public void com.hpe.aop.impl.ManWaiter.food())"/>-->
            <!--给aop下面的所有的类和子包中的类添加了前置增强-->
            <aop:before method="before" pointcut="execution(* com.hpe.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

2.1.6、测试代码

2.2、XML配置AOP详解

2.2.1、切点表达式

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

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

案例：
execution(public void com.hpe.aop.ManWaiter.food())
execution(void com.hpe.aop.ManWaiter.food())
execution(* com.hpe.aop.ManWaiter.(…))
execution( com.hpe.aop….(…))

2.2.2、通知的类型

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

修改增强类

public class WaiterAspect {
    //前置通知
    public void before(){
        System.out.println("你好....");
    }
    //后置通知
    public void afterReturning(){
        System.out.println("吃好喝好...");
    }
    //环绕通知
    public void around(ProceedingJoinPoint pjp){

        try {
            System.out.println("你好...");
            Object proceed = pjp.proceed();
            System.out.println("吃好喝好...");
        } catch (Throwable throwable) {
            System.out.println("....");
        }finally {
            System.out.println("再见...");
        }

    }
    //异常抛出通知
    public void afterThrowing(){
        System.out.println("....");
    }
    //最终通知
    public void after(){
        System.out.println("再见....");
    }
}

配置织入关系

<!--配置目标对象-->
    <bean id="manWaiter" class="com.hpe.aop.impl.ManWaiter"/>
    <!--配置增强对象-->
    <bean id="aspect" class="com.hpe.aop.WaiterAspect"/>
    <!--配置织入-->
    <aop:config>

        <aop:aspect ref="aspect">
            <!--配置waiter的food方法执行时要使用waiterAspect的before方法进行前置增强-->
            <!--
                aop：before  前置通知
                aop:after-returning 后置通知
                aop:after-throwing  异常抛出通知
                aop:after  最终通知
                aop:around  环绕通知
                method：指定增强使用的方法
                pointcut：配置切点表达式
                pointcut-ref  用来引入提取出来的切入点
                切点表达式：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
                1) 访问修饰符可以省略
                2) 返回值类型、包名、类名、方法名可以使用星号*代表任意
                3) 包名与类名之间两个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
                4) 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
            -->
            <!--只给food()添加了增强-->
            <!--<aop:before method="before" pointcut="execution(public void com.hpe.aop.impl.ManWaiter.food())"/>-->
            <!--给aop下面的所有的类和子包中的类添加了前置增强-->
            <!--<aop:before method="before" pointcut="execution(* com.hpe.aop.*.*(..))"/>-->
            <!--提取出来的切入点-->
            <aop:pointcut id="pt" expression="execution(* com.hpe.aop.*.*(..))"/>
            <aop:before method="before" pointcut-ref="pt"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pt"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
            <aop:after method="after" pointcut-ref="pt"/>
            <!--<aop:around method="around" pointcut-ref="pt"/>-->
        </aop:aspect>
    </aop:config>

通常情况下，环绕通知都是独立使用的。

2.2.3、切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替
pointcut属性来引入抽取后的切点表达式。

<aop:pointcut id="pt" expression="execution(* com.hpe.aop.*.*(..))"/>
<aop:before method="before" pointcut-ref="pt"/>
<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
<aop:after method="after" pointcut-ref="pt"/>

三、使用AOP处理事务

该部分内容在《02_SpringIOC和DI案例及动态代理》3.1、基础工程搭建的基础之上进行操作

3.1、创建通知类

TransactionAspect.java

3.2、编写JDBC配置文件

3.3、在Spring配置文件中进行配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--引入外部文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置datasourse 引入jdbc配置文件的数据-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.drivername}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--为工具类创建连接池-->
    <bean class="com.hpe.util.JdbcUtils">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置queryrunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner"/>
    <!--配置dao -->
    <bean id="accountDao" class="com.hpe.dao.impl.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner"/>
    </bean>
    <!--配置service  目标对象到此配置完成-->
    <bean id="accountService" class="com.hpe.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!--增强对象-->
    <bean id="aspect" class="com.hpe.aspect.TransactionAspect"/>
    <!--织入-->
    <aop:config>
        <aop:aspect ref="aspect">
            <aop:pointcut id="pt" expression="execution(* com.hpe.service..*.*(..))"/>
            <aop:before method="before" pointcut-ref="pt"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pt"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>
</beans>

3.4、测试

public class MyTest {
    @Test
    public void test1() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

        IAccountService service = (IAccountService) context.getBean("accountService");
        service.transfer(1, 2, 10);
    }
}