＜Spring＞AOP的AspectJ注解-7

Spring框架一般都是基于AspectJ实现AOP操作

1、什么是AspectJ

AspectJ不是Spring框架的组成部分，是独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

2、基于AspectJ实现AOP操作

（1）基于xml配置文件方式实现
（2）基于注解方式实现（一般使用这个）

3、在项目工程里引入 AOP 相关依赖

目前总的依赖有以下

4、切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构

execution([权限修饰符] [返回值类型] [简单类名/全类名(类全路径)] [方法名] ([参数列表]))

例1 对com.pencil.spring5.dao.BookDao类里面的add方法进行增强

execution (* void com.pencil.spring5.dao.BookDao.add(...))

//*表示任意的权限修饰符

例2 对com.pencil.spring5.dao.BookDao类里面的所有方法进行增强

execution(* com.pencil.spring5.dao.BookDao.*(...))
//返回值类型省略

例3 对com.pencil.spring5.dao包里面的所有类，类里面的所有方法进行增强

execution(* com.pencil.dao.*.*(...))
//返回值类型省略

---

---

-------------------------------------------------------分割线----------------------------------------------------------------------------------------

AspectJ注解

1、创建类，在类里面定义方法

User类

package com.pencil.spring5.aopPac;

public class User {
    public void add()
    {
        System.out.println("User:add....");
    }
}

2、创建增强类（编写增强逻辑）

UserProxy类

package com.pencil.spring5.aopPac;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void before()
    {
        System.out.println("before....");
    }

    @After(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void after()
    {
        System.out.println("after...");
    }

    @AfterReturning(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void afterReturning()
    {
        System.out.println("afterReturning....");
    }

    @AfterThrowing(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void afterthrowing()
    {
        System.out.println("afterthrowing...");
    }

    @Around(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }


}

3、进行通知的配置

步骤如下

（1）在spring配置文件中，开启注解扫描

（2）使用注解创建User和UserProxy对象

（3）在增强类上面添加注解@Aspect，表示要生成代理对象

（4）在 spring 配置文件中开启生成代理对象

（1）在spring配置文件中，开启注解扫描

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: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.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:component-scan base-package="com.pencil.spring5.aopPac"></context:component-scan>
</beans>

（2）使用注解创建User和UserProxy对象

（3）在增强类上面添加注解@Aspect，表示要生成代理对象

（4）在 spring 配置文件中开启生成代理对象

在配置文件中再加上这一段生成代理对象

4、配置不同类型的通知

（1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

package com.pencil.spring5.aopPac;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void before()
    {
        System.out.println("before....");
    }

    @After(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void after()
    {
        System.out.println("after...");
    }

    @AfterReturning(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void afterReturning()
    {
        System.out.println("afterReturning....");
    }

    @AfterThrowing(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void afterthrowing()
    {
        System.out.println("afterthrowing...");
    }

    @Around(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }


}

特别需要留意的是@Around的编写

    @Around(value="execution(* com.pencil.spring5.aopPac.User.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }

测试代码

package com.pencil.spring5.test;

import com.pencil.spring5.aopPac.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class testAOP {
    @Test

    public void test()
    {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        User user=context.getBean("user", User.class);
        user.add();
    }


}

运行结果