Java Spring AOP 从入门到精通 -1

背景

想写几篇Spring AOP 方面的简洁实用的博客。当然，从知识体系化上来说，最好的当然是读英文原版的技术文档，这有很多。比如（https://docs.spring.io/spring/docs/2.5.x/reference/aop.html ）就讲的很清楚很详细，但对部分入门者来说，可能并不一定要把上千页的文档从头读到尾，最好的可能是知道个大概后马上能方便的建立一些程序例子，了解这个东西什么能做，什么不能做，需要深入时再具体参阅更详细的文档。
如果一开始就贴一些例子程序有些突兀，所以就加入了这一篇，简要介绍一下AOP的一些重要概念。而把例子程序从“Java Spring AOP 从入门到精通-2”开始。

AOP的几个重要概念

以下把英文原始定义放旁边供参考，并不逐词翻译。只是用一两句话讲明重点。
Aspect: a modularization of a concern that cuts across multiple classes. Transaction management is a good example of a crosscutting concern in J2EE applications. In Spring AOP, aspects are implemented using regular classes (the schema-based approach) or regular classes annotated with the @Aspect annotation (the @AspectJ style).
切面编程，针对多个类的某一方面。比如不同的类都需要进行transaction management, logging等。

Join point: a point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point always represents a method execution.
注入点。程序执行过程中某一方法的执行，某一异常的处理等。

Advice: action taken by an aspect at a particular join point. Different types of advice include “around,” “before” and “after” advice. (Advice types are discussed below.) Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors around the join point.
切面带来的逻辑。

Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the pointcut (for example, the execution of a method with a certain name). The concept of join points as matched by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut expression language by default.
如何描述注入点。通常用一个正则表达式来描述。

Introduction: declaring additional methods or fields on behalf of a type. Spring AOP allows you to introduce new interfaces (and a corresponding implementation) to any advised object. For example, you could use an introduction to make a bean implement an IsModified interface, to simplify caching. (An introduction is known as an inter-type declaration in the AspectJ community.)
除了类型外额外的方法或字段的声明。

Target object: object being advised by one or more aspects. Also referred to as the advised object. Since Spring AOP is implemented using runtime proxies, this object will always be a proxied object.
目的对象。比如myObject.doSometing(int a), 如果对doSomething定义了一个Aspect， 在执行这个Aspect时，Target object就是myObject.

AOP proxy: an object created by the AOP framework in order to implement the aspect contracts (advise method executions and so on). In the Spring Framework, an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy.

Weaving: linking aspects with other application types or objects to create an advised object. This can be done at compile time (using the AspectJ compiler, for example), load time, or at runtime. Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime.

注入的种类

Before advice: Advice that executes before a join point, but which does not have the ability to prevent execution flow proceeding to the join point (unless it throws an exception).
调用前
比如下面的例子是任何地方调用方法com.xyz.myapp.SystemArchitecture.dataAccessOperation()之前，注入doAccessCheck()进行检查。

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

@Aspect
public class BeforeExample {

  @Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() {
    // ...
  }

}

After returning advice: Advice to be executed after a join point completes normally: for example, if a method returns without throwing an exception.
正常返回前(没有抛出异常）。
下面这个例子就是任何地方调用com.xyz.myapp.SystemArchitecture.dataAccessOperation()，正常返回后调用doAccessCheck()。

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

@Aspect
public class AfterReturningExample {

  @AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() {
    // ...
  }

}

After throwing advice: Advice to be executed if a method exits by throwing an exception.
抛出异常后

After (finally) advice: Advice to be executed regardless of the means by which a join point exits (normal or exceptional return).
调用后（不管正常退出，还是异常退出）

Around advice: Advice that surrounds a join point such as a method invocation. This is the most powerful kind of advice. Around advice can perform custom behavior before and after the method invocation. It is also responsible for choosing whether to proceed to the join point or to shortcut the advised method execution by returning its own return value or throwing an exception.
执行中。这种类型的注入有机会在方法执行前，执行后，或执行中施加一些操作，甚至有可能让原方法根本不执行，或者改变行为。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;

@Aspect
public class AroundExample {

  @Around("com.xyz.myapp.SystemArchitecture.businessService()")
  public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
    // start stopwatch
    Object retVal = pjp.proceed();
    // stop stopwatch
    return retVal;
  }

}