AOP切面通知

需要用的基本的jar包：

aopalliance-1.0.jar
aspectj-1.6.8.jar
aspectjweaver-1.6.8.jar
commons-logging-1.1.3.jar
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar

1：基于注解的日志通知和验证通知：

定义接口：

 package com.yinfu.spring.aop.impl;

 public interface ArithmeticCalculator {

     public int add(int i,int j);
     public int sub(int i,int j);
     public int mul(int i,int j);
     public int div(int i,int j);
 }

定义实现类：

 package com.yinfu.spring.aop.impl;

 import org.springframework.stereotype.Component;

 @Component("arithmeticCalculator")
 public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

     @Override
     public int add(int i, int j) {

         int result = i+j;
         return result;
     }

     @Override
     public int sub(int i, int j) {
         int result = i-j;
         return result;
     }

     @Override
     public int mul(int i, int j) {
         int result = i*j;
         return result;
     }

     @Override
     public int div(int i, int j) {
         int result = i/j;
         return result;
     }

 }

定义spring的配置文件：applicationContext.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"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

 <!--     <bean id="helloWorld" class="com.yinfu.spring.beans.HelloWorld">
         <property name="name" value="fuck"></property>
     </bean> -->
     <!-- 配置自动扫描包 -->
     <context:component-scan base-package="com.yinfu.spring.aop.impl"></context:component-scan>

     <!-- 使AspectJ注解起作用:自动为匹配的类生成代理对象 -->
     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 </beans>

定义切面类：

 package com.yinfu.spring.aop.impl;

 import java.util.Arrays;
 import java.util.List;

 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;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;

 /**
  * 把此类声明为一个切面
  * 首相把该类放到IOC容器中，然后在声明为切面
  * @Aspect声明此类是一个切面
  * @Order声明切面的优先级,值越小优先级越高
  * @author lusong
  *
  */
 @Order(1)
 @Aspect
 @Component
 public class LoggingAspect {

     //定义一个方法用于声明切入点表达式，因为表达式都相同，可以进行封装不过方法内不需要添加其他代码
     //使用@Pointcut声明切入点表达式
     /**
      * 此时下面的通知注解都可以将value值写成此方法名 如：@Before("declareJoinPointException()")即可
      */
     @Pointcut("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
     public void declareJoinPointException(){}

     //1.前置通知：声明该方法是一个前置方法，在指定目标方法之前执行
     /**
      * before中写的是aspectj的表达式
      * public int可以用*代替，代表：任意修饰符和任意返回值
      * com.yinfu.spring.aop.impl代表包名
      * ArithmeticCalculatorImpl代表类名，可以用*代替，代表该包下的任意类
      * add代表方法名，可以用*好代替，代表该类下的任意方法
      * (int,int)参数类型，可以用..代替
      * @param joinPoint 链接点利用此链接点可以得到代理对象中的方法名称和参数等细节
      */
     @Before("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
     public void beforeMethod(JoinPoint joinPoint ){
         String methodName = joinPoint.getSignature().getName();
         List<Object> args = Arrays.asList(joinPoint.getArgs());
         System.out.println("this method "+methodName+" begin"+args);
     }
     //2.后置通知：在目标方法执行后(无论是否发生异常)，执行的通知
     //后置通知中还不能访问目标方法执行的结果
     @After("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
     public void afterMethod(JoinPoint joinPoint ){
         String methodName = joinPoint.getSignature().getName();
         System.out.println("this method "+methodName+" end");
     }

     //3返回通知：在目标方法正常执行后，执行的通知
     //返回通知是可以访问到方法的返回值的
     @AfterReturning(value="execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))",returning="result")
     public void afterReturning(JoinPoint joinPoint ,Object result){
         String methodName = joinPoint.getSignature().getName();
         System.out.println("this method "+methodName+" end with "+result);
     }

     //4.异常通知:在目标方法出现异常时会执行代码
     //可以访问异常对象，指定异常类型，当出现指定的异常时才会执行代码
     //也就是Exception可以换成NullPoinException异常，当出现空指针异常的时候才会执行异常通知，其他异常不执行
     @AfterThrowing(value="execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))",throwing="ex")
     public void afterThrowing(JoinPoint joinPoint ,Exception ex){
         String methodName = joinPoint.getSignature().getName();
         System.out.println("this method "+methodName+" throw with "+ex);
     }

     //5.环绕通知
     //环绕通知携带ProceedingJoinPoint类型的参数
     //环绕通知类似于动态代理的全过程，ProceedingJoinPoint类型的参数可以决定是否执行目标方法
     //环绕通知必须有返回值，返回值即为目标方法的返回值
     @Around("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
     public Object aroundMethod(ProceedingJoinPoint pjp){
         Object result = null;
         String methodName = pjp.getSignature().getName();
         Object[] args = pjp.getArgs();
         //执行目标方法
         try {
             //前置通知
             System.out.println("this aroundMethod "+methodName+" begin with "+Arrays.asList(args));
             result = pjp.proceed();
             //返回通知
             System.out.println("this aroundMethod "+methodName+" resutn with "+result);
         } catch (Throwable e) {
             //异常通知
             System.out.println("this aroundMethod "+methodName+" throw with "+e);
         }
         //后置通知
         System.out.println("this aroundMethod "+methodName+" end ");
         return result;
     }

 }

2.基于配置文件的日志通知和验证通知：

将类中的注解全部去掉，其他不变

此时的配置文件applicationContext.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"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

     <!-- 配置方法对象bean -->
     <bean id="arithmeticCalculator" class="com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl"></bean>
     <!-- 配置切面bean -->
     <bean id="loggingAspect" class="com.yinfu.spring.aop.impl.LoggingAspect"></bean>
     <!-- 配置AOP切面 -->
     <aop:config>
         <!-- 配置切点表达式 -->
         <aop:pointcut expression="execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))" id="pointcut"/>
         <!-- 配置切点及通知 -->
         <aop:aspect ref="loggingAspect" order="1">
             <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
             <aop:after method="afterMethod" pointcut-ref="pointcut"/>
             <!-- 这里的returning值必须与切面类中定义的值是一样的 -->
             <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
             <!-- 这里的throwing值必须与切面类中定义的值是一样的 -->
             <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>
             <aop:around method="aroundMethod" pointcut-ref="pointcut"/>
         </aop:aspect>
     </aop:config>

 </beans>