SpringAOP切入方式

AOP与OOP是什么关系？

AOP的实现技术有多种，其中与Java无缝对接的是一种称为AspectJ的技术，Spring AOP 与AspectJ 实现原理上并不完全一致，但功能上是相似的。AOP的出现确实解决外围业务代码与核心业务代码分离的问题，但它并不会替代OOP，如果说OOP的出现是把编码问题进行模块化，那么AOP就是把涉及到众多模块的某一类问题进行统一管理

切面（Aspect）包含了切点(PointCut)、连接点（JoinPoint）;额外还有通知（Advice）,织入（Weaving）,引入（Introduce）。

package springMVCmybatis.com.my.aop;
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Around; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.annotation.Pointcut; 
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.springframework.core.annotation.Order;
@Aspect
// 切面执行顺序
@Order(3)
public class MyAopTest {
      @Pointcut("execution(* springMVCmybatis..addController.addEmp(..))") 
        private void pointCutMethod() { 
        } 
       
      @Pointcut("execution(* springMVCmybatis.com.my.aop.UserServiceImp.*(..))") 
        private void testAOP() { 
        }
      /*
       *  声明前置通知 ，JoinPont是srpring提供的静态变量，
       *  通过joinPoint参数可以获得目标方法的类名，方法参数，方法名等信息，这个参数可有可无。
       */
        
        @Before("pointCutMethod() || testAOP()") 
        public void doBefore(JoinPoint joinPoint) { 
            System.out.println("@Before:开始添加--order=3"); 
        } 
       
        //声明后置通知 ，如果result的类型与proceed执行的方法返回的参数类型不匹配那么就不会执行这个方法
        @AfterReturning(pointcut = "pointCutMethod()  || testAOP()", returning = "result") 
        public void doAfterReturning(String result) { 
            System.out.println("@AfterReturning:后置通知--order=3"); 
            System.out.println("---" + result + "---"); 
        } 
       
        //声明例外通知 
        @AfterThrowing(pointcut = "pointCutMethod() || testAOP()", throwing = "e") 
        public void doAfterThrowing(Exception e) { 
            System.out.println("@AfterThrowing:例外通知--order=3"); 
            System.out.println(e.getMessage()); 
        } 
       
        //声明最终通知 
        @After("pointCutMethod() || testAOP()") 
        public void doAfter() { 
            System.out.println("@After:最终通知--order=3"); 
        } 
      /*
       * 声明环绕通知
       * 参数必须是ProceedingJoinPoint，通过该对象的proceed()方法来执行目标函数，
       * proceed()的返回值就是环绕通知的返回值，proceedingJoinPoint是个接口，
       * implement JoinPoint,所以也可以获得目标函数的类名，方法名等参数。
       */
         
        @Around("pointCutMethod() || testAOP()") 
        public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
            System.out.println("@Around:进入方法---环绕通知--order=3"); 
            Object o = pjp.proceed(); 
            System.out.println("@Around:退出方法---环绕通知--order=3"); 
            return o; 
        }
 
        
}

上面是我写的一个例子，结合例子我们来看看这些核心的概念：

2.1、切面(Aspect)：是一个类，里面定义了通知与切点。

2.2、切点(PointCut)：表达式(表达式有很多种，如方法签名表达式，类型签名表达式，还有其他的表达式，)。就是告诉程序要在执行哪些核心业务的时候，执行非核心的业务。

2.3、通知（advice）:五种通知方式：

• @Before：前置通知，在调用目标方法之前执行通知定义的任务
• @After：后置通知，在目标方法执行结束后，无论执行结果如何都执行通知定义的任务
• @After-returning：后置通知，在目标方法执行结束后，如果执行成功，则执行通知定义的任务
• @After-throwing：异常通知，如果目标方法执行过程中抛出异常，则执行通知定义的任务
• @Around：环绕通知，在目标方法执行前和执行后，都需要执行通知定义的任务。

3.1：方法签名表达式

1 2	execution(<修饰符模式>?<返回类型模式><方法所在类的完全限定名称模式>(<参数模式>)<异常模式>?) execution(modifiers-pattern? ret-type-pattern fully-qualified-class-name (param-pattern) throws-pattern?)

其实如果单纯的给定这个表达式还是不容易记忆，下面对比方法的定义来记忆，一个java方法的全部定义方式可以表示成下面的方式：

public String springMVCmybatic.com.my.aop.UserServiceImp(String a, int b) throw Exception{

}

• modifier-pattern?：表示方法的修饰符，可有可无；对应的就是 public
• ret-type-pattern：表示方法的返回值；对应的就是 String
• fully-qualified-class-name  方法所在类的完全限定名称；对应的就是 springMVCmybatic.com.my.aop.UserServiceImp
• param-pattern：表示方法的参数；对应的就是 String a, int b
• throws-pattern：表示方法抛出的异常，可有可无；对应的就是 throw Exception

3.2：&&，||，！