Spring AspectJ AOP框架注解原理解析

更新时间：2020年09月02日 15:24:07 作者：NopSmile

这篇文章主要介绍了Spring AspectJ AOP框架注解原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

什么是AspectJ

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

AspectJ是一个基于Java语言的AOP框架

Spring2.0以后新增了对AspectJ切点表达式支持

@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP

AspectJ表达式:

语法:execution(表达式)

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
execution(“ cn.itcast.spring3.demo1.dao.(..)”) ---只检索当前包
execution(“ cn.itcast.spring3.demo1.dao..(..)”) ---检索包及当前包的子包.
execution( cn.itcast.dao.GenericDAO+.(..)) ---检索GenericDAO及子类

AspectJ增强:

@Before 前置通知，相当于BeforeAdvice
@AfterReturning 后置通知，相当于AfterReturningAdvice
@Around 环绕通知，相当于MethodInterceptor
@AfterThrowing抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

基于注解

第一步:引入相应jar包.

aspectj依赖aop环境.

spring-aspects-3.2.0.RELEASE.jar

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

第二步:编写被增强的类:

UserDao

package cn.spring3.demo1;
/**
 * @author NOP
 * 被代理的对象
 */
public class UserDao {
  public void add() {
    // TODO Auto-generated method stub
    System.out.println("添加客户");
  }
  public void delete() {
    // TODO Auto-generated method stub
    System.out.println("删除客户");
    int i=1/0;
  }
  public String find() {
    // TODO Auto-generated method stub
    System.out.println("查询客户");
    return "fanhuizhi";
  }
  public void update() {
    // TODO Auto-generated method stub
    System.out.println("修改客户");
  }
}

第三步:使用AspectJ注解形式:

package cn.spring3.demo1;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * @author NOP 切面类：就是切点与增强结合
 * 前置增强
 */
@Aspect
public class MyAspect {
  @Before(value = "execution(* cn.spring3.demo1.UserDao.add(..))")//这里写表达式，写哪些类需要添加
  public void before(JoinPoint joinpoint) {
    System.out.println("前置增强..."+joinpoint);
  }

  @AfterReturning(value = "execution(* cn.spring3.demo1.UserDao.find(..))",returning="returnVal")//这里写表达式，写哪些类需要添加
  public void afterReturning(Object returnVal){
    System.out.println("后置增强..."+"方法的返回值"+returnVal);
  }

  @Around(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
  public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
    System.out.println("环绕前增强...");
    Object obj = proceedingJoinPoint.proceed();
    System.out.println("环绕后增强...");
    return obj;
  }

  @AfterThrowing(value = "execution(* cn.spring3.demo1.UserDao.delete(..))",throwing="ex")//这里写表达式，写哪些类需要添加
  public void afterThrowing(Throwable ex) throws Throwable{
    System.out.println("不跑了出异常了..."+ex.getMessage());
  }

  //@After(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")//这里写表达式，写哪些类需要添加
  @After("MyAspect.MyPointCut()")//类名.方法名
  public void after(){
    System.out.println("最终通知");//不管有没有异常都会通知
  }

  //仅是为了定义一个通用的表达式
  @Pointcut(value = "execution(* cn.spring3.demo1.UserDao.delete(..))")
  private void MyPointCut(){
  }
}

第四步:创建applicationContext.xml

 xmlns:aop="http://www.springframework.org/schema/aop"

* 引入aop的约束:
*<!-- 自动生成代理 底层就是AnnotationAwareAspectJautoProxyCreator -->
  <aop:aspectj-autoproxy/>

  <bean id="userDao" class="cn.spring3.demo1.UserDao"/>

  <bean id="MyAspect" class="cn.spring3.demo1.MyAspect"/>

第五步，编写测试类

package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

/**
 * @author NOP
 * 自动方式代理没有切点切面的增强
 */
@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
  @Autowired
  @Qualifier("userDao")
  private UserDao userDao;

  @Test
  public void demo1(){
    System.out.println("-----------------");
    userDao.add();
    System.out.println("-----------------");
    userDao.find();
    System.out.println("-----------------");
    userDao.delete();
    System.out.println("-----------------");
    userDao.update();
    System.out.println("-----------------");
  }
}
测试结果：
-----------------
前置增强...execution(void cn.spring3.demo1.UserDao.add())
添加客户
-----------------
查询客户
后置增强...方法的返回值fanhuizhi
-----------------
环绕前增强...
删除客户
最终通知
不跑了出异常了.../ by zero

AspectJ的通知类型:

@Before 前置通知，相当于BeforeAdvice
就在方法之前执行.没有办法阻止目标方法执行的.
@AfterReturning 后置通知，相当于AfterReturningAdvice
后置通知,获得方法返回值.
@Around 环绕通知，相当于MethodInterceptor
在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
@AfterThrowing抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

切点的定义:

@Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
private void myPointcut(){}

面试:

Advisor和Aspect的区别?

Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.

Aspect:可以支持多个切点和多个通知的组合

基于XML

ProductDao

第一步:编写被增强的类:

package cn.spring3.demo2;

public class ProductDao {

  public void add() {
    // TODO Auto-generated method stub
    System.out.println("添加商品");
  }

  public void delete() {
    // TODO Auto-generated method stub
    System.out.println("删除商品");

  }

  public void find() {
    // TODO Auto-generated method stub
    System.out.println("查询商品");
    int i = 1 / 0;
  }

  public String update() {
    // TODO Auto-generated method stub
    System.out.println("修改商品");
    return "woshitest";
  }

}

第二步:定义切面

package cn.spring3.demo2;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @author NOP
 * 切面类
 */
public class MyAspectXML {
  /*
   * 
   */
  public void before(){
    System.out.println("前置增强");
  }

  public void afterReturning(Object returnVal){
    System.out.println("后置增强"+returnVal);
  }

  public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
    System.out.println("环绕前增强");
    Object obj = proceedingJoinPoint.proceed();
    System.out.println("环绕后增强");
    return obj;
  }

  public void afterThrowing(Throwable ex){
    System.out.println("不跑了出异常了..."+ex.getMessage());
  }

  public void after(){
    System.out.println("最终通知");//不管有没有异常都会通知
  }
}

第三步:配置applicationContext.xml

<!-- 定义被增强的类 -->
  <bean id="productDao" class="cn.spring3.demo2.ProductDao"/>

  <!-- 定义切面 -->
  <bean id="myAspectXML" class="cn.spring3.demo2.MyAspectXML"/>

  <!-- 定义aop配置 -->
  <aop:config>
    <!-- 定义切点： -->
    <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

    <!-- 定义切点： -->
    <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.update(..))" id="mypointcutar"/>

    <!-- 定义切点： -->
    <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.delete(..))" id="mypointcutaar"/>

    <!-- 定义切点： -->
    <aop:pointcut expression="execution(* cn.spring3.demo2.ProductDao.find(..))" id="mypointcutaat"/>

    <aop:aspect ref="myAspectXML">
      <!-- 前置通知-->
      <aop:before method="before" pointcut-ref="mypointcut"/> 

      <!-- 后置通知 -->
      <aop:after-returning method="afterReturning" pointcut-ref="mypointcutar" returning="returnVal"/>

      <!-- 环绕通知 -->
      <aop:around method="around" pointcut-ref="mypointcutaar"/>

      <!-- 异常通知 -->
      <aop:after-throwing method="afterThrowing" throwing="ex" pointcut-ref="mypointcutaat"/>

      <!-- 最终通知//不管有没有异常都会通知 -->
      <aop:after method="after" pointcut-ref="mypointcutaat"/>
    </aop:aspect>
  </aop:config>

第四步:编写测试类

package cn.spring3.demo2;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {
  @Autowired
  @Qualifier("productDao")
  private ProductDao productDao;

  @Test
  public void demo1(){
    System.out.println("-----------------");
    productDao.add();
    System.out.println("-----------------");
    productDao.find();
    System.out.println("-----------------");
    productDao.delete();
    System.out.println("-----------------");
    productDao.update();
    System.out.println("-----------------");
  }
}

测试结果：
-----------------
前置增强
添加商品
-----------------
查询商品
不跑了出异常了.../ by zero
最终通知

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

java中的transient关键字解读
这篇文章主要介绍了java中的transient关键字解读,transient关键字的主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化,实际上也正是因此,在学习过程中很少用得上序列化操作,一般都是在实际开发中,需要的朋友可以参考下
2023-09-09
java编程的30个建议
这篇文章主要介绍了java编程的30个建议,需要的朋友可以参考下
2014-05-05
Spring外部化配置的几种技巧分享
在油管上看了龙之春的一个Spring tips 视频，讲述Spring外部化配置的几种技巧，收获颇多，想拿出来给大家分享下。对spring感兴趣的朋友可以了解下本文
2021-06-06
Java实现文件上传保存
这篇文章主要为大家详细介绍了Java实现文件上传保存，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-06-06
logback如何自定义日志存储
这篇文章主要介绍了logback如何自定义日志存储的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-08-08
linux部署出现java文件操作报错:java.io.FileNotFoundException解决办法
这篇文章主要g介绍了linux部署出现java文件操作报错:java.io.FileNotFoundException解决的相关资料,这个错误通常表示你的Spring Boot应用程序无法找到指定的文本文件,需要的朋友可以参考下
2023-12-12
Java NIO深入分析
本篇技术文章主要对Java新api（New IO）做了详细深入的讲解，有助于程序对NIO有更加深入的理解。
2017-12-12
Tomcat+Eclipse乱码问题解决方法与步骤
乱码问题是大家在日常开发过程中经常会遇到的问题,由于各自环境的不同,解决起来也费时费力,本文主要介绍一般性乱码问题的解决方法与步骤,开发工具采用Eclipse+Tomcat,统一设置项目编码UTF-8为例,感兴趣的朋友跟随小编一起看看吧
2023-08-08
java8中的默认垃圾回收器(GC)
这篇文章主要介绍了java8中的默认垃圾回收器(GC)，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-05-05
通过实践了解如何处理Java异常
Java中的异常处理不是一个简单的主题。初学者发现它很难理解，甚至有经验的开发者也可以花几个小时讨论如何以及应该抛出或处理哪些异常。下面我们通过实践来了解如何解决异常
2019-05-05