基于AspectJ的AOP开发--注解

短命女 2022-05-18 01:26 287阅读 0赞

在实际开发中，最常用到的是基于AspectJ的AOP开发方式。

AspectJ的使用用两种方式：注解式和xml配置式。下面分别讲解。

### 注解式： ###

首先，引用开发包。下面列出使用Spring AspectJ所需要的完整依赖：

<dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </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.10</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aspects</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>
        
      </dependencies>

实例中使用Junit进行测试，所以引入了junit包。

使用Spring进行开发，当然Spring的四个包不能少。

进行AOP的开发，aop联盟的包和Spring的aop 包也要引入。

使用aspectJ，要引入aspectJ框架的包和Spring的aspects包。

下面准备配置文件：因为需要aop开发，所以配置文件中需要有aop相关的约束。我们在IDEA中新建的spring配置文件是没有次约束的。可以在Spring包中的技术文件中找到：spring-framework-4.3.9.RELEASE\\docs\\spring-framework-reference\\html\\xsd-configuration.html。页面中靠近末尾的地方有：41.2.7 the aop schema这一章节，把相应的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">
    
        
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    </beans>

其中加上一句：<aop:aspectj-autoproxy></aop:aspectj-autoproxy>。它指定开启@AspectJ自动代理

@AspectJ提供的不同类型的增强处理，我们已经有文章说过了。此文中用到：@Before、@AfterReturning、@Around、@AfterThrowing、@After这五种处理。

上面做好了准备工作，下面正式进入。

使用注解进行开发步骤非常简单：

1：首先要有目标类。这里我们提供一个ProductDao类：

package com.imooc.aspectJ.demo1;
    
    public class ProductDao {
    
        public void save(){
            System.out.println("保存商品...");
        }
    
        public void update(){
            System.out.println("修改商品...");
        }
    
        public String delete(){
            System.out.println("删除商品...");
            return "6666666";
        }
    
        public void findOne(){
            System.out.println("查询一个商品...");
    //        int i = 1/0;
        }
    
        public void findAll(){
            System.out.println("查询所有商品...");
        }
    }

2：使用@AspectJ来定义切面类。MyAspectAnno

package com.imooc.aspectJ.demo1;
    
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    
    /**
     * 切面类
     */
    @Aspect
    public class MyAspectAnno {
    
        //前置增强注解
        @Before(value="point()")
        public void before(){
            System.out.println("前置增强=========");
        }
        //后置增强注解
        @AfterReturning(value="point()",returning = "result")
        public void afterReturning(Object result){
            System.out.println("后置增强========="+result);
        }
        //环绕增强注解
        @Around(value="execution(* com.imooc.aspectJ.demo1.ProductDao.delete(..))")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("环绕前处理============");
            //此处是执行原方法。这里可以不执行，就截断了代理方法的执行。
            Object obj = joinPoint.proceed();
            System.out.println("环绕后处理============");
            return obj;
        }
        //异常抛出注解
        @AfterThrowing(value="execution(* com.imooc.aspectJ.demo1.ProductDao.findOne(..))",throwing = "e")
        public void afterThrowing(Throwable e){
            System.out.println("异常抛出通知============="+e.getMessage());
        }
        //最终注解
        @After(value="execution(* com.imooc.aspectJ.demo1.ProductDao.findAll(..))")
        public void after(){
            System.out.println("最终通知===========");
        }
        //定义切入点
        @Pointcut(value="execution(* com.imooc.aspectJ.demo1.ProductDao.save(..))")
        public void point(){}
    }

如上面代码所示，切面类定义好后，可以定义增强处理。基本用法是：

**@Before(value="execution(<访问修饰符,可有可无>  <返回值类型>  <指定的方法名>(参数列表))")**

这个注解作用就是：定义了增强处理的类型，还定义了作用到哪个类的哪个方法上。结合(\*)的使用，可以变得非常灵活。

当然，增强注解都是作用于切面类的方法上的。也就是把方法内容织入到目标类的目标方法。

上面就完成了使用注解开发AOP。

具体到细节来说：

@Before注解，可以在注解的方法中传入JointPoint对象。此对象就是注解作用的目标类中的方法信息，就是连接点嘛。

@AfterReturning注解，可以定义方法返回值作为参数。当然也可以传入JointPoint对象。

@Around注解，此注解的方法要有返回值。要传入参数：ProceedingJointPoing  pjp    。返回值就是目标代理方法的返回值。一般使用Object作为返回值类型。此注解方法最牛的是可以拦截目标代理方法的执行。只要其中不在增强方法中写pjp.proceed()即可。

@AfterThrowing注解，此注解在代理方法抛出异常时执行。

@After注解，此注解不管代理方法是否发生异常，都执行。

**还有最有用的一点：定义切入点。**

因为，比如我们目标代理方法中需要用到了好几个注解。那么难道我们每个注解都指定该切入点表达式吗？这就做了重复工作。

定义切入点的操作是：在切面类中随便建一个方法，该方法没有实际意义，就是用来写切入点表达式的。上面代码中的point方法就是一个切入点。它指向了\* com.imooc.aspectJ.demo1.ProductDao.save(..))  这个方法。我们的前置增强和后置增强处理需要指向这个方法时，value值写此方法就行了。