Spring 基于 AspectJ 的 AOP 开发，包括注解方式和xml方式

仁王_雅治

541人浏览 · 2020-11-30 23:26:51

仁王_雅治 · 2020-11-30 23:26:51 发布

使用 AspectJ 实现 AOP

1、注解方式
2、xml 方式

相比传统方式更加灵活方便，学习重点

AspectJ 简介

AspectJ 是一个基于 Java 语言的 AOP 框架，Spring 2.0 以后新增了对 AspectJ 切点表达式支持

@AspectJ 是 AspectJ1.5 新增功能，通过 JDK5 注解技术，允许直接在 Bean 类中定义切面。新版本的 Spring 框架，建议使用 AspectJ 方式来开发 AOP

在这里插入图片描述

注解方式

环境准备

在这里插入图片描述

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.2.4.RELEASE</version>
    </dependency>
</dependencies>

新建一个 applicationContext.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 http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--开启AspectJ的注解开发，自动代理=====================-->
    <aop:aspectj-autoproxy/>

    
</beans>

AspectJ提供的通知类型

@Before 前置通知，相当于 BeforeAdvice
@AfterReturning 后置通知，相当于 AfterReturningAdvice
@Around 环绕通知，相当于 MethodInterceptor，能够阻止目标方法执行，在事务管理时常用到
@AfterThrowing 异常抛出通知，相当于 ThrowAdvice
@After 最终 final 通知，不管是否异常，该通知都会执行

在通知中通过value属性定义切点

通过 exceution 函数，可以定义切点的方法切入

语法：

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

<访问修饰符>? 表示访问修饰符是可以没有的

匹配所有类的 public 方法：execution(public * *(..)) 第一个星号表示返回值类型，第二个星号表示方法名

匹配指定包下所有类方法 execution(* com.learn.dao.*(..)) 第一个星号表示返回值类型（不是访问修饰符，访问修饰符可以省略）。com.learn.dao.* 不包含子包，com.learn.dao..* 表示包，子孙包下所有类

匹配指定类所有方法 execution(* com.learn.service.UserService.*(..))

匹配实现特定接口所有实现类方法 execution(* com.learn.dao.GenericDAO+.*(..)) +表示包含其子类，GenericDAO表示接口或抽象类等等

匹配所有 save 开头的方法 execution(* save*(..))

前置通知入门案例1

applicationContext.xml

<!--开启AspectJ的注解开发，自动代理=====================-->
<aop:aspectj-autoproxy/>
<!--目标类===================-->
<bean id="productDao" class="com.learn.aspectJ.demo1.ProductDao"/>

<!--定义切面-->
<bean class="com.learn.aspectJ.demo1.MyAspectAnno"/>

public class ProductDao {
    public void save(){
        System.out.println("保存商品...");
    }

    public String update(){
        System.out.println("修改商品...");
        return "hello";
    }

    public void delete(){
        System.out.println("删除商品...");
    }

    public void findOne(){
        System.out.println("查询一个商品...");
    }

    public void findAll(){
        System.out.println("查询所有商品...");
    }
}

**
 * 切面类
 */
@Aspect
public class MyAspectAnno {

    @Before(value="execution(* com.learn.aspectJ.demo1.ProductDao.*(..))")
    public void before(){
        System.out.println("前置通知==================");
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {
    @Resource(name="productDao")
    private ProductDao productDao;

    @Test
    public void demo1(){
        productDao.save();
        productDao.update();
        productDao.delete();
        productDao.findAll();
        productDao.findOne();
    }

}

执行结果：

ProductDao 中所有方法在执行方法前都会进行前置通知

前置通知==================
保存商品…
前置通知==================
修改商品…
前置通知==================
删除商品…
前置通知==================
查询所有商品…
前置通知==================
查询一个商品…

前置通知入门案例2

可以在方法中传入 JoinPoint 对象，用来获取切点信息

针对案例1，修改 MyAspectAnno

/**
 * 切面类
 */
@Aspect
public class MyAspectAnno {

    @Before(value="execution(* com.learn.aspectJ.demo1.ProductDao.save(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知=================="+joinPoint);
    }
}

执行结果：

前置通知==================execution(void com.learn.aspectJ.demo1.ProductDao.save())
保存商品…
修改商品…
删除商品…
查询所有商品…
查询一个商品…

后置通知入门案例1

 @AfterReturning(value="execution(* com.learn.aspectJ.demo1.ProductDao.update(..)))")
 public void afterReturing(){
     System.out.println("后置通知==================");
 }

执行结果：

保存商品…
修改商品…
后置通知==================
删除商品…
查询所有商品…
查询一个商品…

后置通知入门案例2

后置通知可以获得方法的返回值

public class ProductDao {

    public String update(){
        System.out.println("修改商品...");
        return "hello";
    }

}

@Aspect
public class MyAspectAnno {
    @AfterReturning(value="execution(* com.learn.aspectJ.demo1.ProductDao.update(..)))",returning = "result")
    public void afterReturing(Object result){
        System.out.println("后置通知=================="+result);
    }
}

执行结果：

修改商品…
后置通知==================hello

环绕通知入门案例1

around 方法的返回值就是目标方法执行的返回值，还可以阻止目标方法的执行

参数为 ProceedingJoinPoint 可以调用拦截目标方法执行

@Around(value="execution(* com.learn.aspectJ.demo1.ProductDao.delete(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("环绕前通知================");
    // 执行目标方法，不调用目标方法不会执行
    Object obj = joinPoint.proceed();
    System.out.println("环绕后通知================");
    return obj;
}

执行结果：

环绕前通知================
删除商品…
环绕后通知================

异常抛出通知入门案例1

通过设置 throwing 属性，可以设置发生异常对象参数。没有异常时不执行。应用场景较少

@AfterThrowing(value="execution(* com.learn.aspectJ.demo1.ProductDao.findOne(..))",throwing = "e")
public void afterThrowing(Throwable e){
    System.out.println("异常抛出通知=============="+e.getMessage());
}

ProductDao.java

public void findOne(){
    String str = null;
    str.substring(1);
    System.out.println("查询一个商品...");
}

public void findAll(){
    System.out.println("查询所有商品...");
}

测试类

productDao.findOne();
productDao.findAll();

执行结果：

执行 findOne 方法时报错了，因此没有走到 findAll 方法中

异常抛出通知==============null
错误信息

最终通知入门案例1

无论是否出现异常，最终通知总会被执行

@After(value="execution(* com.learn.aspectJ.demo1.ProductDao.findAll(..))")
public void after(){
    System.out.println("最终通知==================");
}

ProductDao.java

public void findAll(){
    String str = null;
    str.substring(1);
    System.out.println("查询所有商品...");
}

执行结果：

最终通知==================

通过 PonitCut 为切点命名

在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用 @PonitCut 进行定义

切点方法：private void 无参数方法，方法名为切点名

当通知多个切点时，可以使用 || 进行连接

@Before(value="myPointcut1()")
public void before(JoinPoint joinPoint){
    System.out.println("前置通知=================="+joinPoint);
}

@Pointcut(value="execution(* com.learn.aspectJ.demo1.ProductDao.save(..))")
private void myPointcut1(){}

xml 方式

环境准备

新建一个 applicationContext.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 http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

案例

上一个注解方式没有接口，这个例子我们用接口作为入门案例

applicationContext.xml

<!--XML的配置方式完成AOP的开发===============-->
<!--配置目标类=================-->
<bean id="customerDao" class="com.learn.aspectJ.demo2.CustomerDaoImpl"/>

<!--配置切面类-->
<bean id="myAspectXml" class="com.learn.aspectJ.demo2.MyAspectXml"/>

<!--aop的相关配置=================-->
<aop:config>
    <aop:pointcut id="pointcut1" expression="execution(* com.learn.aspectJ.demo2.CustomerDao.save(..))"/>
    <aop:pointcut id="pointcut2" expression="execution(* com.learn.aspectJ.demo2.CustomerDao.update(..))"/>
    <aop:pointcut id="pointcut3" expression="execution(* com.learn.aspectJ.demo2.CustomerDao.delete(..))"/>
    <aop:pointcut id="pointcut4" expression="execution(* com.learn.aspectJ.demo2.CustomerDao.findOne(..))"/>
    <aop:pointcut id="pointcut5" expression="execution(* com.learn.aspectJ.demo2.CustomerDao.findAll(..))"/>
    <!--配置AOP的切面-->
    <aop:aspect ref="myAspectXml">
        <!--配置前置通知,before方法名只要跟MyAspectXml类中的方法对应上即可-->
        <aop:before method="before" pointcut-ref="pointcut1"/>
        <!--配置后置通知-->
        <aop:after-returning method="afterReturing" pointcut-ref="pointcut2" returning="result"/>
        <!--配置环绕通知-->
        <aop:around method="around" pointcut-ref="pointcut3"/>
        <!--配置异常抛出通知-->
        <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="e"/>
        <!--配置最终通知-->
        <aop:after method="after" pointcut-ref="pointcut5"/>
    </aop:aspect>
</aop:config>

public interface CustomerDao {
    public void save();
    public String update();
    public void delete();
    public void findOne();
    public void findAll();
}

public class CustomerDaoImpl implements CustomerDao {
    public void save() {
        System.out.println("保存客户...");
    }

    public String update() {
        System.out.println("修改客户...");
        return "spring";
    }

    public void delete() {
        System.out.println("删除客户...");
    }

    public void findOne() {
        System.out.println("查询一个客户...");
    }

    public void findAll() {
        System.out.println("查询多个客户...");
    }
}

public class MyAspectXml {

    // 前置通知
    public void before(JoinPoint joinPoint){
        System.out.println("XML方式的前置通知=============="+joinPoint);
    }

    // 后置通知
    public void afterReturing(Object result){
        System.out.println("XML方式的后置通知=============="+result);
    }

    // 环绕通知
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("XML方式的环绕前通知==============");
        Object obj = joinPoint.proceed();
        System.out.println("XML方式的环绕后通知==============");
        return obj;
    }

    // 异常抛出通知
    public void afterThrowing(Throwable e){
        System.out.println("XML方式的异常抛出通知============="+e.getMessage());
    }

    // 最终通知
    public void after(){
        System.out.println("XML方式的最终通知=================");
    }
}

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value="classpath:applicationContext2.xml")
public class SpringDemo2 {

    @Resource(name="customerDao")
    private CustomerDao customerDao;

    @Test
    public void demo1(){
        customerDao.save();
        customerDao.update();
        customerDao.delete();
        customerDao.findOne();
        customerDao.findAll();
    }
}

执行结果：

XML方式的前置通知execution(void com.learn.aspectJ.demo2.CustomerDao.save())
保存客户…
修改客户…
XML方式的后置通知spring
XML方式的环绕前通知==============
删除客户…
XML方式的环绕后通知==============
查询一个客户…
查询多个客户…
XML方式的最终通知=================

魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

小参数・大码力・易部署 | Qwen3.6-27B上线魔乐社区，基于昇腾的部署教程来了

继一周前模型开源发布后，千问再度开源Qwen3.6-27B —— 一个拥有270亿参数的稠密多模态模型，也是社区呼声最高的模型规格。Qwen3.6-27B 依然支持多模态思考与非思考模式，在智能体编程方面达到了旗舰级表现，全面超越前代开源旗舰 Qwen3.5-397B-A17B（总参数397B / 激活参数17B的MoE模型）。作为稠密架构，它无需MoE路由即可部署，是开发者在实用、可广泛部署规模