IOC和AOP的一些基本概念
IOC和AOP的一些基本概念
介紹 IOC
介紹 IOC
一、什麽是IOC
IoC就是Inversion of Control，控制反轉。在Java開發中，IoC意味著將你設計好的類交給系統去控制，而不是在你的類內部控制。這稱為控制反轉。
下面我們以幾個例子來說明什麽是IoC
假設我們要設計一個Girl和一個Boy類，其中Girl有kiss方法，即Girl想要Kiss一個Boy。那麽，我們的問題是，Girl如何能夠認識這個Boy？
在我們中國，常見的ＭＭ與GG的認識方式有以下幾種
１ 青梅竹馬； ２ 親友介紹； ３ 父母包辦
那麽哪一種才是最好呢？
青梅竹馬：Girl從小就知道自己的Boy。
public class Girl {
void kiss(){
Boy boy = new Boy();
}
}
然而從開始就創建的Boy缺點就是無法在更換。並且要負責Boy的整個生命周期。如果我們的Girl想要換一個怎麽辦？（筆者嚴重不支持Girl經常更換Boy）
親友介紹：由中間人負責提供Boy來見面
public class Girl {
void kiss(){
Boy boy = BoyFactory.createBoy();
}
}
親友介紹，固然是好。如果不滿意，盡管另外換一個好了。但是，親友BoyFactory經常是以Singleton的形式出現，不然就是，存在於Globals，無處不在，無處不能。實在是太繁瑣了一點，不夠靈活。我為什麽一定要這個親友摻和進來呢？為什麽一定要付給她介紹費呢？萬一最好的朋友愛上了我的男朋友呢？
父母包辦：一切交給父母，自己不用費吹灰之力，只需要等著Kiss就好了。
public class Girl {
void kiss(Boy boy){
// kiss boy
boy.kiss();
}
}
Well，這是對Girl最好的方法，只要想辦法賄賂了Girl的父母，並把Boy交給他。那麽我們就可以輕松的和Girl來Kiss了。看來幾千年傳統的父母之命還真是有用哦。至少Boy和Girl不用自己瞎忙乎了。
這就是IOC，將對象的創建和獲取提取到外部。由外部容器提供需要的組件。
我們知道好萊塢原則：“Do not call us, we will call you.” 意思就是，You, girlie, do not call the boy. We will feed you a boy。
我們還應該知道依賴倒轉原則即 Dependence Inversion Princinple，DIP。
Eric Gamma說，要面向抽象編程。面向接口編程是面向對象的核心。
組件應該分為兩部分，即
Service, 所提供功能的聲明
Implementation, Service的實現
好處是：多實現可以任意切換，防止 “everything depends on everything” 問題．即具體依賴於具體。
所以，我們的Boy應該是實現Kissable接口。這樣一旦Girl不想kiss可惡的Boy的話，還可以kiss可愛的kitten和慈祥的grandmother。
二、IOC的type
IoC的Type指的是Girl得到Boy的幾種不同方式。我們逐一來說明。
IOC type 0：不用IOC
public class Girl implements Servicable {
private Kissable kissable;
public Girl() {
kissable = new Boy();
}
public void kissYourKissable() {
kissable.kiss();
}
}
Girl自己建立自己的Boy，很難更換，很難共享給別人，只能單獨使用，並負責完全的生命周期。
IOC type 1，先看代碼：
public class Girl implements Servicable {
Kissable kissable;
public void service(ServiceManager mgr) {
kissable = (Kissable) mgr.lookup(“kissable”);
}
public void kissYourKissable() {
kissable.kiss();
}
}
這種情況出現於Avalon Framework。一個組件實現了Servicable接口，就必須實現service方法，並傳入一個ServiceManager。其中會含有需要的其它組件。只需要在service方法中初始化需要的Boy。
另外，J2EE中從Context取得對象也屬於type 1。
它依賴於配置文件
<Container>
<component name=“kissable“ class=“Boy">
<configuration> … </configuration>
</component>
<component name=“girl" class=“Girl" />
</container>
IOC type 2：
public class Girl {
private Kissable kissable;
public void setKissable(Kissable kissable) {
this.kissable = kissable;
}
public void kissYourKissable() {
kissable.kiss();
}
}
Type 2出現於spring Framework，是通過JavaBean的set方法來將需要的Boy傳遞給Girl。它必須依賴於配置文件。
<beans>
<bean id=“boy" class=“Boy"/>
<bean id=“girl“ class=“Girl">
<property name=“kissable">
<ref bean=“boy"/>
</property>
</bean>
</beans>
IOC type 3
public class Girl {
private Kissable kissable;
public Girl(Kissable kissable) {
this.kissable = kissable;
}
public void kissYourKissable() {
kissable.kiss();
}
}
這就是PicoContainer的組件 。通過構造函數傳遞Boy給Girl。
PicoContainer container = new DefaultPicoContainer();
container.registerComponentImplementation(Boy.class);
container.registerComponentImplementation(Girl.class);
Girl girl = (Girl) container.getComponentInstance(Girl.class);
girl.kissYourKissable();
================
AOP 關註與主要的東西，也可以說讓你只關註與業務，其他的東西就讓AOP幫你完成。
我們要吃武昌魚：
public class Dinner {
Customer yangyi;
public void eatfish() {
yangyi.cookFish();
yangyi.eatFish();
yangyi.washDish();
}
}
prog 1
現在我覺得這頓飯吃的太不爽了，還要自己做,洗碗。
我想這樣
public class Dinner {
ICustomer yangyi;
public void eatfish() {
yangyi.eatFish();
}
}
prog 2
就是說我現在只用吃就行了，但是這樣可以麽？
誰來幫我做魚呢？這個我想就是所謂AOP吧，我只用關心我吃魚的方面就行了，做魚又食堂關註就行了。
現在看看誰來幫我cook fish呢，它怎麽做到的呢？
我看到上面prog 1中的Customer已經變成了prog 2中的ICustomer了，就是說如果願意，我可以用任意的ICustomer實現來替代yangyi了，這個就是一個Customer的代理，在調用 yangyi.eatfish的時候，之前代理會幫我調用cookfish()，之後代理會幫我調用washdish()
還是看看代碼吧
class Customer implements ICustomer {
void eatfish() {
//haha eat, delicious
}
}
class CustomerProxy implements ICustomer {
Customer yangyi = new Customer() //just for example. proxy is implement by dynamic proxy or other tech in real world
void eatfish() {
cookfish();
yangyi.eatfish();
washdish();
}
}
基本上就是說proxy會在調用我的Customer代碼之前和之後做一些工作，ok, 這就是AOP，不知道我講清楚了沒有。在spring中，proxy是用java的動態代理做的，在運行的時候自動生成CustomerProxy這個東西，然後用這個Proxy替代我的Customer。
為什麽老把IOC和AOP放在一起講呢，想想我們的Customer是怎麽來的吧
如果在某個時候我們說yangyi = new Customer()，那這樣Proxy怎麽替代這個Customer啊。
所以IoC說，你要用Customer麽，你直接說我要用，聲明他，告訴我怎麽樣能夠設置這個Customer，用的時候我會來調用你的(don‘t call me, but I call you)
所以真正的代碼應該是這樣的
public class Dinner {
ICustomer yangyi;
public void eatfish() {
yangyi.eatFish();
}
public void setYangyi(ICustomer customer) {
this.yangyi = customer;
}
}
我提供一個SetYangyi的方法，IoC會在運行時把yangyi設置成CustomerProxy，然後，我的代碼就只用盡情的享受武昌魚的美味了。其它的，留給ioc了。
BTW,煩死JDBC的connection.close()了吧，呵呵，IOC＋AOP應該最適合這方面了。
這兩個概念基本上是一個設計層的概念，主要講的就是怎麽去分離關註，用面向對象的話說，就是怎麽把職責進行分離。而這兩個模式，我個人認為都有一個共同點，就是變以前的主動為被動，而我認為，這種改變可能也是將來面向對象發展的一個趨勢。
首先說說什麽叫主動。寫過面向對象程序的人都知道，面向對象與面向過程的區別就是，面向對象是由一大堆對象組成的，對象通過協作完成面向過程中的任務。假設現在有對象A和B，那麽當A需要使用B中的方法時，那麽在A內部，就會有有一個對B方法的調用，這種調用就稱為主動調用。代碼大概會如下：
public class A{
B b;
public void methodA(){
b.methodB();
}
}
這裏為了下文解釋方便，我增加了一個調用點的定義，調用點就是調用發生的地方。也就是上面
b.methodB()中的b。
理解了什麽叫主動之後，我想就先介紹什麽叫IoC。IoC的全稱這裏就不說了，他的字面意思就是控制反轉。在上面的代碼當中，由於A調用了B的方法，因此就形成了一個A對B的依賴，這本身並沒有什麽問題。但是OO的思想是希望我們基於接口編程，而不是基於實現編程。因此，系統設計將不止是原有的A，B，而需要變成IA，IB，A，B，其中IA，IB是接口，A，B是對應的實現類，然後為了使得A中現在對B的實現依賴變成對接口的依賴，代碼應該變成這樣。
public class A implements IA{
IB b;
public void methodA(){
b.methodB();
}
}
這裏雖然我們是基於接口編程了，但大家知道，在這中間，我們需要有一個步驟把b指向一個IB的實現類B，這個怎麽做，就是IoC要做的事情，這裏就不細說了。但簡單來說，沒有IoC，我們可能需要在A中通過某種方法去獲取一個B的實例，但有了IoC，她就能在A不參與的情況下，給我們一個B的實例，所以，IoC要做的就是在調用點上從原來的主動生成一個調用點，變成被動的接受一個調用點。
接著就是AOP，全稱也不說了，字面意思就是面向方面編程。舉一個最普遍的例子，就是如果我們代碼需要做日誌的話，那麽在沒有AOP的時候，我們的代碼可能就是這樣：
public class A{
public void methodA(){
do log;
b.methodB();
}
}
這裏methodA()中的做日誌並不是方法本身的邏輯功能，而是一個附屬功能，因此，我們需要把它分離出去。怎麽分離，就是AOP要做的事情，簡單來說，就是系統在調用者不知情的情況下，為我們的類A增加了一個代理類，她把我們的類A包裝了起來，像這樣：
public class AP extends A{
A a;
public void methodA(){
do log;
a.methodA():
}
}
public class A{
public void methodA(){
b.methodB();
}
}
於是，當我們以為自己在調用A的methodA()方法時，實際調用的將是AP中的methodA()，於是就可以把做日誌的功能從原有的methodA()中分離了出去。所以，AOP要做的就是在用戶不知道的情況下，將我們的調用點包裹了起來，從而把原來的功能進行了分離。
這個基本上就是我對IoC和AOP的看法。歡迎指正。
IOC和AOP的一些基本概念