一、AspectJ概述
圖1 ：FigureEditor例子的UML圖
AspectJ（也就是AOP）的動機是發現那些使用傳統的編程方法無法很好處理的問題。考慮一個要在某些應用中實施安全策略的問題。安全性是貫穿于系統所有模塊間的問題，每個模塊都需要應用安全機制才能保證整個系統的安全性，很明顯這里的安全策略的實施問題就是一個橫切關注點，使用傳統的編程解決此問題非常的困難而且容易產生差錯，這就正是AOP發揮作用的時候了。
傳統的面向對象編程中，每個單元就是一個類，而類似于安全性這方面的問題，它們通常不能集中在一個類中處理因為它們橫跨多個類，這就導致了代碼無法重用，可維護性差而且產生了大量代碼冗余，這是我們不愿意看到的。
面向方面編程的出現正好給處于黑暗中的我們帶來了光明，它針對于這些橫切關注點進行處理，就好象面向對象編程處理一般的關注點一樣。而作為AOP的具體實現之一的AspectJ，它向Java中加入了連接點（Join Point）這個新概念，其實它也只是現存的一個Java概念的名稱而已。它向Java語言中加入少許新結構：切點(pointcut)、通知(Advice)、類型間聲明(Inter-type declaration)和方面(Aspect)。切點和通知動態地影響程序流程，類型間聲明則是靜態的影響程序的類等級結構，而方面則是對所有這些新結構的封裝。
一個連接點是程序流中指定的一點。切點收集特定的連接點集合和在這些點中的值。一個通知是當一個連接點到達時執行的代碼，這些都是AspectJ的動態部分。其實連接點就好比是程序中的一條一條的語句，而切點就是特定一條語句處設置的一個斷點，它收集了斷點處程序棧的信息，而通知就是在這個斷點前后想要加入的程序代碼。AspectJ中也有許多不同種類的類型間聲明，這就允許程序員修改程序的靜態結構、名稱、類的成員以及類之間的關系。AspectJ中的方面是橫切關注點的模塊單元。它們的行為與Java語言中的類很象，但是方面還封裝了切點、通知以及類型間聲明。
動態連接點模型
任何面向方面編程的關鍵元素就是連接點模型。AspectJ提供了許多種類的連接點集合，但是本篇只介紹它們中的一個：方法調用連接點集(method call join points)。一個方法調用連接點捕捉對象的方法調用。每一個運行時方法調用都是一個不同的連接點，許多其他的連接點集合可能在方法調用連接點執行時運，包括方法執行時的所有連接點集合以及在方法中其他方法的調用。我們說這些連接點集合在原來調用的連接點的動態環境中執行。
切點
在AspectJ中，切點捕捉程序流中特定的連接點集合。例如，切點
call(void Point.setX(int))
捕捉每一個簽名為void Point.setX(int)的方法調用的連接點，也就是說，調用Point對象的有一個整型參數的void setX方法。切點能與其他切點通過或(||)、與(&&)以及非(!)操作符聯合。例如 call(void Point.setX(int)) || call(void Point.setY(int)) 捕捉setX或setY調用的連接點。切點還可以捕捉不同類型的連接點集合，換句話說，它們能橫切類型。例如
call(void FigureElement.setXY(int,int)) || call(void Point.setX(int))
|| call(void Point.setY(int) || call(void Line.setP1(Point))
|| call(void Line.setP2(Point));
捕捉上述五個方法調用的任意一個的連接點集合。它在本文的例子中捕捉當FigureElement移動時的所有連接點集合。AspectJ使程序員可以命名一個切點集合，以便通知的使用。例如可以為上面的那些切點命名
pointcut move():
call(void FigureElement.setXY(int,int)) || call(void Point.setX(int))
|| call(void Point.setY(int)) || call(void Line.setP1(Point)) || call(void Line.setP2(Point));
無論什么時候，程序員都可以使用move()代替捕捉這些復雜的切點。
前面所說的切點都是基于顯示的方法簽名，它們稱為基于名字(name-based)橫切。AspectJ還提供了另一種橫切，稱為基于屬性(property-based)的橫切。它們可以使用通配符描述方法簽名，例如 call(void Figure.make*(..)) 捕捉Figure對象中以make開頭的參數列表任意的方法調用的連接點。而 call(public & Figure.*(..)) 則捕捉Figure對象中的任何公共方法調用的連接點。但是通配符不是AspectJ支持的唯一屬性，AspectJ中還有許多其他的屬性可供程序員使用。例如cflow，它根據連接點集合是否在其他連接點集合的動態環境中發生標識連接點集合。例如 cflow(move()) 捕捉被move()捕捉到的連接點集合的動態環境中發生的連接點。
通知
雖然切點用來捕捉連接點集合，但是它們沒有做任何事。要真正實現橫切行為，我們需要使用通知機制。通知包含了切點和要在每個連連接點處執行的代碼段。AspectJ有幾種通知。
·前通知(Before Advice) 當到達一個連接點但是在程序進程運行之前執行。例如，前通知在方法實際調用之前運行，剛剛在方法的參數被分析之后。
Before() : move(){ System.out.println(“物體將移動了”);}
·后通知(After Advice) 當特定連接點處的程序進程執行之后運行。例如，一個方法調用的后通知在方法體運行之后，剛好在控制返回調用者之前執行。因為Java程序有兩種退出連接點的形式，正常的和拋出異常。相對的就有三種后通知：返回后通知(after returning)、拋出異常后通知(after throwing)和清楚的后通知(after)，所謂清楚后通知就是指無論是正常還是異常都執行的后通知，就像Java中的finally語句。
After() returning : move(){ System.out.println(“物體剛剛成功的移動了”);}
·在周圍通知(Around Advice) 在連接點到達后，顯示的控制程序進程是否執行（暫不討論）
暴露切點環境
切點不僅僅捕捉連接點，它還能暴露連接點處的部分執行環境。切點中暴露的值可以在通知體中聲明以后使用。通知聲明有一個參數列表（和方法相同）用來描述它所使用的環境的名稱。例如后通知
after(FigureElement fe,int x,int y) returning : somePointcuts { someCodes }
使用了三個暴露的環境，一個名為fe的FigureElement對象，兩個整型變量x,y。通知體可以像使用方法的參數那樣使用這些變量，例如
after(FigureElement fe,int x,int y) returning : somePointcuts {
System.out.println(fe+”移動到(”+x+”,”+y+”)”);
}
通知的切點發布了通知參數的值，三個原生切點this、target和args被用來發布這些值/所以上述例子的完整代碼為
after(FigureElement fe,int x,int y) returning : call(void FigureElement.setXY(int,int)
&& target(fe) && args(x,y) {
System.out.println(fe+”移動到(”+x+”,”+y+”)”);
}
目標對象是FigureElement所以fe是after的第一個參數，調用的方法包含兩個整型參數所以x和y為after的第二和第三個參數。所以通知打印出方法setXY調用返回后對象移動到的點x和y。當然還可以使用命名切點完成同樣的工作，例如
pointcut setXY(FigureElement fe,int x,int y):call(void FigureElement.setXY(int,int)
&& target(fe) && args(x,y);
after(FigureElement fe,int x,int y) returning : setXY(fe,x,y){
System.out.println(fe+”移動到(”+x+”,”+y+”)”);
}
類型間聲明
AspectJ的類型間聲明指的是那些跨越類和它們的等級結構的聲明。這些可能是橫跨多個類的成員聲明或者是類之間繼承關系的改變。不像通知是動態地操作，類型間聲明編譯時的靜態操作。考慮一下，Java語言中如何向一個一些的類中加入新方法，這需要實現一個特定接口，所有類都必須在各自內部實現接口聲明的方法，而使用AspectJ則可以將這些工作利用類型間聲明放在一個方面中。這個方面聲明方法和字段，然后將它們與需要的類聯系。
假設我們想有一個Sreen對象觀察Point對象的變化，當Point是一個存在的類。我們可以通過書寫一個方面，由這個方面聲明Point對象有一個實例字段observers,用來保存所有觀察Point對象的Screen對象的引用，從而實現這個功能。
Aspect PointObserving{
Private Collection Point.observers=new ArrayList();
……
}
observers字段是私有字段，只有PointObserving能使用。因此，要在aspect中加入方法管理observers聚集。
Aspect PointObserving{
Private Collection Point.observers=new ArrayList();
Public static void addObserver(Point p,Screen s){
p.observers.add(s);
}
public static void removeObserver(Point p,Screen s){
p.observers.remove(s);
}
……
}
然后我們可以定義一個切點stateChanges決定我們想要觀察什么并且提供一個after通知定義當觀察到變化時我們想要做什么。
Aspect PointObserving{
Private Collection Point.observers=new ArrayList();
Public static void addObserver(Point p,Screen s){
p.observers.add(s);
}
public static void removeObserver(Point p,Screen s){
p.observers.remove(s);
}
pointcut stateChanges(Point p) : target(p) && call(void Point.set*(int));
after(Point p) : stateChanges(p){
Iterator it=p.observers.iterator();
While(it.hasNext()){
UpdateObserver(p,(Screen)it.next()));
}
}
private static void updateObserver(Point p,Screen s){
s.display(p);
}
}
注意無論是Sreen還是Point的代碼都沒有被修改，所有的新功能的加入都在方面中實現了，很酷吧！
方面
方面以橫切模塊單元的形式包裝了所有的切點、通知和類型間聲明。這非常像Java語言的類。實際上，方面也可以定義自己的方法，字段和初始化方法。像類一樣一個方面也可以用abstrace關鍵字聲明為抽象方面，可以被子方面繼承。在AspectJ中方面的設計實際上使用了單例模式，缺省情況下，它不能使用new構造，但是可以使用一個方法實例化例如方法aspectOf()可以獲得方面的實例。所以在方面的通知中可以使用非靜態的成員字段。
例如
aspect Tracing {
OutputStream trace=System.out;
After() : move(){ trace.println(“物體成功移動”); }
二、AspectJ應用范圍
如前所述，AspectJ可以用于應用開發的不同階段。下面討論不同階段的AspectJ的具體應用情況。
開發型方面(Development Aspects)
開發方面可以很容易的從真正的產品中刪除。而產品方面則被可用于開發過程和生產過程，但是僅僅影響某幾個類。
這一部分將通過幾個例子說明方面在Java應用的開發階段是如何使用的。這些方面包括調試、測試和性能檢測等工作。方面定義的行為范圍包括簡單的代碼跟蹤、測試應用的內在聯系等等。使用AspectJ不僅使得模塊化這些功能變為可能，同時也使得根據需要打開和關閉這些功能變成可能。
代碼跟蹤(Tracing)
首先讓我們看看如何增加一個程序內部工作的可視性。我們定義一個簡單的方面用于代碼跟蹤并且在每個方法調用時輸出一些信息。在前一篇的圖形編輯例子中，這樣的方面可能僅僅簡單的跟蹤什么時候畫一個點。
aspect SimpleTracing {
pointcut tracedCall():
call(void FigureElement.draw(GraphicsContext));
before(): tracedCall() {
System.out.println("Entering: " + thisJoinPoint);
}
}
代碼利用了thisJoinPoint變量。在所有的通知體內，這個變量將與描述當前連接點的對象綁定。所以上述代碼在每次一個FigureElement對象接受到draw方法時輸出如下信息：
Entering: call(void FigureElement.draw(GraphicsContext))
通常我們在調式程序時，會在特定的地方放置幾條輸出語句，而當調試結束時還需要找到這些代碼段將它們刪除，這樣做不但使我們的代碼很難看而且很費時間。而使用AspectJ我們可以克服以上的兩個問題，我們可以通過定義切點捕捉任何想要觀察的代碼段，利用通知可以在方面內部書寫輸出語句，而不需要修改源代碼，當不在需要跟蹤語句的時候還可以很輕松的將方面從應用中刪除并重新編譯代碼即可。
前提條件和后續條件(Pre-and Post-Conditions)
許多的程序員使用按契約編程(Design by Contract)的形式。這種形式的編程需要顯式的前提條件測試以保證方法調用是否合適，還需要顯式的后續條件測試保證方法是否工作正常。AspectJ使得可以模塊化地實現這兩種條件測試。例如下面的代碼
aspect PointBoundsChecking {
pointcut setX(int x):
(call(void FigureElement.setXY(int, int)) && args(x, *))
|| (call(void Point.setX(int)) && args(x));
pointcut setY(int y):
(call(void FigureElement.setXY(int, int)) && args(*, y))
|| (call(void Point.setY(int)) && args(y));
before(int x): setX(x) {
if ( x < MIN_X || x > MAX_X )
throw new IllegalArgumentException("x is out of bounds.");
}
before(int y): setY(y) {
if ( y < MIN_Y || y > MAX_Y )
throw new IllegalArgumentException("y is out of bounds.");
}
}
它實現了邊界檢測功能。當FigureElement對象移動時，如果x或y的值超過了定義的邊界，程序將會拋出IllegalArgumentException異常。
合同實施(Contract Enforcement)
基于屬性的橫切機制在定義更加復雜的合同實施上非常有用。一個十分強大的功能是它可以強制特定的方法調用只出現在對應的程序中，而在其他程序中不出現。例如，下面的方面實施了一個限制，使得只有在知名的工廠方法中才能向注冊并添加FigureElement對象。實施這個限制的目的是為了確保沒有任何一個FigureElement對象被注冊多次。
static aspect RegistrationProtection {
pointcut register(): call(void Registry.register(FigureElement));
pointcut canRegister(): withincode(static * FigureElement.make*(..));
before(): register() && !canRegister() {
throw new IllegalAccessException("Illegal call " + thisJoinPoint);
}
}
這個方面使用了withincode初始切點，它表示在FigureElement對象的工廠方法(以make開始的方法)體內出現的所有連接點。在before通知中聲明一個異常，該通知用于捕捉任何不在工廠方法代碼內部產生的register方法的調用。該通知在特定連接點處拋出一個運行時異常，但是AspectJ能做地更好。使用declare error的形式，我們可以聲明一個編譯時的錯誤。
static aspect RegistrationProtection {
pointcut register(): call(void Registry.register(FigureElement));
pointcut canRegister(): withincode(static * FigureElement.make*(..));
declare error: register() && !canRegister(): "Illegal call"
}
當使用這個方面后，如果代碼中存在定義的這些非法調用我們將無法通過編譯。這種情況只出現在我們只需要靜態信息的時候，如果我們需要動態信息，像上面提到的前提條件實施時，就可以利用在通知中拋出帶參數的異常來實現。
配置管理(Configuration Management)
AspectJ的配置管理可以使用類似于make-file等技術進行處理。程序員可以簡單的包括他們想要的方面進行編譯。不想要任何方面出現在產品階段的開發者也可以通過配置他們的make-file使用傳統的Java編譯器編譯整個應用。
產品型方面(Production Aspects)
這一部分的方面例子將描述方面用于生產階段的應用。產品方面將向應用中加入功能而不僅僅為程序的內部工作增加可視性。
改變監視(Change Monitoring)
在第一個例子，方面的角色是用于維護一位數據標志，由它說明對象從最后一次顯示刷新開始是否移動過。在方面中實現這樣的功能是十分直接的，testAndClear方法被顯示代碼調用以便找到一個圖形元素是否在最近移動過。這個方法返回標志的狀態并將它設置為假。切點move捕捉所有能夠是圖形移動的方法調用。After通知截獲move切點并設置標志位。
aspect MoveTracking {
private static boolean dirty = false;
public static boolean testAndClear() {
boolean result = dirty;
dirty = false;
return result;
}
pointcut move():
call(void FigureElement.setXY(int, int)) ||
call(void Line.setP1(Point)) ||
call(void Line.setP2(Point)) ||
call(void Point.setX(int)) ||
call(void Point.setY(int));
after() returning: move() {
dirty = true;
}
}
這個簡單例子同樣說明了在產品代碼中使用AspectJ的一些好處。考慮使用普通的Java代碼實現這個功能：將有可能需要包含標志位，testAndClear以及setFlag方法的輔助類。這些方法需要每個移動的圖形元素包含一個對setFlag方法的調用。這些方法的調用就是這個例子中的橫切關注點。
·顯示的捕捉了橫切關注點的結構
·功能容易拔插
·實現更加穩定
傳遞上下文(Context Passing)
橫切結構的上下文傳遞在Java程序中是十分復雜的一部分。考慮實現一個功能，它允許客戶設置所創建的圖形對象的顏色。這個需求需要從客戶端傳入一個顏色或顏色工廠。而要在大量的方法中加入一個參數，目的僅僅是為傳遞上下文信息這種不方便的情況是所有的程序員都十分熟悉的。
使用AspectJ，這種上下文的傳遞可以使用模塊化的方式實現。下面代碼中的after通知僅當一個圖形對象的工廠方法在客戶ColorControllingClient的某個方法控制流程中調用時才運行。
aspect ColorControl {
pointcut CCClientCflow(ColorControllingClient client):
cflow(call(* * (..)) && target(client));
pointcut make(): call(FigureElement Figure.make*(..));
after (ColorControllingClient c) returning (FigureElement fe):
make() && CCClientCflow(c) {
fe.setColor(c.colorFor(fe));
}
}
這個方面僅僅影響一小部分的方法，但是注意該功能的非AOP實現可能 需要編輯更多的方法。
提供一致的行為(Providing Consistent Behavior)
接下來的例子說明了基于屬性的方面如何在很多操作中提供一致的處理功能。這個方面確保包com.bigboxco的所有公共方法記錄由它們拋出的任何錯誤。PublicMethodCall切點捕捉包中的公共方法調用， after通知在任何一個這種調用拋出錯誤后運行并且記錄下這個錯誤。
aspect PublicErrorLogging {
Log log = new Log();
pointcut publicMethodCall():
call(public * com.bigboxco.*.*(..));
after() throwing (Error e): publicMethodCall() {
log.write(e);
}
}
在一些情況中，這個方面可以記錄一個異常兩次。這在com.bigboxco包內部的代碼自己調用本包中的公共方法時發生。為解決這個問題，我們可以使用cflow初始切點將這些內部調用排除：
after() throwing (Error e) : publicMethodCall() && !cflow(publicMethodCall()) {
log.write(e);
}
結論
AspectJ是對Java語言的簡單而且實際的面向方面的擴展。僅通過加入幾個新結構，AspectJ提供了對模塊化實現各種橫切關注點的有力支持。向以有的Java開發項目中加入AspectJ是一個直接而且漸增的任務。一條路徑就是通過從使用開發方面開始再到產品方面當擁有了AspectJ的經驗后就使用開發可重用方面。當然可以選取其他的開發路徑。例如，一些開發者將從使用產品方面馬上得到好處，另外的人員可能馬上編寫可重用的方面。
AspectJ可以使用基于名字和基于屬性這兩種橫切點。使用基于名字橫切點的方面僅影響少數幾個類，雖然它們是小范圍的，但是比起普通的Java實現來說它們能夠減少大量的復雜度。使用基于屬性橫切點的方面可以有小范圍或著大范圍。使用AspectJ導致了橫切關注點的干凈、模塊化的實現。當編寫AspectJ方面時，橫切關注點的結構變得十分明顯和易懂。方面也是高度模塊化的，使得開發可拔插的橫切功能變成現實。
AspectJ提供了比這兩部分簡短介紹更多的功能。本系列的下一章內容，The AspectJ Language，將介紹 AspectJ語言的更多細節和特征。系列的第三章，Examples將通過一些完整的例子說明如何使用AspectJ。建議大家在仔細閱讀了接下來的兩章后再決定是否在項目中加入AspectJ。
三、AspectJ的高級特性
（一）、The reflection API
說到高級特性，首先要說的就是AspectJ提供的一套reflection API，主要包括JoinPoint、JoinPoint.StaticPart和Signature三個主要的接口。你可以從aspectj.jar中的javadoc來了解它們的詳細情況。那它們能提供什么功能呢？其實從字面上就能大致明白：通過這三個接口能訪問到Join Points的信息。譬如，調用thisJoinPoint.getArgs()就可以得到方法的參數列表。
（二）、Aspect precedence
在AspectJ中，pointcut和advice都會包含在一個aspect中。在應用系統中，對同一個join point會有多種advice（logging，caching等），這就會引出一個問題：如果系統中有很多的aspect，而這些aspect很有可能會捕獲同樣的join points，那這些aspect的執行順序是如何安排的呢？
AspectJ早已為我們考慮到了這個問題，它提供了一種設置aspect precedence的方法。對三種不同的advice來說：
1、before advice是先執行higher-precedence，后執行lower-precedence；
2、around advice是higher-precedence包含lower-precedence，當higher-precedence around advice沒有調用proceed()方法時，lower-precedence不會被執行；
3、after advice與before advice正好相反，先執行執行lower-precedence，然后執行higher-precedence。
那應該如何來聲明aspect precedence？非常簡單，只要在aspect中使用如下的語法即可：
declare precedence : TypePattern1, TypePattern2, ..;
從左往右，排在前面的是higher-precedence advice，后面的是lower-precedence。
（三）、Aspect association
在Java中，為了節省對象每次構建的耗費，增加效率，很多人會考慮使用Singleton模式，讓jvm中只有一個實例存在。AspectJ當然為我們考慮到這個問題，Aspect association實際上就是aspect與advised join point object的一種關聯關系，這很類似于OO中association，譬如1:1，1:m等。Aspect association能讓我們能更好地控制aspect的狀態信息。
在AspectJ中可以把Aspect association大致分為三類：
1、Per virtual machine (default)
一個jvm中只有一個aspect instance，AspectJ默認association。
2、Per object
每一個advised join point object都會產生一個aspect instance，不過同一個object instance只會產生一個aspect instance。
3、Per control-flow association
這種association稍微復雜一些，它主要針對程序調用的控制流，譬如：A方法調用B方法，B方法又調用C方法，這就是control-flow。
在aspect中聲明這三種association非常簡單，它的主要語法如下：
aspect [(
)] {
... aspect body
}
Per virtual machine是aspectj的默認association，不需要你額外的聲明，正常使用即可。
Per object主要有兩種方式：perthis()和pertarget()。perthis()主要用于execution object，pertarget()主要用于target object，兩者非常類似。
Per control-flow中也包含兩種方式：percflow()和percflowbelow()。這兩者也很類似，只是兩者的control-flow不太一樣而已。
維護aspect的狀態信息還有一種方法，就是使用introduce。可以在aspect中introduce member fields，通過fields來保存狀態信息。
四、AspectJ實例
使用方面的Tracing程序
寫一個具有跟蹤能力的類是很簡單的事情：一組方法，一個控制其開或關的布爾變量，一種可選的輸出流，可能還有一些格式化輸出能力。這些都是Trace類需要的東西。當然，如果程序需要的話，Trace類也可以實現的十分的復雜。開發這樣的程序只是一方面，更重要的是如何在合適的時候調用它。在大型系統開發過程中，跟蹤程序往往影響效率，而且在正式版本中去除這些功能十分麻煩，需要修改任何包含跟蹤代碼的源碼。出于這些原因，開發人員常常使用腳本程序以便向源碼中添加或刪除跟蹤代碼。
AspectJ可以更加方便的實現跟蹤功能并克服這些缺點。Tracing可以看作是面向整個系統的關注點，因此，Tracing方面可以完全獨立在系統之外并且在不影響系統基本功能的情況下嵌入系統。
應用實例
整個例子只有四個類。應用是關于Shape的。TwoShape類是Shape類等級的基類。
public abstract class TwoDShape {
protected double x, y;
protected TwoDShape(double x, double y) {
this.x = x; this.y = y;
}
public double getX() { return x; }
public double getY() { return y; }
public double distance(TwoDShape s) {
double dx = Math.abs(s.getX() - x);
double dy = Math.abs(s.getY() - y);
return Math.sqrt(dx*dx + dy*dy);
}
public abstract double perimeter();
public abstract double area();
public String toString() {
return (" @ (" + String.valueOf(x) + ", " + String.valueOf(y) + ") ");
}
}
TwoShape類有兩個子類，Circle和Square
public class Circle extends TwoDShape {
protected double r;
public Circle(double x, double y, double r) {
super(x, y); this.r = r;
}
public Circle(double x, double y) { this( x, y, 1.0); }
public Circle(double r) { this(0.0, 0.0, r); }
public Circle() { this(0.0, 0.0, 1.0); }
public double perimeter() {
return 2 * Math.PI * r;
}
public double area() {
return Math.PI * r*r;
}
public String toString() {
return ("Circle radius = " + String.valueOf(r) + super.toString());
}
}
public class Square extends TwoDShape {
protected double s; // side
public Square(double x, double y, double s) {
super(x, y); this.s = s;
}
public Square(double x, double y) { this( x, y, 1.0); }
public Square(double s) { this(0.0, 0.0, s); }
public Square() { this(0.0, 0.0, 1.0); }
public double perimeter() {
return 4 * s;
}
public double area() {
return s*s;
}
public String toString() {
return ("Square side = " + String.valueOf(s) + super.toString());
}
}
Tracing版本一
首先我們直接實現一個Trace類并不使用方面。公共接口Trace.java
public class Trace {
public static int TRACELEVEL = 0;
public static void initStream(PrintStream s) {...}
public static void traceEntry(String str) {...}
public static void traceExit(String str) {...}
}
如果我們沒有AspectJ，我們需要在所有需要跟蹤的方法或構造子中直接調用traceEntry和traceExit方法并且初試化TRACELEVEL和輸出流。以上面的例子來說，如果我們要跟蹤所有的方法調用（包括構造子）則需要40次的方法調用并且還要時刻注意沒有漏掉什么方法，但是使用方面我們可以一致而可靠的完成。TraceMyClasses.java
aspect TraceMyClasses {
pointcut myClass(): within(TwoDShape) || within(Circle) || within(Square);
pointcut myConstructor(): myClass() && execution(new(..));
pointcut myMethod(): myClass() && execution(* *(..));
before (): myConstructor() {
Trace.traceEntry("" + thisJoinPointStaticPart.getSignature());
}
after(): myConstructor() {
Trace.traceExit("" + thisJoinPointStaticPart.getSignature());
}
before (): myMethod() {
Trace.traceEntry("" + thisJoinPointStaticPart.getSignature());
}
after(): myMethod() {
Trace.traceExit("" + thisJoinPointStaticPart.getSignature());
}
}
這個方面在合適的時候調用了跟蹤方法。根據此方面，跟蹤方法在Shape等級中每個方法或構造子的入口和出口處調用，輸出的是各個方法的簽名。因為方法簽名是靜態信息，我們可以利用thisJoinPointStaticPart對象獲得。運行這個方面的main方法可以獲得以下輸出：
--> tracing.TwoDShape(double, double)
<-- tracing.TwoDShape(double, double)
--> tracing.Circle(double, double, double)
<-- tracing.Circle(double, double, double)
--> tracing.TwoDShape(double, double)
<-- tracing.TwoDShape(double, double)
--> tracing.Circle(double, double, double)
<-- tracing.Circle(double, double, double)
--> tracing.Circle(double)
<-- tracing.Circle(double)
--> tracing.TwoDShape(double, double)
<-- tracing.TwoDShape(double, double)
--> tracing.Square(double, double, double)
<-- tracing.Square(double, double, double)
--> tracing.Square(double, double)
<-- tracing.Square(double, double)
--> double tracing.Circle.perimeter()
<-- double tracing.Circle.perimeter()
c1.perimeter() = 12.566370614359172
--> double tracing.Circle.area()
<-- double tracing.Circle.area()
c1.area() = 12.566370614359172
--> double tracing.Square.perimeter()
<-- double tracing.Square.perimeter()
s1.perimeter() = 4.0
--> double tracing.Square.area()
<-- double tracing.Square.area()
s1.area() = 1.0
--> double tracing.TwoDShape.distance(TwoDShape)
--> double tracing.TwoDShape.getX()
<-- double tracing.TwoDShape.getX()
--> double tracing.TwoDShape.getY()
<-- double tracing.TwoDShape.getY()
<-- double tracing.TwoDShape.distance(TwoDShape)
c2.distance(c1) = 4.242640687119285
--> double tracing.TwoDShape.distance(TwoDShape)
--> double tracing.TwoDShape.getX()
<-- double tracing.TwoDShape.getX()
--> double tracing.TwoDShape.getY()
<-- double tracing.TwoDShape.getY()
<-- double tracing.TwoDShape.distance(TwoDShape)
s1.distance(c1) = 2.23606797749979
--> String tracing.Square.toString()
--> String tracing.TwoDShape.toString()
<-- String tracing.TwoDShape.toString()
<-- String tracing.Square.toString()
s1.toString(): Square side = 1.0 @ (1.0, 2.0)
Tracing版本二
版本二實現了可重用的tracing方面，使其不僅僅用于Shape的例子。首先定義如下的抽象方面Trace.java
abstract aspect Trace {
public static int TRACELEVEL = 2;
public static void initStream(PrintStream s) {...}
protected static void traceEntry(String str) {...}
protected static void traceExit(String str) {...}
abstract pointcut myClass();
}
為了使用它，我們需要定義我們自己的子類。
public aspect TraceMyClasses extends Trace {
pointcut myClass(): within(TwoDShape) || within(Circle) || within(Square);
public static void main(String[] args) {
Trace.TRACELEVEL = 2;
Trace.initStream(System.err);
ExampleMain.main(args);
}
}
注意我們僅僅在類中聲明了一個切點，它是超類中聲明的抽象切點的具體實現。版本二的Trace類的完整實現如下
abstract aspect Trace {
// implementation part
public static int TRACELEVEL = 2;
protected static PrintStream stream = System.err;
protected static int callDepth = 0;
public static void initStream(PrintStream s) {
stream = s;
}
protected static void traceEntry(String str) {
if (TRACELEVEL == 0) return;
if (TRACELEVEL == 2) callDepth++;
printEntering(str);
}
protected static void traceExit(String str) {
if (TRACELEVEL == 0) return;
printExiting(str);
if (TRACELEVEL == 2) callDepth--;
}
private static void printEntering(String str) {
printIndent();
stream.println("--> " + str);
}
private static void printExiting(String str) {
printIndent();
stream.println("<-- " + str);
}
private static void printIndent() {
for (int i = 0; i < callDepth; i++)
stream.print(" ");
}
// protocol part
abstract pointcut myClass();
pointcut myConstructor(): myClass() && execution(new(..));
pointcut myMethod(): myClass() && execution(* *(..));
before(): myConstructor() {
traceEntry("" + thisJoinPointStaticPart.getSignature());
}
after(): myConstructor() {
traceExit("" + thisJoinPointStaticPart.getSignature());
}
before(): myMethod() {
traceEntry("" + thisJoinPointStaticPart.getSignature());
}
after(): myMethod() {
traceExit("" + thisJoinPointStaticPart.getSignature());
}
}
它與版本一的不同包括幾個部分。首先在版本一中Trace用單獨的類來實現而方面是針對特定應用實現的，而版本二則將Trace所需的方法和切點定義融合在一個抽象方面中。這樣做的結果是traceEntry和traceExit方法不需要看作是公共方法，它們將由方面內部的通知調用，客戶完全不需要知道它們的存在。這個方面的一個關鍵點是使用了抽象切點，它其實與抽象方法類似，它并不提供具體實現而是由子方面實現它。
Tracing版本三
在前一版本中，我們將traceEntry和traceExit方法隱藏在方面內部，這樣做的好處是我們可以方便的更改接口而不影響余下的代碼。
重新考慮不使用AspectJ的程序。假設，一段時間以后，tracing的需求變了，我們需要在輸出中加入方法所屬對象的信息。至少有兩種方法實現，一是保持traceEntry和traceExit方法不變，那么調用者有責任處理顯示對象的邏輯，代碼可能如下
Trace.traceEntry("Square.distance in " + toString());
另一種方法是增強方法的功能，添加一個參數表示對象，例如
public static void traceEntry(String str, Object obj);
public static void traceExit(String str, Object obj);
然而客戶仍然有責任傳遞正確的對象，調用代碼如下
Trace.traceEntry("Square.distance", this);
這兩種方法都需要動態改變其余代碼，每個對traceEntry和traceExit方法的調用都需要改變。
這里體現了方面實現的另一個好處，在版本二的實現中，我們只需要改變Trace方面內部的一小部分代碼，下面是版本三的Trace方面實現
abstract aspect Trace {
public static int TRACELEVEL = 0;
protected static PrintStream stream = null;
protected static int callDepth = 0;
public static void initStream(PrintStream s) {
stream = s;
}
protected static void traceEntry(String str, Object o) {
if (TRACELEVEL == 0) return;
if (TRACELEVEL == 2) callDepth++;
printEntering(str + ": " + o.toString());
}
protected static void traceExit(String str, Object o) {
if (TRACELEVEL == 0) return;
printExiting(str + ": " + o.toString());
if (TRACELEVEL == 2) callDepth--;
}
private static void printEntering(String str) {
printIndent();
stream.println("Entering " + str);
}
private static void printExiting(String str) {
printIndent();
stream.println("Exiting " + str);
}
private static void printIndent() {
for (int i = 0; i < callDepth; i++)
stream.print(" ");
}
abstract pointcut myClass(Object obj);
pointcut myConstructor(Object obj): myClass(obj) && execution(new(..));
pointcut myMethod(Object obj): myClass(obj) &&
execution(* *(..)) && !execution(String toString());
before(Object obj): myConstructor(obj) {
traceEntry("" + thisJoinPointStaticPart.getSignature(), obj);
}
after(Object obj): myConstructor(obj) {
traceExit("" + thisJoinPointStaticPart.getSignature(), obj);
}
before(Object obj): myMethod(obj) {
traceEntry("" + thisJoinPointStaticPart.getSignature(), obj);
}
after(Object obj): myMethod(obj) {
traceExit("" + thisJoinPointStaticPart.getSignature(), obj);
}
}
在此我們必須在methods切點排除toString方法的執行。問題是toString方法在通知內部調用，因此如果我們跟蹤它，我們將陷入無限循環中。這一點不明顯，所以必須在寫通知時格外注意。如果通知回調對象，通常都回存在循環的可能性。
事實上，簡單的排除連接點的執行并不夠，如果在這之中調用了其他跟蹤方法，那么就必須提供以下限制
&& !cflow(execution(String toString()))
排除toString方法的執行以及在這之下的所有連接點。
總之，為了實現需求的改變我們必須在Trace方面中做一些改變，包括切點說明。但是實現的改變只局限于Trace方面內部，而如果沒有方面，則需要更改每個應用類的實現。
（來源：http://befresh.blogbus.com/logs/2004/08/339330.html；
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=15565）