AOP及其在Spring中的應用（一）

AOP簡介
OOP思想對現代編程產生了深遠的影響，但在某些方面，OOP也有其不足之處。比如在logging（日志）、transaction（事務）等方面，應用OOP將這些內容封裝為對象的行為則會產生大量的代碼重復，雖然通過一些設計模式可以減少這種重復，但我們還有更好的解決辦法，那就是AOP(Aspect Oriented Programming)。AOP是最近興起的一種編程思想，它是OOP思想的補充，而不是其對立面。
AOP，從字面的理解來看就是面向切面的編程，用一個比較通俗的例子來說，比如在訪問多個對象前需要進行權限檢查，那么如果按照面向對象的思路來說，權限檢查勢必會成為這多個對象的行為。如果每個對象都需要去實現這些行為，勢必會造成大量重復代碼的產生，寫程序也會變得枯燥無味。但我們可以將權限檢查看作是一個切面，所有對這些對象的訪問都要經過這個切面。要了解AOP，就必須先了解幾個基本的且非常重要的概念。

Aspect（切面）：對象操作過程中的截面。如權限檢查、日志、事務處理等。
Join Point（連接點）：程序運行中的某個階段點。如某個方法調用，異常拋出等。
Advice（處理邏輯）：某個連接點所采用的處理邏輯。
PointCut（切點）：一系列連接點的集合，它指明Advice在什么時候被觸發。

示例

還是用例子來說明一切，比如現在有一個DomainObjDAO接口以及其實現類DomainObjDAOImpl
DomainObjDAO.java:
public interface DomainObjDAO {
public void save();
}
DomainObjDAOImpl:
public class DomainObjDAOImpl implements DomainObjDAO {
private Logger logger = Logger.getLogger(this.getClass().getName());
public void save() {
System.out.println("saving domain object......");
}
現在需要在save方法中添加對該業務對象的鎖，比如在save前后加鎖和解鎖。拿到這個需求，在不影響外部調用邏輯以及不對現有代碼改動的前提下，Proxy模式（GOF）是個不錯的選擇，新增一個Proxy類同樣實現DomainObjDAO接口，在其實現方法中代理DomainObjDAOImpl類的save方法，并在save的前后調用lock以及unlock方法。這種方法使得我們不必改動外部調用邏輯以及現有代碼，但是如果有多個DomainObjImpl的情況下，該方法的弊端便暴露無遺，我們必須實現與DomainObjImpl個數相同的Proxy類來實現該功能，這對我們來說將是非�？植狼也豢山邮艿�。
這個例子再次印證我們開始所描述的，針對這類問題，OOP顯得有些力不從心，而AOP卻能很好的解決它，JDK1.3后所提供的動態代理的特性為我們利用AOP的思想解決這個問題提供了很好的思路，下面我們來看它如何實現。

動態代理實現AOP

public class LockHandler implements InvocationHandler {
private Logger logger = Logger.getLogger(this.getClass().getName());
private Object originalObject;

public Object bind(Object obj) {
logger.info("coming here...");
this.originalObject = obj;
return Proxy.newProxyInstance(
obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),this);}

public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
Object result=null;
if(arg1.getName().startsWith("save")){
lock();
result=arg1.invoke(this.originalObject,arg2);
unlock();
}
return result;
}
private void lock(){
logger.info("lock object...");
}
private void unlock(){
logger.info("unlock object...");
}
}
上述代碼中并沒有出現與具體應用層相關的接口以及類的引用，所以對所有的類都適用。這便解決了用普通Proxy類實現的弊端。但是動態代理要求所代理的類必須是某個接口的實現（這點可以通過obj.getClass().getInterfaces()看出），不過這也符合面向對象的設計思想，如果所代理的類沒有實現任何接口，可以通過GCLIB來實現，這里就不再詳述。

最后我們寫下一個TestCase來測試動態代理的實現，如下：
public class DyproxyTestCase extends TestCase {
private LockHandler handler=null;
private DomainObjDAOImpl daoImpl=null;
protected void setUp() throws Exception {
// TODO Auto-generated method stub
super.setUp();
handler=new LockHandler();
daoImpl=new DomainObjDAOImpl();

}

protected void tearDown() throws Exception {
super.tearDown();
}
public void testSave(){
((DomainObjDAO)handler.bind(daoImpl)).save();
}
}

運行結果如下：
2004-12-1 23:01:10 test.aop.dynamicproxy.LockHandler bind
信息: coming here...
2004-12-1 23:01:10 test.aop.dynamicproxy.LockHandler lock
信息: lock object...
saving domain object......
2004-12-1 23:01:10 test.aop.dynamicproxy.LockHandler unlock
信息: unlock object...

至此，我們用動態代理實現了AOP，Spring的AOP實現正是采用了動態代理，我將在下一個Blog中討論其實現。