声明：该文是参考这位博主；
YSOcean-Spring详解

1.什么是AspectJ?

• AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，也可以说 AspectJ 是一个基于 Java 语言的 AOP 框架。

2.切入点表达式

• 语法：execution(修饰符 返回值 包.类.方法名(参数) throws异常)
• 一个简单的demo：

<aop:pointcut id="pointcut" expression="execution(* com.springaop.service.impl.*.*(..))"/>

• 盗一张图

  
  切入单表达式思维导图.png

注意：如果切入点表达式有多个不同目录呢？ 可以通过 || 来表示或的关系。

<aop:pointcut expression="execution(* com.ys.*Service1.*(..)) ||
                          execution(* com.ys.*Service2.*(..))" id="myPointCut"/>
　//表示匹配 com.ys包下的，以 Service1结尾或者以Service2结尾的类的任意方法。

AOP 切入点表达式支持多种形式的定义规则：

- 1.execution:匹配方法的执行（常用）
        execution(public *.*(..))
- 2.within:匹配包或子包中的方法(了解)
    within(com.ys.aop..*)
- 3.this:匹配实现接口的代理对象中的方法(了解)
    this(com.ys.aop.user.UserDAO)
- 4.target:匹配实现接口的目标对象中的方法(了解)
    target(com.ys.aop.user.UserDAO)
- 5.args:匹配参数格式符合标准的方法(了解)
    args(int,int)
- 6.bean(id)  对指定的bean所有的方法(了解)
    bean('userServiceId')

3.Aspect通知类型

- 1.before:前置通知(应用：各种校验)
    在方法执行前执行，如果通知抛出异常，阻止方法运行
- 2.afterReturning:后置通知(应用：常规数据处理)
    方法正常返回后执行，如果方法中抛出异常，通知无法执行
    必须在方法执行后才执行，所以可以获得方法的返回值。
- 3.around:环绕通知(应用：十分强大，可以做任何事情)
    方法执行前后分别执行，可以阻止方法的执行
    必须手动执行目标方法
- 4.afterThrowing:抛出异常通知(应用：包装异常信息)
    方法抛出异常后执行，如果方法没有抛出异常，无法执行
- 5.after:最终通知(应用：清理现场)
    方法执行完毕后执行，无论方法中是否出现异常

这里最重要的是around,环绕通知，它可以代替上面的任意通知。

try{
     //前置：before
    //手动执行目标方法
    //后置：afterRetruning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

AOP具体实例

• pom文件，在上一篇文章里面有，我就不CV了。

Student

public class Student {
    String name;
    Integer age;
    String address;
  //getter,setter方法省略
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

StudentService

public interface StudentService {
    /**
     * 添加学生
     * @param student
     * @return
     */
    int addStudent(Student student);

    /**
     * 删除学生
     * @param name
     * @return
     */
    int deleteStudent(String name);
}

StudentServiceImpl

public class StudentServiceImpl implements StudentService {
    public int addStudent(Student student) {
        System.out.println("添加学生:"+student.toString());
        return 1;
    }
    public int deleteStudent(String name) {
        System.out.println("删除学生:"+name);
        return 1;
    }
}

MyAspect

public class MyAspect {
    /**
     * 前置通知
     * JoinPoint 能获取目标方法的一些基本信息
     * @param joinPoint
     */
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }

    /**
     * 后置通知
     * @param joinPoint
     * @param ret
     */
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }

    /**
     * 最终通知
     */
    public void myAfter(){
        System.out.println("最终通知");
    }
}

bean.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-3.0.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
">
    <!--1、 创建目标类 -->
    <bean id="studentService" class="com.springaop.service.impl.StudentServiceImpl"></bean>
    <!--2、创建切面类（通知）  -->
    <bean id="myaspect" class="com.springaop.aop.aspect.MyAspect"></bean>

    <!--3、aop编程 
        3.1 导入命名空间
        3.2 使用 <aop:config>进行配置
                proxy-target-class="true" 声明时使用cglib代理
                如果不声明，Spring 会自动选择cglib代理还是JDK动态代理
            <aop:pointcut> 切入点 ，从目标对象获得具体方法
            <aop:advisor> 特殊的切面，只有一个通知 和 一个切入点
                advice-ref 通知引用
                pointcut-ref 切入点引用
        3.3 切入点表达式
            execution(* com.ys.aop.*.*(..))
            选择方法         返回值任意   包             类名任意   方法名任意   参数任意
    -->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.springaop.service.impl.*.*(..))"/>
        <aop:aspect ref="myaspect">
 <!-- 3.1 前置通知
                <aop:before method="" pointcut="" pointcut-ref=""/>
                    method : 通知，及方法名
                    pointcut :切入点表达式，此表达式只能当前通知使用。
                    pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
                通知方法格式：public void myBefore(JoinPoint joinPoint){
                    参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等
        -->
            <aop:before method="myBefore" pointcut-ref="pointcut"></aop:before>
       <!-- 后置通知  ,目标方法后执行，获得返回值
                <aop:after-returning method="" pointcut-ref="" returning=""/>
                    returning 通知方法第二个参数的名称
                通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
                    参数1：连接点描述
                    参数2：类型Object，参数名 returning="ret" 配置的
        -->
            <aop:after-returning method="myAfterReturning" pointcut-ref="pointcut"
                                 returning="ret"></aop:after-returning>
          <!-- 3.3 最终通知 -->  
            <aop:after method="myAfter" pointcut-ref="pointcut"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

测试

 @Test
    public void TestAop1() {
        //从spring容器获得 //1 获得容器
        String xmlPath = "bean.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        //2获得内容 --不需要自己new，都是从spring容器获得
        StudentService studentService = (StudentService) applicationContext.getBean("studentService");
        //添加
        Student student = new Student();
        student.setName("HeloWxl");
        student.setAddress("安徽合肥");
        student.setAge(22);
        studentService.addStudent(student);
        //删除
        studentService.deleteStudent("HeloWxl");
    }

测试结果

测试结果.png

异常通知测试

• 1.在StudentServiceImpl的addStudent方法添加一个异常，例如：

        int i = 1/0;//显然这里会抛出除数不能为 0

• 2.bean.xml添加

<!--  抛出异常
               <aop:after-throwing method="" pointcut-ref="" throwing=""/>
                   throwing ：通知方法的第二个参数名称
               通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
                   参数1：连接点描述对象
                   参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
       -->
<aop:after-throwing method="myAfterThrowing" pointcut-ref="pointcut" throwing="e"/>

• 3.测试

  
  异常通知.png

环绕通知测试

• 1.修改MyAspect

public class MyAspect {
    /**
     * 环绕通知
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前置通知");
        //手动执行目标方法
        Object obj = joinPoint.proceed();

        System.out.println("后置通知");
        return obj;
    }
}

• 2.bean.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-3.0.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
">
    <bean id="studentService" class="com.springaop.service.impl.StudentServiceImpl"></bean>
    <bean id="myaspect" class="com.springaop.aop.aspect.MyAspect"></bean>

    <!--AOP配置-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.springaop.service.impl.*.*(..))"/>
        <aop:aspect ref="myaspect">
            <aop:around method="myAround" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

• 3.测试

  
  image.png