package com.xyz.myapp;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;


@Aspect
//这个类使用了org.aspectj.lang.annotation.Aspect 注解，这个类被视作一个@Aspect切面
public class AspectExample {
  //切面可能包括切入点，通知和引入（inter-type）声明。
  //可以在同一个切面里定义多个通知，或者其他成员。
  //前置通知（Before advice）--在一个匹配的方法执行前执行
  @Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() {
    // ...
  }
  //使用一个in-place 的切入点表达式
  @Before("execution(* com.xyz.myapp.dao.*.*(..))")
  public void doAccessCheck() {
    // ...
  }

  //返回后通知（After returning advice）--在一个匹配的方法返回的时候执行
  @AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() {
    // ...
  }
  //为了在通知体内得到返回的值使用了returning 属性
  //在 returning 属性中使用的名字必须对应于通知方法内的一个参数名。
  //当一个方法执行返回后，返回值作为相应的参数值传入通知方法。
  //returning 子句也限制了匹配的返回值类型
  //（在本例子中，返回值是 Object 类，也就是说返回任意类型都会匹配）
  @AfterReturning(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    returning="retVal")
  public void doAccessCheck(Object retVal) {
    // ...
  }

  //抛出后通知（After throwing advice）--在一个方法抛出异常后执行
  @AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doRecoveryActions() {
    // ...
  }
  //限制通知只在某种特殊的异常被抛出的时候匹配，并可以在通知体内得到被抛出的异常。
  //使用 throwing 属性不光可以限制匹配的异常类型（如果你不想限制，请使用 Throwable 作为异常类型），
  //还可以将抛出的异常绑定到通知的一个参数上。
  //在 throwing 属性中使用的名字必须与通知方法内的一个参数对应。 当一个方法因抛出一个异常而中止后，
  //这个异常将会作为那个对应的参数送至通知方法。
  //throwing 子句也限制了只能匹配到抛出指定异常类型的方法（在本例子中为 DataAccessException）。
  @AfterThrowing(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    throwing="ex")
  public void doRecoveryActions(DataAccessException ex) {
    // ...
  }

  //后通知（After (finally) advice）
  //不论一个方法是如何结束的，在它结束后（finally）后通知（After (finally) advice）都会运行。
  //这个通知必须做好处理正常返回和异常返回两种情况。通常用来释放资源。
  @After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doReleaseLock() {
    // ...
  }

  //环绕通知（Around Advice）
  //环绕通知在一个方法执行之前和之后执行。 它使得通知有机会既在一个方法执行之前又在执行之后运行。
  //并且，它可以决定这个方法在什么时候执行，如何执行，甚至是否执行。
  //环绕通知经常在在某线程安全的环境下，你需要在一个方法执行之前和之后共享某种状态的时候使用。
  @Around("com.xyz.myapp.SystemArchitecture.businessService()")
  //通知的第一个参数必须是 ProceedingJoinPoint 类型。
  public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
    // start stopwatch
    //在通知体内，调用 ProceedingJoinPoint 的 proceed() 方法将会导致潜在的连接点方法执行。
    //proceed 方法也可能会被调用并且传入一个 Object[] 对象-该数组将作为方法执行时候的参数。
    //请注意proceed可能在通知体内部被调用一次，许多次，或者根本不被调用。
    Object retVal = pjp.proceed();
    // stop stopwatch
    //方法的调用者得到的返回值就是环绕通知返回的值。
    return retVal;
  }
}

package com.xyz.myapp;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
//这个切面中定义的切入点，可以在任何需要切入点表达式的地方引用
public class SystemArchitecture {

  /**
   * A join point is in the web layer if the method is defined
   * in a type in the com.xyz.myapp.web package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.myapp.web..*)")// the pointcut expression
  public void inWebLayer() {}// the pointcut signature

  /**
   * A join point is in the service layer if the method is defined
   * in a type in the com.xyz.myapp.service package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.myapp.service..*)")
  public void inServiceLayer() {}

  /**
   * A join point is in the data access layer if the method is defined
   * in a type in the com.xyz.myapp.dao package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.myapp.dao..*)")
  public void inDataAccessLayer() {}

  /**
   * A business service is the execution of any method defined on a service
   * interface. This definition assumes that interfaces are placed in the
   * "service" package, and that implementation types are in sub-packages.
   *
   * If you group service interfaces by functional area (for example,
   * in packages com.xyz.myapp.abc.service and com.xyz.def.service) then
   * the pointcut expression "execution(* com.xyz.myapp..service.*.*(..))"
   * could be used instead.
   */
  @Pointcut("execution(* com.xyz.myapp.service.*.*(..))")
  public void businessService() {}

  /**
   * A data access operation is the execution of any method defined on a
   * dao interface. This definition assumes that interfaces are placed in the
   * "dao" package, and that implementation types are in sub-packages.
   */
  @Pointcut("execution(* com.xyz.myapp.dao.*.*(..))")
  public void dataAccessOperation() {}

}

<?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-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
<!--
有了schema的支持，切面就和常规的Java对象一样被定义成application context中的一个bean。
对象的字段和方法提供了状态和行为信息，XML文件则提供了切入点和通知信息。
正如下面这个bean指向一个没有使用 @Aspect 注解的bean类，
但是这个类会在下面被配置为一个切面的backing bean（支持bean）。
-->
<bean id="aBean" class="com.xyz.myapp.AspectExample2">
  ...
</bean>
<!--
配置文件中：
所有的AOP配置是在<aop:config>标签中设置的，所有的切面和通知器都必须定义在 <aop:config> 元素内部。
一个application context可以包含多个 <aop:config>。
一个 <aop:config> 可以包含pointcut，advisor和aspect元素（注意它们必须按照这样的顺序进行声明）。
如果想强制使用CGLIB代理，需要将 <aop:config> 的 proxy-target-class 属性设为true
-->
<aop:config>
  <!--顶级（<aop:config>）切入点：
  直接在<aop:config>下定义，这样就可以使多个切面和通知器共享该切入点。-->
  <aop:pointcut id="businessService"
  expression="execution(* com.xyz.myapp.service.*.*(..))"/>
  <!--这里使用命名式切入点，只在JDK1.5及以上版本中支持。-->
  <aop:pointcut id="businessService"
  expression="com.xyz.myapp.SystemArchitecture.businessService()"/>

  <!--切面使用<aop:aspect>来声明，backing bean（支持bean）通过 ref 属性来引用-->
  <aop:aspect id="myAspect" ref="aBean">
    <!--在切面里面声明一个切入点：这种情况下切入点只在切面内部可见。-->
    <aop:pointcut id="businessService"
    expression="execution(* com.xyz.myapp.service.*.*(..))"/>

    <!--Before通知-->
    <aop:before
   pointcut-ref="dataAccessOperation"
   method="doAccessCheck"/>
    <!--使用内置切入点：将 pointcut-ref 属性替换为 pointcut 属性-->
    <aop:before
   pointcut="execution(* com.xyz.myapp.dao.*.*(..))"
   method="doAccessCheck"/>

    <!--返回后通知-->
    <aop:after-returning
   pointcut-ref="dataAccessOperation"
   method="doAccessCheck"/>
    <!--和@AspectJ风格一样，通知主体可以接收返回值。使用returning属性来指定接收返回值的参数名-->
    <aop:after-returning
   pointcut-ref="dataAccessOperation"
   returning="retVal"
   method="doAccessCheck"/>

    <!--抛出异常后通知-->
    <aop:after-throwing
   pointcut-ref="dataAccessOperation"
   method="doRecoveryActions"/>
    <!--和@AspectJ风格一样，可以从通知体中获取抛出的异常。
    使用throwing属性来指定异常的名称，用这个名称来获取异常-->
    <aop:after-throwing
   pointcut-ref="dataAccessOperation"
   thowing="dataAccessEx"
   method="doRecoveryActions"/>

    <!--后通知-->
    <aop:after
   pointcut-ref="dataAccessOperation"
   method="doReleaseLock"/>

    <!--Around通知:通知方法的第一个参数的类型必须是 ProceedingJoinPoint 类型-->
    <aop:around
   pointcut-ref="businessService"
   method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>
</beans>