花痴无极限，凉粉Forever

先说一下AOSD的起源吧

传统的软件工程有一个不变的主题：对关注点的分解和局部化。将系统分解成为主要的功能模块，识别出关注点的其他问题，确保所有关注点的问题都能在代码的适当位置得到解决。但是关注点的分散和混杂又给代码编写和后期维护带来了很大的难度。
因此，必须有一种方法可以把关注点集中在一起，让系统开发者可以使用关注点自身的模块来描述每个关注点的行为。
AOSD，用以寻找软件系统中新的模块化特性，允许对系统中多个关注点进行独立描述，同时又能自动统一到系统中。

然后是一些常用的术语(from AOSD wiki)：

concern(关注点)：A concern is an area of interest or focus in a system. Concerns are the primary criteria for decomposing software into smaller, more manageable and comprehensible parts that have meaning to a software engineer.

crosscutting(横切)：Note that crosscutting is a relationship between representations of concerns. Note also that it is a symmetric relationship. Therefore, if:

1. A is a representation of one a concern,
2. B is a representation of another concern, and
3. A crosscuts B,

then B also crosscuts A.

This means that the term "crosscutting concerns" is often misused in two ways: To talk about a single concern, and to talk about concerns rather than representations of concerns. Consider "synchronization is a crosscutting concern": we don't know that synchronization is crosscutting unless we know what it crosscuts. And there may be representations of the concerns involved that are not crosscutting.

aspect(方面)：Aspects are one kind of concern in software development.

joint point(联接点)：Join points are those elements of the programming language semantics which the aspects coordinate with. Nowadays, there are various join point models around and still new under development. They heavily depend on the underlying programming language and AO language.

In a number of presently available AOP languages, a join point is a region in the dynamic control flow of an application. Thus a join point can for instance represent

* a call to a method,
* execution of a method,
* the event of setting a field,
* the event of handling an exception ...

Join points can be picked up by an AOP program by using pointcuts to match on them. Depending on the pointcut language the AOP language provides, it may be possible to pick up more or less of those join points. Since join points are dynamic, it may be possible to expose runtime information such as the caller or callee of a method from a join point to a matching pointcut.

advice：In a number of AOP languages, advice consists of a pointcut and a body. The body executes at join points the pointcut matches. This pointcut may expose runtime information to the advice body.

pointcut:

(from Without EJB)：A set of join points,defined to specify when an advice should fire.Pointcuts are often described using either regular expressions or another wildcard syntax.

(from Wiki)In a number of AOP languages, a pointcut is a predicate over dynamic join points, meaning that given a certain dynamic join point, a pointcut can either match this join point or not (at runtime). Another view of pointcuts is often, that they represent sets of join points. A pointcut may expose runtime information to a piece of advice.

Weaving：The process of coordinating aspects and non-aspects. Weaving can be done explicitly or implicitly, and can be done at a variety of times ranging from by-hand weaving when code is written, through compile-time, post-compile time and load time, up to runtime.

Without EJB中有个例子很好的解释了一下上面的术语：

public class MyBusinessObject implements BusinessObject{
public void businessMethod1() throws UnauthorizedException{
doSecurityCheck();
}
public void businessMethod2() throws UnauthorizedException{
doSecurityCheck();
}
public void requiresNoSecurityCheck() {
}
public void doSecurityCheck() throws UnauthorizedException{
}
}

这里，安全检查就是一个aspect，需要进行安全检查的这几个方法就是join point。而由于不是所有的方法都需要进行安全检查，所以就需要用pointcut来进行匹配。

下面使用了一个interceptor来将关注点模块化：

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class SecurityInterceptor implements MethodInterceptor{
public Object invoke(MethodInvocation invocation)throws Throwable{
doSecurityCheck();
return invocation.proceed();
}
public void doSecurityCheck{}
}

这里的interceptor就是advice