使用注解的方式编写：@Aspect运用

列子、

public interface Calculator {

     // 加
     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);
}

  @Service
  public class MyMathCalculator implements Calculator {
        @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;
        }
    }

      /**
       * 如何将这个类（切面类）中的这些方法（通知方法）动态的在目标方法运行的各个位置切入
       *
       *
       */
      @Aspect
      @Component
  public class LogUtils {

    @Pointcut("execution(public int com.atguigu.impl.MyMathCalculator.*(..))")
    public void MyPoint(){};

/**
 *告诉spring每个方法都什么时候运行；
 *
 *  try{
 *      @Before
 *      method.invoke(obj,args);
 *      @AfterReturning
 *  }catch(e){
 *      @AfterThrowing
 *  }finally{
 *      @After
 *  }
 *
 *
 *
 *  5个通知
 * @Before：在目标方法之前运行
 * @After：在目标方法结束之后
 * @AfterReturning：在目标方法正常返回之后
 * @AfterThrowing：在目标方法抛出异常之后运行
 * @Around：环绕
 *
 * //execution(访问权限符  返回值类型  方法签名)
 *
 */

// @Before("execution(public int com.apcstudy.aop.impl.MyMathCalculator.*(..))")
@Before(value = "MyPoint()")
public static  void logStart(JoinPoint joinPoint){
    //获取到目标方法运行是使用的参数
    Object[] args = joinPoint.getArgs();
    //获取到方法签名
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("【"+name+"】方法开始执行，用的参数列表【"+ Arrays.asList(args)+"】");
}

/**
 * 告诉Spring这个result用来接收返回值：
 *          returning="result"；
 * @param joinPoint
 * @param result
 */
@AfterReturning(value = "execution(public int com.apcstudy..impl.MyMathCalculator.*(..))",returning = "result")
public static void logReturn(JoinPoint joinPoint,Object result){
    System.out.println("【"+joinPoint.getSignature().getName()+"】方法正常执行完成，计算结果是："+result);
}

/**
 * 细节四：我们可以在通知方法运行的时候，拿到目标方法的详细信息；
 * 1）只需要为通知方法的参数列表上写一个参数：
 * 		JoinPoint joinPoint：封装了当前目标方法的详细信息
 * 2）、告诉Spring哪个参数是用来接收异常
 * 		throwing="exception"：告诉Spring哪个参数是用来接收异常
 * 3）、Exception exception:指定通知方法可以接收哪些异常
 *
 * ajax接受服务器数据
 * 	$.post(url,function(abc){
 * 		alert(abc)
 * 	})
 */
@AfterThrowing(value = "execution(public int com.apcstudy..MyMathCalculator.*(..))",throwing = "exception")
public static void logException(JoinPoint joinPoint,Exception exception){
    System.out.println("【"+joinPoint.getSignature().getName()+"】方法执行出现异常了，异常信息是【"+exception+"】：；这个异常已经通知测试小组进行排查");
}

/**
 * Spring对通知方法的要求不严格；
 * 唯一要求的就是方法的参数列表一定不能乱写？
 *      通知方法是Spring利用反射调用的，每次方法调用得确定这个方法的参数表的值；
 *      参数表上的每一个参数，Spring都得知道是什么？
 *      JoinPoint:认识
 *      不知道的参数一定告诉Spring这是什么？
 * @param joinPoint
 * @return
 */
@After("execution(public int com.apcstudy.aop.impl.MyMathCalculator.*(..))")
private int logEnd(JoinPoint joinPoint){
    System.out.println("【"+joinPoint.getSignature().getName()+"】方法最终结束了");
    return 0;
}

    /**
 * @throws Throwable
 * @Around：环绕	:是Spring中强大的通知；
 * @Around：环绕:动态代理；
 * 	try{
 * 			//前置通知
 * 			method.invoke(obj,args);
 * 			//返回通知
 * 	}catch(e){
 * 			//异常通知
 *  }finally{
 * 			//后置通知
 * 	}
 *
 * 	四合一通知就是环绕通知；
 * 	环绕通知中有一个参数：	ProceedingJoinPoint pjp
 *
 *环绕通知：是优先于普通通知执行，执行顺序；
 *
 *[普通前置]
 *{
 *	try{
 *		环绕前置
 *		环绕执行：目标方法执行
 *		环绕返回
 *	}catch(){
 *		环绕出现异常
 *	}finally{
 *		环绕后置
 *	}
 *}
 *
 *
 *[普通后置]
 *[普通方法返回/方法异常]
 *新的顺序：
 *		（环绕前置---普通前置）----目标方法执行----环绕正常返回/出现异常-----环绕后置----普通后置---普通返回或者异常
 *注意：
 */

@Around("hahaMyPoint()")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{

	Object[] args = pjp.getArgs();
	String name = pjp.getSignature().getName();
	//args[0] = 100;
	Object proceed = null;
	try {
		//@Before
		System.out.println("【环绕前置通知】【"+name+"方法开始】");
		//就是利用反射调用目标方法即可，就是method.invoke(obj,args)
		proceed = pjp.proceed(args);
		//@AfterReturing
		System.out.println("【环绕返回通知】【"+name+"方法返回，返回值"+proceed+"】");
	} catch (Exception e) {
		//@AfterThrowing
		System.out.println("【环绕异常通知】【"+name+"】方法出现异常，异常信息："+e);
		//为了让外界能知道这个异常，这个异常一定抛出去
		throw new RuntimeException(e);
	} finally{
		//@After
		System.out.println("【环绕后置通知】【"+name+"】方法结束");
	}

	//反射调用后的返回值也一定返回出去
	return proceed;
}

}

  public class AOPTest {

      ApplicationContext ioc = new ClassPathXmlApplicationContext("conf/applicationContext.xml");

/**
 * 通知方法的执行顺序；
 *
 *   try{
 *   	@Before
 *   	method.invoke(obj,args);
 *   	@AfterReturning
 *   }catch(){
 *   	@AfterThrowing
 *   }finally{
 *   	@After
 *   }
 *
 * 正常执行：  @Before（前置通知）=====@After（后置通知）====@AfterReturning（正常返回）；
 * 异常执行： @Before（前置通知）=====@After（后置通知）===@AfterThrowing（方法异常）
 *
 */

@Ignore
public void test01(){
    //	一定要从容器中拿到目标对象；注意：如果想要用类型，一定要用他的接口类型，不要用本类；
    Calculator calculator = ioc.getBean(Calculator.class);
    calculator.add(2, 12);
}

@Test
public void test02(){
    //	一定要从容器中拿到目标对象；注意：如果想要用类型，一定要用他的接口类型，不要用本类；
    Calculator calculator = ioc.getBean(Calculator.class);
    calculator.add(2, 12);
    System.out.println("=================");
    calculator.div(1, 0);
}

  }

      <?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-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

<!-- 将接口实现组件加入到容器中 -->
<context:component-scan base-package="com.apcstudy.aop"></context:component-scan>

<!-- 开启基于注解的AOP功能：aop名称空间 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  </beans>