2023年摩根面試準備要點Java

摩根面試準備要點ＪＶM架構(Ｖｉncent)?

重要涉及兩個子系統(tǒng)和兩個組件:Clａsｓlｏadｅr（類裝載器)子系統(tǒng)，Exｅcｕtｉoｎenｇinｅ（執(zhí)行引擎)子系統(tǒng)；Runtimｅdａt(yī)aarｅa(運營時數(shù)據(jù)區(qū)域)組件，Nativeｉnteｒｆace(本地接口)組件。?

Ｃlａsｓloａdeｒ子系統(tǒng)的作用:根據(jù)給定的全限定名類名(如jａva.lang.Objeｃｔ）來裝載class文獻的內容到Rｕnｔimedａｔａaｒea中的methoｄarea（方法區(qū)域)。Ｊaｖsａ程序員可以ｅｘｔendsjavａ．lａnｇ.ClaｓsＬoadｅr類來寫自己的Ｃlasｓloader。?

Eｘecutionengｉne子系統(tǒng)的作用:執(zhí)行classes中的指令。任何JVMspecｉｆｉcation實現(xiàn)(JDK)的核心是Exｅｃｕtioneｎｇinｅ，換句話說:Sun的JＤK和IBM的JDK好壞重要取決于他們各自實現(xiàn)的Execution

ｅngine的好壞。每個運營中的線程都有一個Eｘecutionengiｎe的實例。

Natiｖeinterｆace組件:與nａt(yī)ivelibraries交互，是其它編程語言交互的接口。

?

Ruｎtimｅdａt(yī)aareａ組件：這個組件就是JVM中的內存。下面對這個部分進行具體介紹。Runtiｍedatａarea的整體架構圖Runtimｅdataarea重要涉及五個部分：Heap(堆),MeｔｈodAｒea(方法區(qū)域）,JavaＳｔａck（javａ的棧)，ProgｒamＣounｔer(程序計數(shù)器）,Ｎａt(yī)ivemｅthoｄstack(本地方法棧）。Hｅap和MethoｄArea是被所有線程的共享使用的;而Javastaｃｋ,Ｐrｏｇｒａmｃoｕｎter和Naｔiveｍｅtｈoｄstaｃk是以線程為粒度的，每個線程獨自擁有。?

Ｈeap

Javａ程序在運營時創(chuàng)建的所有類實或數(shù)組都放在同一個堆中。而一個Javａ虛擬實例中只存在一個堆空間，因此所有線程都將共享這個堆。每一個ｊava程序獨占一個JVM實例,因而每個java程序都有它自己的堆空間,它們不會彼此干擾。但是同一jａvａ程序的多個線程都共享著同一個堆空間，就得考慮多線程訪問對象(堆數(shù)據(jù))的同步問題。(這里也許出現(xiàn)的異常java.lａng.ＯuｔＯfMemoryEｒｒor:Javahｅapｓpaｃｅ）??Mｅｔhodareａ?在Jaｖa虛擬機中，被裝載的class的信息存儲在Meｔｈodａrea的內存中。當虛擬機裝載某個類型時,它使用類裝載器定位相應的class文獻，然后讀入這個ｃlaｓs文獻內容并把它傳輸?shù)教摂M機中。緊接著虛擬機提取其中的類型信息，并將這些信息存儲到方法區(qū)。該類型中的類（靜態(tài)）變量同樣也存儲在方法區(qū)中。與Hｅap同樣，ｍetｈoｄaｒea是多線程共享的,因此要考慮多線程訪問的同步問題。比如，假設同時兩個線程都企圖訪問一個名為Lava的類，而這個類還沒有內裝載入虛擬機,那么，這時應當只有一個線程去裝載它，而另一個線程則只能等待。(這里也許出現(xiàn)的異常java.ｌaｎg．ＯutＯfMemｏryError:PerｍGenfulｌ）

Ｊavasｔack?

Javａｓｔack以幀為單位保存線程的運營狀態(tài)。虛擬機只會直接對Jaｖasｔａcｋ執(zhí)行兩種操作:以幀為單位的壓?；虺鰲?。每當線程調用一個方法的時候,就對當前狀態(tài)作為一個幀保存到javastaｃk中（壓棧);當一個方法調用返回時，從javastack彈出一個幀(出棧)。棧的大小是有一定的限制，這個也許出現(xiàn)StaｃkOverFｌow問題。下面的程序可以說明這個問題。ｐｕｂlｉcclassTｅｓｔStaｃkOverFlow{?ｐublicｓtaｔiｃｖｏidmain(String[]aｒｇｓ){? Recurｓivｅｒ=nｅｗＲecursive();??r．dｏit(1000０);? //Eｘceｐtiｏｎiｎthｒｅad"main"jaｖａ.laｎg.StackＯverfｌowＥrror ｝}ｃlassＲeｃｕrｓiｖｅ{ publｉciｎtdoit(intt){? ｉf(t<＝1）{ ??return1; ｝??returｎt＋dｏit(t-1); }}

?Pｒogramｃounter?每個運營中的Java程序,每一個線程都有它自己的ＰC寄存器，也是該線程啟動時創(chuàng)建的。PＣ寄存器的內容總是指向下一條將被執(zhí)行指令的地址;，這里的地址可以是一個本地指針,也可以是在方法區(qū)中相相應于該方法起始指令的偏移量。

Nativemeｔhｏdstａck?對于一個運營中的Ｊava程序而言，它還能會用到一些跟本地方法相關的數(shù)據(jù)區(qū)。當某個線程調用一個本地方法時，它就進入了一個全新的并且不再受虛擬機限制的世界。本地方法可以通過本地方法接口來訪問虛擬機的運營時數(shù)據(jù)區(qū),不止與此，它還可以做任何它想做的事情。比如，可以調用寄存器,或在操作系統(tǒng)中分派內存等?？傊?，本地方法具有和ＪVM相同的能力和權限。（這里出現(xiàn)JＶM無法控制的內存溢出問題nativehｅapOutOfMｅmory)

CＬassLoadｅｒ(Vincｅnt）Javａ的可執(zhí)行文獻不同于C/C＋＋，Javａ編譯器只產生中間字節(jié)碼文獻（．class文獻)，由Ｊava虛擬機（jaｖａ.exe）解釋執(zhí)行。Jaｖa發(fā)布的程序（ＪAR包)也多半是一堆class文獻,運營時由ClaｓｓLｏaｄer加載到Jaｖａ虛擬機中執(zhí)行。CｌａｓsLoadｅr是Java虛擬機的重要組成部分,由Java語言編寫,用戶可以實現(xiàn)自定義的CｌａssLｏaｄer來完畢特定的功能。下面我們用例子說明ＣlaｓsＬoａder。JＶＭ規(guī)范定義了兩種類型的ＣlａssLoader：BootｓtｒapClassLoadｅr和Usｅr-deｆｉneｄCｌassLｏader。ＪVM在運營時會產生三個CｌａｓｓＬoaｄer：ＢｏoｔｓｔｒapＣlassLｏadeｒ、EｘｔenｓionCｌassLｏader和AppClａssLｏａder。Bｏoｔstｒａp是用Ｃ++編寫的，我們在Java中看不到它,是nuｌl,是JVM自帶的類裝載器,用來裝載核心類庫，如ｊａva.lａｎg.*等。AppＣlａssLoaｄer的Ｐaｒenｔ是ＥxtＣlassＬｏader,而ＥｘtClassLoaｄer的Ｐarenｔ為BootstrapＣlａsｓＬoader。java中，什么叫不可更改的類（immｕｔablｅclaｓs)(KｅvinTam)從字面意思來理解就是不會發(fā)生變化的類,那么是什么不會發(fā)生變化呢，其實就是類的狀態(tài),也就是不變類的實例一旦被創(chuàng)建,其狀態(tài)就不會發(fā)生變化，舉個例子：假如人是一個class,那么我們中的每一個都是人這個類的具體的iｎstａnce,假如人這個類只有一個狀態(tài)就是生身父母,那么它就是一個不變類，由于每一個人在出生的那一剎那，生身父母就已經被設立了值,并且終生都不會發(fā)生變化。不變類有什么好處呢?１)不變類是線程安全的,由于不變類的狀態(tài)在創(chuàng)建以后不再發(fā)生變化,所以它可以在線程之間共享，而不需要同步。2)不變類的ｉｎsｔance可以被rｅuse創(chuàng)建類的實例需要花費CPU的時間,當這個實例不再被引用時，將會被垃圾回收掉,這時候，又需要花費CPU的時間。對于不變類而言，一個好處就是可以將常用的實例進行緩存，從而減少了對象的創(chuàng)建。舉個例子，對于布爾型,最常用的便是trueａndfalse。JDK中的Ｂooleａn類就是一個不變類，并且對這兩個實例進行了緩沖。ｐｕblicfinａlcｌａssBoolｅanimpｌeｍｅｎtsｊａva.iｏ．Serｉaｌizabｌe｛/＊**Ｔhe<codｅ>Booｌeａｎ</cｏde＞ｏbjectｃｏｒresｐondingtotｈeｐrｉmitive*vａｌue<ｃode>true＜／ｃｏdｅ>.*/pubｌicstaticｆｉnalBｏｏｌeanTRUE＝newBｏｏｌean（truｅ);/***The<ｃode>Ｂoolean</ｃoｄe>ｏbjectcorresｐｏｎdiｎgtoｔhepｒｉｍitive＊vａｌue＜ｃode＞falsｅ<／codｅ＞．*／pｕｂｌiｃstaticfiｎalＢooleanFＡLSE=newＢooｌeａｎ(faｌsｅ)；//這個方法不會創(chuàng)建新的對象，而是重用已經創(chuàng)建好的inｓtａｎceｐublicstaｔicBoｏｌeａnｖａluｅOf（ｂｏoleanb){rｅｔurn(b?TRＵE：ＦALSE);}}3）不變類的某些方法可以緩存計算的結果haｓhＣode這個方法來自于Obｊecｔ這個類，這個方法用來返回對象的ｈaｓｈCodｅ,重要用于將對象放置到hashtabｌe中時,來擬定這個對象的存儲位置。對于一個不變類的實例,它的hashCode也是不變的,所以就可以緩存這個計算的結果，來提高性能，避免不必要的運算,JDK中的Ｓtriｎｇ類就是一個例子。pubｌicfinalｃlasｓＳｔring{/**Cａｃhetｈeｈaｓhcoｄefoｒtｈestring*/pｒivａt(yī)einthａsh;／/Deｆaulｔto0ｐubｌicintｈashＣode()｛inｔh=ｈash;ｉf(h==0){/／cｏｍputetheｖaｌuｅｈasｈ＝h;／／ｃａcheｔhevaluｅ}rｅtｕｒnｈ;}}在JDK中,Ｓtrｉng，thｅpriｍｉtiｖｅwｒaｐｐｅrclａsseｓ，aｎｄBigIntｅgerandBｉgＤecimａl都是不變類。假如一個類是不變類，這個類是不是就不能有改變狀態(tài)的方法呢?答案當然是否認的,Sｔrｉnｇ是一個不變類，仍然有ｒeｐlaｃe，ｒeｐlaceAll這樣的方法，而Ｓtｒing仍然是一個不變類，那是由于在這些改變狀態(tài)的方法中,每次都是新創(chuàng)建一個Ｓtｒiｎg對象。假如大家理解了不變類，那也就不難理解為什么在做Strｉnｇ的concａt(yī)enate時,應當用SｔrinｇBuffeｒ而不是用＋的操作符。如何對的使用Ｓtrinｇ呢?1)不要用ｎew去創(chuàng)建Stｒiｎg對象。假如使用ｎew去創(chuàng)建Ｓtring,那么每次都會創(chuàng)建一個新對象。puｂlicstaticvｏidmain（Sｔｒｉng[]args）｛ＳtringＡ1＝"A";StrinｇＡ2="A";／／Iｔｗoｎ'tcreateaneｗobjectcｈeckIｎstａｎcｅ(A１，Ａ2);/／Result:TｈeyareｓaｍｅinstanｃeｓStringB1=neｗStrｉng("Ａ"）;//ｃreatｅanewoｂjecｔStringＢ2=nｅwStriｎg(＂A"）;//crｅaｔａnｅwoｂｊectcｈeckInsｔaｎce（Ｂ1,B2);//Reｓult:Theyarｅｄｉffｅrentinｓtａnｃeｓ}ｐrivatｅstatｉcvｏidchｅckInstａnce(Striｎgａ1,Stｒｉnga2)｛if（a１==a2){Ｓyｓｔem．oｕｔ.printｌｎ("Theyaresａｍｅｉnsｔances"）；}else{Sｙstem.ｏut．pｒintｌｎ("Ｔheyarｅdiｆfeｒeｎtｉnstaｎｃes")；｝}2)應當用StriｎgＢｕffer來做連接操作由于Ｓtriｎg是一個不變類，那么在做連接操作時，就會創(chuàng)建臨時對象來保存中間的運算結果,而SｔｒｉngBｕｆfｅr是一個mutａblecｌａｓｓ,這樣就不需要創(chuàng)建臨時的對象來保存結果，從而提高了性能。JＡVAGarbageColｌｅction（Vｉnｃent)垃圾分代回收算法(GeneraｔionalColleｃting）

基于對對象生命周期分析后得出的垃圾回收算法。把對象分為年青代、年老代、持久代,對不同生命周期的對象使用不同的算法(上述方式中的一個)進行回收?，F(xiàn)在的垃圾回收器(從J２SE1.２開始）都是使用此算法的。

??如上圖所示,為Jａva堆中的各代分布。?１．Younｇ(年輕代)JVMｓpeｃiｆicatiｏn中的Ｈeap的一部份

年輕代分三個區(qū)。一個Edeｎ區(qū),兩個Sｕrvｉvoｒ區(qū)。大部分對象在Edeｎ區(qū)中生成。當Eｄen區(qū)滿時,還存活的對象將被復制到Suｒｖivor區(qū)（兩個中的一個),當這個Survｉvｏr區(qū)滿時，此區(qū)的存活對象將被復制到此外一個Surｖivor區(qū),當這個Ｓｕｒｖivoｒ去也滿了的時候,從第一個Survivor區(qū)復制過來的并且此時還存活的對象，將被復制年老區(qū)（Ｔenｕrｅd）;。需要注意,Surviｖoｒ的兩個區(qū)是對稱的,沒先后關系,所以同一個區(qū)中也許同時存在從Ｅｄen復制過來對象,和從前一個Ｓｕrvｉvor復制過來的對象,而復制到年老區(qū)的只有從第一個Survivｏr去過來的對象。并且，Survivor區(qū)總有一個是空的。

2.Tenureｄ(年老代）ＪVMspecificａt(yī)ion中的Heａp的一部份

年老代存放從年輕代存活的對象。一般來說年老代存放的都是生命期較長的對象。?3.Ｐerm(持久代）JVMspｅcifiｃatｉoｎ中的Methodarea?用于存放靜態(tài)文獻，如今Java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應用也許動態(tài)生成或者調用一些class,例如Hiｂernate等,在這種時候需要設立一個比較大的持久代空間來存放這些運營過程中新增的類。持久代大小通過-XX:MaxPermSizｅ=進行設立。?采用分區(qū)管理機制的JＶM將ＪVＭ所管理的所有內存資源分為2個大的部分。永久存儲區(qū)（PｅrmanentＳpａce)和堆空間(TheHｅapＳｐace)。其中堆空間又分為新生區(qū)(Young（New)generationsｐace）和養(yǎng)老區(qū)（Tｅnuｒe(Old）genｅrationｓｐacｅ），新生區(qū)又分為伊甸園（Edｅnｓpaｃe),幸存者0區(qū)（Survｉvor0sｐace）和幸存者1區(qū)（Sｕrvivor１spaｃe）。具體分區(qū)如下圖:

?那ＪVM他的這些分區(qū)各有什么用途,請看下面的解說。

永久存儲區(qū)（PermaｎeｎｔSpａce):永久存儲區(qū)是JVM的駐留內存,用于存放JDＫ自身所攜帶的Ｃlaｓs,Inteｒfａce的元數(shù)據(jù)，應用服務器允許必須的Clａsｓ，Ｉnｔｅrface的元數(shù)據(jù)和Jａva程序運營時需要的Clａss和Ｉnterface的元數(shù)據(jù)。被裝載進此區(qū)域的數(shù)據(jù)是不會被垃圾回收器回收掉的,關閉JＶM時,釋放此區(qū)域所控制的內存。?

堆空間（ＴhｅHeapＳpaｃe）：是JAVA對象生死存亡的地區(qū)，JAＶA對象的出生，成長，死亡都在這個區(qū)域完畢。堆空間又分別按JＡVA對象的創(chuàng)建和年齡特性分為養(yǎng)老區(qū)和新生區(qū)。??新生區(qū)(Yｏｕｎｇ(New)geｎｅｒaｔionspace)：新生區(qū)的作用涉及JAVA對象的創(chuàng)建和從JAVA對象中篩選出能進入養(yǎng)老區(qū)的ＪAＶＡ對象。??伊甸園(Ｅdenｓpace）：JAＶA對空間中的所有對象在此出生,該區(qū)的名字因此而得名。也即是說當你的JＡVA程序運營時，需要創(chuàng)建新的對象,JVＭ將在該區(qū)為你創(chuàng)建一個指定的對象供程序使用。創(chuàng)建對象的依據(jù)即是永久存儲區(qū)中的元數(shù)據(jù)。?

幸存者0區(qū)(Sｕrｖiｖoｒ０spaｃe）和幸存者1區(qū)（Survｉvor1sｐace)：當伊甸園的空間用完時,程序又需要創(chuàng)建對象;此時JＶM的垃圾回收器將對伊甸園區(qū)進行垃圾回收，將伊甸園區(qū)中的不再被其他對象所引用的對象進行銷毀工作。同時將伊甸園中的尚有其他對象引用的對象移動到幸存者0區(qū)。幸存者0區(qū)就是用于存放伊甸園垃圾回收時所幸存下來的JＡＶA對象。當將伊甸園中的尚有其他對象引用的對象移動到幸存者0區(qū)時，假如幸存者0區(qū)也沒有空間來存放這些對象時，ＪVM的垃圾回收器將對幸存者0區(qū)進行垃圾回收解決，將幸存者０區(qū)中不在有其他對象引用的JAＶA對象進行銷毀，將幸存者0區(qū)中尚有其他對象引用的對象移動到幸存者1區(qū)。幸存者１區(qū)的作用就是用于存放幸存者0區(qū)垃圾回收解決所幸存下來的ＪAVA對象。

養(yǎng)老區(qū)（Ｔenure(Oｌd)geｎeｒationｓpａｃｅ):用于保存從新生區(qū)篩選出來的JＡVA對象。

上面我們看了JVＭ的內存分區(qū)管理，現(xiàn)在我們來看JVM的垃圾回收工作是如何運作的。一方面當啟動J２EE應用服務器時，JVM隨之啟動，并將JＤK的類和接口,應用服務器運營時需要的類和接口以及J2EE應用的類和接口定義文獻也及編譯后的Claｓs文獻或JＡR包中的Ｃlａss文獻裝載到JVM的永久存儲區(qū)。在伊甸園中創(chuàng)建JVＭ，應用服務器運營時必須的JAＶA對象,創(chuàng)建Ｊ2EE應用啟動時必須創(chuàng)建的JAVA對象；J2EE應用啟動完畢,可對外提供服務。?ＪVＭ在伊甸園區(qū)根據(jù)用戶的每次請求創(chuàng)建相應的JＡＶA對象,當伊甸園的空間局限性以用來創(chuàng)建新JAVA對象的時候，JVM的垃圾回收器執(zhí)行對伊甸園區(qū)的垃圾回收工作，銷毀那些不再被其他對象引用的JAVA對象（假如該對象僅僅被一個沒有其他對象引用的對象引用的話，此對象也被歸為沒有存在的必要，依此類推)，并將那些被其他對象所引用的JＡVＡ對象移動到幸存者0區(qū)。

假如幸存者０區(qū)有足夠控件存放則直接放到幸存者0區(qū)；假如幸存者0區(qū)沒有足夠空間存放，則ＪＶM的垃圾回收器執(zhí)行對幸存者0區(qū)的垃圾回收工作,銷毀那些不再被其他對象引用的JAVA對象(假如該對象僅僅被一個沒有其他對象引用的對象引用的話,此對象也被歸為沒有存在的必要,依此類推），并將那些被其他對象所引用的ＪAVA對象移動到幸存者1區(qū)。?假如幸存者１區(qū)有足夠控件存放則直接放到幸存者1區(qū);假如幸存者0區(qū)沒有足夠空間存放,則JVM的垃圾回收器執(zhí)行對幸存者０區(qū)的垃圾回收工作,銷毀那些不再被其他對象引用的JAVA對象(假如該對象僅僅被一個沒有其他對象引用的對象引用的話,此對象也被歸為沒有存在的必要,依此類推)，并將那些被其他對象所引用的ＪAＶA對象移動到養(yǎng)老區(qū)。

假如養(yǎng)老區(qū)有足夠控件存放則直接放到養(yǎng)老區(qū);假如養(yǎng)老區(qū)沒有足夠空間存放,則JVM的垃圾回收器執(zhí)行對養(yǎng)老區(qū)區(qū)的垃圾回收工作，銷毀那些不再被其他對象引用的JＡVＡ對象(假如該對象僅僅被一個沒有其他對象引用的對象引用的話,此對象也被歸為沒有存在的必要，依此類推),并保存那些被其他對象所引用的JＡＶＡ對象。假如到最后養(yǎng)老區(qū),幸存者1區(qū),幸存者０區(qū)和伊甸園區(qū)都沒有空間的話,則ＪVM會報告“JVＭ堆空間溢出（ｊava.lａng.OutOfMemoｒyErrｏr:Javahｅaｐspaｃe）”，也即是在堆空間沒有空間來創(chuàng)建對象。?這就是JVＭ的內存分區(qū)管理，相比不分區(qū)來說；一般情況下，垃圾回收的速度要快很多;由于在沒有必要的時候不用掃描整片內存而節(jié)省了大量時間。?通常大家還會碰到此外一種內存溢犯錯誤“永久存儲區(qū)溢出（ｊaｖa.laｎｇ.OｕｔＯfMｅmoryErrｏr:JavaPerｍａneｎtSpace)”。所有的垃圾收集算法都面臨同一個問題,那就是找出應用程序不可到達的內存塊，將其釋放，這里面得不可到達重要是指應用程序已經沒有內存塊的引用了，而在ＪAＶＡ中，某個對象相應用程序是可到達的是指:這個對象被根（根重要是指類的靜態(tài)變量,或者活躍在所有線程棧的對象的引用）引用或者對象被另一個可到達的對象引用。Ｒefｅｒｅnｃe

Ｃｏuｎting(引用計數(shù)）

引用計數(shù)是最簡樸直接的一種方式，這種方式在每一個對象中增長一個引用的計數(shù),這個計數(shù)代表當前程序有多少個引用引用了此對象，假如此對象的引用計數(shù)變?yōu)?，那么此對象就可以作為垃圾收集器的目的對象來收集。優(yōu)點:簡樸，直接，不需要暫停整個應用缺陷:1.需要編譯器的配合，編譯器要生成特殊的指令來進行引用計數(shù)的操作,比如每次將對象賦值給新的引用,或者者對象的引用超過了作用域等。2.不能解決循環(huán)引用的問題跟蹤收集器跟蹤收集器一方面要暫停整個應用程序,然后開始從根對象掃描整個堆，判斷掃描的對象是否有對象引用，這里面有三個問題需要搞清楚：１.假如每次掃描整個堆,那么勢必讓GC的時間變長,從而影響了應用自身的執(zhí)行。因此在JVM里面采用了分代收集，在新生代收集的時候miｎｏr

ｇc只需要掃描新生代,而不需要掃描老生代。2．ＪVM采用了分代收集以后，mｉnor

gc只掃描新生代,但是mｉnor

gc怎么判斷是否有老生代的對象引用了新生代的對象，ＪＶM采用了卡片標記的策略,卡片標記將老生代提成了一塊一塊的，劃分以后的每一個塊就叫做一個卡片,JＶM采用卡表維護了每一個塊的狀態(tài)，當ＪAVA程序運營的時候,假如發(fā)現(xiàn)老生代對象引用或者釋放了新生代對象的引用,那么就JＶM就將卡表的狀態(tài)設立為臟狀態(tài)，這樣每次mｉｎor

ｇc的時候就會只掃描被標記為臟狀態(tài)的卡片，而不需要掃描整個堆。具體如下圖:3.GC在收集一個對象的時候會判斷是否有引用指向對象，在JAVA中的引用重要有四種:Stｒong

reｆereｎce,Ｓoft

rｅference，Ｗeａｋ

refｅｒeｎｃe,Ｐhantom

rｅfeｒｅncｅ.Stｒｏng

Referｅｎce

強引用是JAVA中默認采用的一種方式，我們平時創(chuàng)建的引用都屬于強引用。假如一個對象沒有強引用,那么對象就會被回收。ｐuｂｌic

ｖｏid

tｅｓtStrｏngＲｅｆｅrｅncｅ(){Oｂjecｔ

referent

=

new

Ｏbject();Oｂject

stｒongReference

=

rｅfeｒenｔ；reｆeｒent

=

null；Ｓysteｍ．gc()；ａsｓｅrtNoｔNull(stｒongRｅfeｒeｎce);｝

Ｓoft

Ｒeference軟引用的對象在ＧC的時候不會被回收,只有當內存不夠用的時候才會真正的回收,因此軟引用適合緩存的場合,這樣使得緩存中的對象可以盡量的再內存中待長期一點。Publiｃ

voiｄ

testSoftRefeｒencｅ(）{Stｒiｎg

sｔr

=

＂ｔesｔ";SｏfｔＲeferｅnce<Strｉng＞

softｒeｆerenｃｅ

=

new

ＳoftReferｅｎce<Ｓtring>(str);stｒ=nulｌ;Sｙsｔeｍ.ｇc()；assｅrｔNｏtＮull(sｏfｔreferencｅ.geｔ()）;}

Ｗeak

ｒｅｆｅrencｅ弱引用有助于對象更快的被回收，假如一個對象沒有強引用只有弱引用,那么在GC后,這個對象肯定會被回收。Public

void

testWeakＲefereｎce(){String

stｒ

=

"tｅsｔ";WeａkＲeferｅncｅ<Sｔrｉｎg>

wｅakRefereｎce

=

neｗ

WｅaｋＲeferenｃｅ<Stｒing＞（stｒ);ｓtr=nｕlｌ;Sysｔem．ｇc()；asseｒtNull（weａｋＲeference．ｇｅt(））；}

Phａntom

refeｒence

Ｍark-Ｓwｅep

Ｃollector(標記-清除收集器）標記清除收集器最早由Lisp的發(fā)明人于1960年提出,標記清除收集器停止所有的工作,從根掃描每個活躍的對象，然后標記掃描過的對象，標記完畢以后，清除那些沒有被標記的對象。優(yōu)點:1

解決循環(huán)引用的問題2

不需要編譯器的配合，從而就不執(zhí)行額外的指令缺陷：1．每個活躍的對象都要進行掃描，收集暫停的時間比較長。Copyiｎg

Coｌlｅｃｔor(復制收集器）復制收集器將內存分為兩塊同樣大小空間，某一個時刻,只有一個空間處在活躍的狀態(tài),當活躍的空間滿的時候,ＧC就會將活躍的對象復制到未使用的空間中去，本來不活躍的空間就變?yōu)榱嘶钴S的空間。復制收集器具體過程可以參考下圖：優(yōu)點：1

只掃描可以到達的對象，不需要掃描所有的對象，從而減少了應用暫停的時間缺陷：1．需要額外的空間消耗，某一個時刻，總是有一塊內存處在未使用狀態(tài)2．復制對象需要一定的開銷Mark-Cｏｍpａct

Ｃoｌlｅctoｒ(標記-整理收集器）標記整理收集器汲取了標記清除和復制收集器的優(yōu)點，它分兩個階段執(zhí)行,在第一個階段，一方面掃描所有活躍的對象,并標記所有活躍的對象，第二個階段一方面清除未標記的對象，然后將活躍的的對象復制到堆得底部。標記整理收集器的過程示意圖請參考下圖：

Maｒk-ｃｏmpact策略極大的減少了內存碎片，并且不需要像Ｃｏpy

Ｃｏｌlecｔor同樣需要兩倍的空間。JVM的垃圾收集策略

GC的執(zhí)行時要花費一定的CＰU資源和時間的,因此在JDK１.2以后，JＶＭ引入了分代收集的策略，其中對新生代采用"Maｒk-Ｃompacｔ"策略,而對老生代采用了“Mａｒk-Ｓwｅep"的策略。其中新生代的垃圾收集器命名為“minｏr

gc”,老生代的GＣ命名為＂Fｕｌl

Gｃ

或者Major

GC＂.其中用Systｅm.gｃ（)強制執(zhí)行的是Fｕll

Gc.SprｉｎgIOCaｎｄAOP(Mｉnjiｎ)IｏC和AOＰ都是Spring的核心思想??

當然，最為一個框架級的輕量組件,大量的配置文獻是不可缺少的,但是核心是要把這些配置文獻,配置節(jié)組裝起來，并將核心代碼編寫為完全業(yè)務無關的。我們看看Sprｉnｇ是怎么做的。

一方面，IoＣ,控制反轉。Sｐring開發(fā)的基本思想：面向接口的編程模式?？蚣茏龅脑蕉?應當越能發(fā)現(xiàn)接口在其中起到的作用，而Spring將這種想法，開始貫徹到業(yè)務的開發(fā)中了。Bean的Seｔ方法使用接口作為參數(shù)，保證其擴展性，實現(xiàn)依賴關系的松偶爾。所謂的控制反轉，作為中文更好理解的一個翻譯應當是依賴注入,把依賴的類采用接口的方式,運用Set函數(shù),傳入Bｅaｎ的內部，實現(xiàn)與外界的解耦合。這種注入也可作用于構造函數(shù)。

另一方面，AOP,面向切面的編程方式,我覺得更通俗的說法應當是對容器內的Bean進行方法干涉。被容器中創(chuàng)建的類,看起來執(zhí)行一個普通的函數(shù)調用,由于被容器預解決,而會在方法執(zhí)行前／后進行一些其他的、可配置的操作。當然，這種方法也同樣是面向接口的，或者直接使用反射的。運用java.ｌang.ｒeｆlecｔ.Iｎvocａt(yī)ｉonHandler接口可以達成這種干涉的效果。下面是轉載的一個簡樸示例。Jaｖa代碼imporｔ

ｊava.lang.ｒefleｃt.Invｏcａt(yī)ionHanｄler；

imporｔ

java．ｌanｇ.refｌeｃt.Mｅthod;

imｐoｒｔ

ｊaｖa.lａｎg．rｅflect．Ｐroxｙ；

publｉc

clａss

DｙnａＰrｏｘyＨello

impｌemeｎts

InｖoｃaｔionＨandｌer

{

private

Object

proxy;

ｐｒｉvate

Obｊｅct

deleｇatｅ;

ｐｕblic

Objecｔ

ｂiｎd(Ｏbｊeｃt

delegaｔe,Ｏbｊect

proxy)

{

ｔｈis.prｏxy

=

ｐroxｙ;

thｉs．dｅlｅgate

=

deleｇate;

reｔuｒn

Proxy.ｎewＰrｏｘyInｓtanｃe(

thｉｓ.dｅｌeｇａｔe.gｅｔClａss()．gｅtＣlasｓＬoaｄer（),

tｈis.delegate

.getClass().getＩnterｆaｃeｓ（),

tｈis);

ｐublic

Objeｃt

ｉｎvoke(Object

pｒｏｘｙ,

Mｅthod

method,

Ｏbject［］

ａrgs)

ｔｈｒｏws

Throｗａble

{

Object

ｒesult

＝

nｕll;

try

{

//反射得到操作者的實例

Ｃlａsｓ

clazｚ

=

this.ｐｒoｘy．gｅｔＣｌａｓs();

//反射得到操作者的Sｔaｒt方法

Ｍｅthod

stａｒｔ

＝

clazz.geｔDeclaredMeｔhod("stａrt"，

new

Claｓｓ[]

{

Mｅthｏｄ．ｃｌass

});

/／反射執(zhí)行starｔ方法

staｒt.invoｋｅ(tｈiｓ.ｐｒoxｙ,

ｎew

Ｏbjｅｃt［]

{

mｅtｈｏd

})；

/／執(zhí)行要解決對象的原本方法

rｅsult

＝

ｍｅthｏd.invokｅ(this．deｌegatｅ，

arｇs);

／/

反射得到操作者的enｄ方法

Methoｄ

end

＝

ｃlazz．gｅｔＤeclaredＭethｏd("end",

nｅw

Cｌass[]

｛

Mｅｔhod.cｌasｓ

}）;

／/

反射執(zhí)行end方法

end.invoke(ｔhｉxy,

new

Object[]

{

ｍetｈod

｝);

}

ｃａt(yī)cｈ

（Eｘcｅptioｎ

e)

{

ｅ.ｐrｉntStackTrace()；

｝

retｕrｎ

rｅsult;

｝

}

puｂlic

ｃlass

Tｅst

{

public

static

void

maiｎ(String[］

aｒgs)

{

IHello

ｈeｌlo

=

(ＩHello)ｎｅw

DyｎaPrｏxyＨelｌo().bind（new

Ｈeｌlo(),ｎeｗ

LｏgｇeｒOperatｉｏｎ()）;

hello.saｙＧｏｏｇBｙe("Double

J")；

ｈello.saｙHello("Douｂｌｅ

Ｊ＂);

}

}

??

當然,不是只有這一個實現(xiàn)方式,javａ的代理功能只能代理接口，假如要代理類的化，可以使用cｇlｉb。?

Ｓｐring框架當然不會是上述的那么簡樸（事實上它非常復雜）,但是我關注的是核心的實現(xiàn)方式和設計思想。在有些時候，我們不需要使用Sprｉｎg,甚至不能使用Spｒing（比如不用Jａｖa開發(fā)）,但是這種思想和方式是可以復用的。使用這種設計思想，按照當前的語言和環(huán)境規(guī)定，實現(xiàn)自己的IoC和AOP框架。Spriｎg框架(Minjin)Ｓprｉｎg框架是一個分層架構，由7個定義良好的模塊組成。Ｓpring模塊構建在核心容器之上,核心容器定義了創(chuàng)建、配置和管理ｂｅａn的方式,如圖1所示。

圖１．Sｐｒiｎg框架的7個模塊

組成Ｓpring框架的每個模塊(或組件)都可以單獨存在,或者與其他一個或多個模塊聯(lián)合實現(xiàn)。每個模塊的功能如下:核心容器：核心容器提供Spｒｉnｇ框架的基本功能。核心容器的重要組件是BeanFactｏry，它是工廠模式的實現(xiàn)。BｅanFａctorｙ使用控制反轉(IOC)模式將應用程序的配置和依賴性規(guī)范與實際的應用程序代碼分開。Ｓprinｇ上下文:Spｒｉng上下文是一個配置文獻,向Sprｉｎg框架提供上下文信息。Spring上下文涉及公司服務,例如JNDＩ、EJB、電子郵件、國際化、校驗和調度功能。SｐriｎgＡＯP：通過配置管理特性，ＳpｒingAOP模塊直接將面向方面的編程功能集成到了Sprｉng框架中。所以，可以很容易地使Sｐring框架管理的任何對象支持AＯP。SprinｇＡＯＰ模塊為基于Spｒing的應用程序中的對象提供了事務管理服務。通過使用SprinｇAOP，不用依賴EＪB組件,就可以將聲明性事務管理集成到應用程序中。SprinｇDAO:JＤＢＣDAＯ抽象層提供了故意義的異常層次結構,可用該結構來管理異常解決和不同數(shù)據(jù)庫供應商拋出的錯誤消息。異常層次結構簡化了錯誤解決，并且極大地減少了需要編寫的異常代碼數(shù)量(例如打開和關閉連接）。SpｒｉngDＡO的面向JDBＣ的異常遵從通用的DAO異常層次結構。SprｉngOＲM：Ｓpring框架插入了若干個ＯＲM框架，從而提供了ＯRＭ的對象關系工具,其中涉及JDO、Ｈｉbｅrｎａt(yī)e和ｉBatｉsSQLMap。所有這些都遵從Spriｎｇ的通用事務和DAO異常層次結構。ＳｐrｉngWｅb模塊:Ｗeｂ上下文模塊建立在應用程序上下文模塊之上,為基于Weｂ的應用程序提供了上下文。所以，Spring框架支持與ＪakaｒtaStruｔｓ的集成。Web模塊還簡化了解決多部分請求以及將請求參數(shù)綁定到域對象的工作。SpringMVC框架:MVC框架是一個全功能的構建Ｗeb應用程序的MVC實現(xiàn)。通過策略接口，MＶC框架變成為高度可配置的,MVＣ容納了大量視圖技術，其中涉及JSＰ、Velocｉty、Tiｌes、iText和POＩ。Spring框架的功能可以用在任何J２ＥＥ服務器中，大多數(shù)功能也合用于不受管理的環(huán)境。Ｓｐｒinｇ的核心要點是:支持不綁定到特定Ｊ2EE服務的可重用業(yè)務和數(shù)據(jù)訪問對象。毫無疑問，這樣的對象可以在不同Ｊ2EE環(huán)境（Wｅb或EＪB)、獨立應用程序、測試環(huán)境之間重用。SpringAOＰ兩種實現(xiàn)機制(ＢaｏminｇChai）SPＲＩNG是通過動態(tài)代理來實現(xiàn)ＡＯＰ的,SＰＲING內部提供了2種實現(xiàn)機制?1．假如是有接口聲明的類進行AＯP,ｓpring調用的是ｊａva.lang.reflｅctioｎ.Prｏxｙ類來做解決org.sprinｇframeworｋ．aop.ｆramewoｒk．JdkＤyｎaｍicAopProxy ｐubliｃOｂjectｇetPrｏxy(ClaｓｓＬoaｄeｒclaｓsLoadeｒ）{ ?ｉｆ(loggｅr.iｓDebｕgEnabled()){?? ClaｓsｔaｒgeｔCｌａsｓ=ｔｈis．ａdｖisｅd.ｇetＴargetSource().getTargetCｌaｓs(); logger.debug（"ＣreatinｇJDKｄynamｉcpｒoxy"+ ??(tａｒgetCｌass!＝null?＂for[＂+tａｒgetClaｓs．getName()+"］":＂")）； ?}? Class[]prｏxiedIｎterfａces=ＡopPrｏxyUｔpｌetePｒoxｉedInterfａcｅs(tｈis.ａdvｉｓed);??ｒｅtｕｒnProxｙ.newPｒoxｙInsｔanｃe(ｃlaｓｓLoadeｒ,pｒoｘiｅdInｔeｒfａceｓ,this);?}orｇ.spriｎｇｆｒamework.ａop.fｒａｍeｗork.ReflecｔiｖeMethodＩnｖocaｔionｐuｂlicＯbｊeｃtpｒoｃｅｅｄ()ｔhrowｓThrｏwａbｌe{? // Westarｔwｉthaｎindｅｘof-１andincｒementearlｙ.? if（ｔhiｓ．ｃurrentＩnterceptoｒIndeｘ==tｈis．ｉntercepｔｏrｓAndDｙｎamiｃMethodMａt(yī)chｅrs．ｓize(）-1）｛? ｒｅtｕrninvｏkeJoiｎpｏint();? } ObｊecｔｉｎｔｅｒceptorOrＩntｅrcｅptｉoｎＡdvice= ｅrceptorsAndDynamicMethoｄＭａｔcherｓ.ｇet(++ｔhｉs.cuｒｒentIntｅrcｅptｏrIｎｄｅx);??if(intercepｔorOrInｔeｒceｐtiｏｎAdvicｅinstaｎceｏｆIntｅｒｃｅptorAｎｄDyｎａmiｃMｅｔhodＭatcher)｛ ??／/Evaｌｕatedｙｎamｉｃｍｅthoｄｍatcherｈｅre:stａt(yī)icpaｒｔwiｌlaｌrｅadyｈａve //beenevaluａt(yī)ｅdandfoundtomatch．???InｔerｃeptorAnｄDyｎａmicMethoｄMａt(yī)cheｒdｍ= ?（ＩｎteｒｃeｐtorＡnｄDynａmicMetｈｏdＭatcher)intｅrｃｅptoｒOｒInterｃepｔiｏnAdviｃe;???ｉf（dm.methodＭａt(yī)cheｒ．maｔches(tｈis．ｍｅthｏd,thiｓ.tarｇetＣlasｓ,ｔhis.arguｍents)){ ? ｒeturnｄm.inｔercｅptｏr.invoke(tｈiｓ); ?} ??ｅｌse{? ?／／Dｙnamｉcmatchinｇfaiｌｅd．? ??//Skipthisintｅｒceｐtoraｎdｉnvｏkethenextintｈechaｉn.????rｅｔurnprｏｃｅed(); ??} }??else{ ? /／It'saninterceptｏr，sowｅｊusｔinｖoｋｅit:Tｈepoｉｎtcuｔwｉｌlhave?? ／/beeneｖaluａｔeｄstａt(yī)iｃallybeｆorｅｔhisobｊectwasconsｔrｕcｔeｄ． ?reｔurｎ((ＭeｔｈodIｎterceｐtor)inｔｅrcｅptｏｒOrIｎｔerｃepｔiｏｎAdｖice).invoｋｅ(ｔhis)； ?} }2.假如是沒有接口聲明的類呢?SPRING通過CGLＩB包和內部類來實現(xiàn)priｖａt(yī)estａｔicclａssStatｉcＵnaｄvisｅdＩnｔercepｔoｒiｍｐｌemenｔsMethodInｔercｅpｔoｒ,Serｉaliｚable｛??privａｔefiｎalObjecttarget; ?pubｌiｃStaticUnadｖisedＩnｔeｒceｐｔｏr(Objecｔｔａrｇet){???ｔhis.taｒget=tａrｇｅt; ?｝ ?ｐuｂlicObｊｅctiｎtｅrcept(Oｂjeｃtproxy,Methodmethod,Objｅct[]args, MeｔhoｄPｒoxyｍeｔhｏｄPｒoxy)throwsＴｈrowaｂle{? ObｊecｔretVal=ｍethodProxｙ.invoｋe(target，aｒgｓ);???returｎｍassagｅRetｕrnＴypeIfNeｃｅｓsary(proxy,tａrget，ｒetVal）; } }?/** ＊Meｔhodinteｒｃｅptorｕｓeｄｆoｒstaticｔaｒgｅtswｉtｈｎｏａｄviceｃｈａin，whenｔhe *ｐroxyistobeｅxposeｄ. ＊/ ｐｒiｖatesｔaｔicclassＳtaｔiｃUnadvｉsedExposedIntercｅpｔorimpｌementｓMethｏdInterceptoｒ,Seriaｌizable{ ?prｉvatefｉnalObｊｅctｔarget;??pｕbｌicStaticUｎaｄvisedEｘpｏｓedＩnteｒceptor(Objecｔtaｒget）{ ? thｉs．taｒget=tａrｇet;??｝ publｉｃOｂｊectiｎtercept(Objeｃtproxy，Mｅtｈｏdｍethｏｄ,Objｅｃt［］arｇs,MethodＰrｏxｙmetｈodProxy）thｒowsThrｏwabｌｅ{ ? ＯbjeｃtｏldProxy=nｕll； tｒy{ ?olｄPｒoｘy=ＡoｐCoｎｔext.setCurｒeｎtPrｏxy（ｐｒoｘy)；? ?OｂjectｒetＶａl=ｍethodＰroｘy.ｉnｖoｋｅ（ｔａrgｅt,arｇs); retuｒｎmassａｇeReｔurnTypeIfＮeｃessary(prｏｘy，ｔarget,rｅtVａｌ）;? ?} ? fiｎally｛?? ?AopＣｏntext.sｅtCuｒrｅｎtPｒoxy(oldＰroxy); ?} }?}?/** *Interceptｏrusedtｏｉnvokeadynamiｃtａrgeｔｗｉｔhoutｃreatinｇamethｏｄ?＊ｉnvoｃationｏrevaluａt(yī)ingａｎaｄｖiceｃhain.(Ｗeｋnowtherｅwaｓnoadvicｅ?*foｒｔhismｅｔｈｏd.） ＊/ privatecｌasｓDynamicUnadvisedＩntercｅptoｒimplemｅntｓMethoｄIｎtercepｔor,Ｓｅriaｌizaｂlｅ{??puｂliｃObjecｔｉntercept(Objeｃtproxy,Methoｄｍｅthoｄ,Objｅｃt［]ａrgs,ＭetｈｏdPrｏｘｙｍｅｔｈodPｒｏxy)tｈｒoｗsＴhrowable{ Ｏbｊecｔtａｒｇeｔ=ａdｖised．ｇｅtTarｇetSoｕrce().gｅtTargｅｔ(）;? ?trｙ｛ ? OｂｊectretＶal=ｍeｔhoｄProxy.ｉnvｏke（ｔａrget，args); ?? reｔurnmassaｇeＲｅturnTyｐeIfNecｅssaｒy(proxy，targeｔ,ｒeｔVal); ?} fiｎally{ ??advised.ｇｅtＴaｒgetSoｕrce()．releaseTaｒget(tａrｇｅt)； ? } ｝?} ／**?*Iｎterceｐtorfoｒｕnadviseｄdynamiｃtａrgeｔswｈenｔhｅpｒoｘyneeｄsexposiｎg.?*/?ｐrivatｅｃｌａｓsＤynamicUnadvｉｓｅdＥxpｏsedIｎtercepｔoｒｉmｐlemｅntｓMethoｄInterceptor,Sｅｒｉalizａｂｌe{ ?publｉcＯbjｅctｉｎtercｅｐt(Objｅｃｔproxy，Ｍethodmetｈod，Objｅｃt［］ａrgs，MｅthodPｒｏｘymetｈodProxy）tｈrowsTｈroｗaｂｌｅ｛?? OｂjectｏｌｄＰroｘy=null; Ｏｂjｅcｔtargｅｔ=advｉｓeｄ．gｅtTargetSｏuｒce（).ｇetTarｇｅt(); ?tｒy{? ? oldＰroxy=AopCoｎteｘt.seｔCurｒentＰroxy(proxy)； ? ?ObjectretＶal=ｍeｔｈｏdPｒoxy.iｎvｏｋｅ（target,arｇｓ)；? ??ｒeｔｕrnｍassageReturnＴｙpｅIfＮeceｓｓary(pｒoｘy,targeｔ,ｒetVal）; ?} ??finallｙ｛ AopConｔext.sｅtＣurrenｔProｘy(oldPrｏxy）; ? advised.gｅtＴargｅｔSoｕrce（).releａｓeTargｅt(tarｇet); } } }我們自己也可以來試試?1.ｊdkproxy方式?

先來一個接口

IHelloWorld.jaｖapacｋagekris.aｏp.tesｔ;pｕｂｌｉcｉnteｒｆａｃeＩHelloWoｒlｄ｛?publicvｏidpｒinｔ(Strinｇname)； pｕblicvoidwｒite（Stringsｔｈ);｝再來一個實現(xiàn)

?HｅｌloWoｒld.jaｖapａckａgｅｋris.aop．teｓt;pubｌiｃｃlａssHelloWorlｄｉmpｌemeｎtsＩHellｏWoｒld{?pｕblｉcｖoidprinｔ(Ｓtrｉngnaｍｅ){ ?Sｙｓteｍ.oｕt.println(＂HｅllｏWoｒｌd"+nａme）；?} pｕblicvｏidwrｉtｅ（Stｒｉｎgsｔh){??Ｓｙstem.ｏuｔ.priｎｔlｎ("wriｔe"＋sth）； ? ｝}代理類

DeｆａultInｖｏｃａt(yī)ionＨａndler.javaｐaｃkagekｒｉs．aｏｐ.test；imｐoｒｔjaｖa.lang.ｒeflｅct．Iｎvocａt(yī)ioｎHaｎdleｒ;imporｔjａva.lang.ｒefleｃt.Method；ｐublｉcｃlａｓsDefaultInｖoｃatioｎHａndｌeｒimｐlementsＩｎvocaｔionHanｄleｒ{ ／** ＊替換外部ｃlasｓ調用的方法 *obj 外部已經已經包裝好ＩｎｖｏｃationHaｎdｌer的實例?＊methｏd 外部方法 *args??方法參數(shù)?*/ publiｃＯbｊeｃtinvoke(Ｏbjｅcｔｏbj，Methｏｄｍethｏd,Obｊｅｃt[］aｒgｓ)? tｈrｏwsThrowable{ ?Ｓtringｓ1[］＝｛"kｒｉs"};? Sｔriｎgｓ2［］={"anyｏne＂}; IHeｌｌoＷorｌｄｉhw=ｎewHｅｌloWｏｒld()；? Ｓystｅｍ.out.ｐｒintｌｎ（"starｔ!＂）； metｈoｄ.iｎｖｏke(iｈw,aｒgs);??mｅtｈod.invoｋｅ（ihw,ｓ1);??Oｂjecto=method.ｉnｖｏｋe(iｈw,s2);??System．ｏut.ｐrintｌn（"stoｐ!");??returｎo; }}測試類?Tesｔ.jaｖａpackageｋrｉs.aop.test;imｐorｔjａｖa.lａng．reflect．ＩnvoｃatｉoｎＨandler;importjava.laｎg.refｌect．Proxｙ;ｐｕbliｃcｌasｓTesｔ{?publicsｔaｔiｃｖｏｉdｍaｉn(Stringａrｇs[]){??Ｃlaｓscｌａｚz=newHeｌlｏWorｌd(）．geｔＣlasｓ(）；? ClａssLoadercl=clazz.ｇｅtCｌassLoａｄｅr();? Classclasseｓ[］=clａｚｚ.geｔIｎtｅrｆaｃes(); ＩnｖoｃatｉonＨaｎdlｅｒiｈ=neｗDefaulｔInvocationHandlｅr（); //用InvocationHandlｅr給HelloWorld進行AＯP包裝 ?IHelloＷorldihw=（ＩHｅlloＷorld)Prｏxy.ｎewＰroｘｙInsｔａｎce(cｌ,classes,ih);? ihw.ｐrinｔ("ｔest"）;??ihw．ｗｒite("test"); ｝}2.用CGLIＢ包實現(xiàn)，一方面不要忘了引入那個包paｃkａgekriｓ.ａｏp.ｃglｉb.tｅsｔ；publｉｃｃlassＨelloWｏrｌd{?publicvｏidpriｎｔ(Stringｎaｍe）{? Sｙsｔem．oｕｔ.ｐｒiｎtln(＂HｅｌloＷorｌd＂＋ｎamｅ); }?pｕｂlｉcvｏidｗritｅ(Strｉngsth）｛??Sysｔeｍ．ｏut.ｐrintlｎ("wｒｉte＂+sth); ｝?pｕblicｖoidprint(）{??Ｓysｔem.ouｔ.pｒintｌn（＂ＨeｌloＷoｒld"); ｝}代理類(沒用內部類,看起來清楚點)paｃkaｇekris.aop．cｇlib.ｔest；impｏrtｊava．lanｇ.reflect.Ｍｅthod；iｍportｎeｔ．sf.ｃglｉxy．MethｏｄＩnteｒcepｔoｒ;ｉｍporｔｎet.sｆ.ｃglib.ｐroxy．MethodProxy;pｕbｌiｃｃlａsｓＭeｔｈｏdＩnｔeｒcｅptorImplｉｍpｌｅmentsMethodInterｃeptor{?puｂlｉcObjecｔinｔercｅpt（Obｊecｔobｊ，Meｔhoｄｍethod,Obｊecｔ［］args， ? MetｈodProxyｐroxy)ｔｈrowsThroｗabｌe{? Systeｍ．oｕｔ.pｒintln(ｍｅtｈod）;??prｏxｙ．iｎvokeSｕｐer(obj，argｓ); rｅtｕrnnull; }}測試類ｐａckａｇekris.aop.ｃglib.ｔｅsｔ;importnet.sf.cgｌib.pｒoｘｙ.Enhancｅr;pｕbliccｌassＴest{ pｕblicｓtaticvｏidmａiｎ(Sｔrｉng[]aｒgs){??Enhancereｎhanｃｅr=neｗEｎhａｎcｅｒ(); enhancer.setSuperclass(HeｌｌoWｏrld.ｃlａsｓ); //設立回調方法實現(xiàn)類 ｅnｈancer.ｓetCallback(newＭeｔhodIntercepｔorImpl()）;??／/實例化已經添加回調實現(xiàn)的ＨELLＯWORＬD實例 HellｏWｏrldmｙ=(ＨelｌｏWorld)enhａnceｒ．cｒeaｔe(); ｍy.pｒint();?}}SprｉｎgAOP的底層實現(xiàn)技術（BaｏmｉngＣhai，SｔephenYu)AOＰ概述軟件的編程語言最終的目的就是用更自然更靈活的方式模擬世界,從原始機器語言到過程語言再到面向對象的語言,我們看到編程語言在一步步用更自然、更強大的方式描述軟件。AＯＰ是軟件開發(fā)思想的一個奔騰，AＯP的引入將有效填補ＯＯＰ的局限性,OOP和AOP分別從縱向和橫向對軟件進行抽象，有效地消除反復性的代碼，使代碼以更優(yōu)雅的更有效的方式進行邏輯表達。AOP有三種植入切面的方法:其一是編譯期織入,這規(guī)定使用特殊的Java編譯器,AspeｃtJ是其中的代表者;其二是類裝載期織入,而這規(guī)定使用特殊的類裝載器，ＡｓpecｔJ和AspecｔWeｒkｚ是其中的代表者；其三為動態(tài)代理織入，在運營期為目的類添加增強生成子類的方式,SpringAOＰ采用動態(tài)代理織入切面。SｐringＡOP使用了兩種代理機制，一種是基于JDＫ的動態(tài)代理，另一種是基于CGLｉb的動態(tài)代理，之所以需要兩種代理機制,很大限度上是由于JDＫ自身只提供基于接口的代理，不支持類的代理?；贘DK的代理和基于CGLｉb的代理是SｐrｉｎgAＯP的核心實現(xiàn)技術，結識這兩代理技術,有助于探究ＳｐringＡOＰ的實現(xiàn)機理。只要你樂意,你甚至可以拋開Ｓpring，提供自己的AOP實現(xiàn)。帶有橫切邏輯的實例

?一方面，我們來看一個無法通過OOP進行抽象的反復代碼邏輯，它們就是AＯP改造的重要對象。下面,我們通過一個業(yè)務方法性能監(jiān)視的實例了解橫切邏輯。業(yè)務方法性能監(jiān)視,在每一個業(yè)務方法調用之前開始監(jiān)視,業(yè)務方法結束后結束監(jiān)視并給出性能報告:代碼清單2ForumSeｒvice：包含性能監(jiān)視橫切代碼ｐaｃkaｇecom.baobaotao.ｐroxy;?pubｌｉcclassFｏrｕmSerｖiｃｅImｐｌimｐlementsＦｏｒｕmSeｒviｃe...{

publicvoｉｄｒeｍoｖeToｐic（inttopｉcId)...｛

/／開始性能監(jiān)視?

ＰerfoｒｍaｎceMoniｔor.beｇiｎ（＂coｍ.baｏbaotao.pｒoxy.FｏrumSｅrviｃｅＩmpl.ｒemoｖｅTopｉｃ＂);?

Sysｔem.oｕt.pｒｉnｔln（"模擬刪除Topｉc記錄:"＋topｉｃId）;?

trｙ..．{

Thread．currｅｎｔThrｅａd().slｅep（20);

}catch(Ｅxｃeptｉoｎe)...{?

tｈrｏwｎｅwRuntimｅExcｅｐtiｏn(ｅ);?

}?

/／結束監(jiān)視、并給出性能報告信息?

PｅrformanceMoｎitor.end()；

}

pｕblｉcvoｉdremovｅFｏrum(intforumId)...{

／/開始性能監(jiān)視?ＰｅrfoｒmanｃｅＭonitor.begin("com.baｏbaｏtao．prｏxy．ForuｍServicｅImpl.remｏveＦorｕｍ＂);?

System.out.println("模擬刪除Fｏrum記錄："+fｏｒumId);?

try..．{?

Thrｅaｄ.currｅntTｈrｅad（).ｓleｅp(40);?

}caｔcｈ（Exceptioｎe）...｛?

throｗnewRuntimeＥxcepｔion（e)；?

}?

//結束監(jiān)視、并給出性能報告信息

ＰerformaｎceＭonｉtｏr.eｎd();?

}?}代碼清單２中粗體表達的代碼就是具有橫切特性的代碼,需要進行性能監(jiān)視的每個業(yè)務方法的前后都需要添加類似的性能監(jiān)視語句。?

我們保證實例的完整性，我們提供了一個非常簡樸的性能監(jiān)視實現(xiàn)類，如所示代碼清單3所示：代碼清單３PerｆｏrmanceMonitorpackagecｏm.ｂaｏｂaｏtａo.ｐroxｙ;puｂｌiｃclａssＰeｒformancｅMonitｏｒ{

/／通過一個ThｒeａdＬｏｃaｌ保存線程相關的性能監(jiān)視信息

privａt(yī)eｓｔaｔicＴhreadLocaｌ<MethodPerfoｒmａｃe>performaｃeRecord=?neｗThrｅaｄLocal<MｅthodPeｒformace＞(）;

publｉcstaticｖoidbeｇin(Ｓｔriｎgｍetｈod）{

Ｓysteｍ.out.prinｔln（"bｅｇinｍonitｏr...＂);

MeｔhodＰerｆormａｃemｐ＝newMｅｔｈodPerｆorｍａcｅ(methｏd);

pｅrforｍaｃeRecｏｒd.ｓet(ｍp);?

｝

ｐubｌicstａt(yī)icｖｏidｅnd(){

Ｓyｓtem．out.ｐｒintln("endmｏnitｏr...");

MｅｔhodPerformaceｍp=peｒfｏrmａceRｅcorｄ．get();?

mp.prｉｎtＰerfｏrmace();／／打印出業(yè)務方法性能監(jiān)視的信息

}

｝PerformaｎｃeMｏniｔｏｒ提供了兩個方法,bｅgｉｎ（Strinｇｍeｔhod)方法開始對某個業(yè)務類方法的監(jiān)視,ｍethod為業(yè)務方法的署名，而eｎd(）方法結束對業(yè)務方法的監(jiān)視，并給出性能監(jiān)視的信息。由于每一個業(yè)務方法都必須單獨記錄性能監(jiān)視數(shù)據(jù),所以我們使用了ＴｈreａdLocal，ThｒeadLｏcaｌ是削除非線程安全狀態(tài)的不二法寶。ThreadLoｃal中的元素為方法性能記錄對象MethodPｅｒformａce,它的代碼如下所示：代碼清單４MeｔｈodPerｆormaｃｅpackaｇｅcom.baｏbaotaｏ.prｏｘｙ;?publicclａsｓMethoｄPerfoｒmace{?

priｖatelｏｎgbｅgｉn;

privａt(yī)elongend;?

privａt(yī)eStringｓｅrviceMeｔhod；?

publicMeｔhodPeｒfｏrmａcｅ(ＳｔｒingsｅrviceMeｔhod)｛

this.serviｃｅＭethod＝sｅrvｉcｅMｅthoｄ;

ｔhｉs.bｅgｉｎ=Sysｔｅｍ.ｃurrｅｎtTimeMｉllis();／/記錄方法調用開始時的系統(tǒng)時間?

｝?

pｕblｉcvoidprintＰerfoｒmaｃe（){?

//以下兩行程序得到方法調用后的系統(tǒng)時間,并計算出方法執(zhí)行花費時間

end=System．currentTimeMillis(）;?

ｌongelapse=end－bｅgin；

//報告業(yè)務方法執(zhí)行時間?

Ｓysｔem.oｕt.ｐrｉnｔln(serviceMethｏd＋＂花費"＋elａpｓe+"毫秒。");

}?｝通過下面代碼測試這個擁有方法性能監(jiān)視能力的業(yè)務方法：ｐackagecoｍ.ｂaoｂaotａo.ｐroｘｙ;

ｐublicclassTｅstFoｒumSeｒviｃe{?

ｐｕblicｓtatｉcｖoidｍａｉn(Sｔriｎｇ［]args)｛?

ForuｍServiceforumＳｅrvｉce=newForｕmSｅｒｖiceImpl(）;?

foruｍService．removeForum(1０);

ｆorumSｅrｖｉce．reｍoveＴopic(1０1２）；

}

｝我們得到以下的輸出信息:beginmoｎitor．.．?模擬刪除Ｆorｕm記錄:1０

endmｏniｔor...

com．baoｂａxｙ.FｏｒumServiceIｍpl.removｅFｏruｍ花費47毫秒。begｉｎmｏnｉｔoｒ..．?模擬刪除Topｉc記錄:1012

eｎdmoｎiｔor...?com.baobaoｔao．proｘy．ForｕｍＳerｖiceImpl．remoｖeTopｉc花費16毫秒。如實例所示,要對業(yè)務類進行性能監(jiān)視，就必須在每個業(yè)務類方法的前后兩處添加上反復性的啟動性能監(jiān)視和結束性能監(jiān)視的代碼。這些非業(yè)務邏輯的性能監(jiān)視代碼破壞了作為業(yè)務類FoｒumSｅrviceImｐl的純粹性。下面,我們分別ＪDK動態(tài)代理和CGLｉb動態(tài)代理技術,將業(yè)務方法中啟動和結束性能監(jiān)視的這些橫切代碼從業(yè)務類中完畢移除。JDK動態(tài)代理

?在JＤK１.3以后提供了動態(tài)代理的技術，允許開發(fā)者在運營期創(chuàng)建接口的代理實例。在Sｕn剛推出動態(tài)代理時，還很難想象它有多大的實際用途,現(xiàn)在我們終于發(fā)現(xiàn)動態(tài)代理是實現(xiàn)AOP的絕好底層技術。

ＪＤＫ的動態(tài)代理重要涉及到java.lａng．reflecｔ包中的兩個類:Pｒoxy和InvｏｃatｉｏnHaｎｄler。其中IｎvoｃatiｏnHandler是一個接口,可以通過實現(xiàn)該接口定義橫切邏輯,在并通過反射機制調用目的類的代碼，動態(tài)將橫切邏輯和業(yè)務邏輯編織在一起。

?而Pｒoｘｙ為InvocatioｎＨandｌer實現(xiàn)類動態(tài)創(chuàng)建一個符合某一接口的代理實例。這樣講一定很抽象，我們立即著手動用Proxy和InvocationHaｎdleｒ這兩個魔法戒對上一節(jié)中的性能監(jiān)視代碼進行AOＰ式的改造。

?一方面,我們從業(yè)務類ForuｍSｅrviceImｐl中刪除性能監(jiān)視的橫切代碼,使ForuｍSeｒviｃeImpｌ只負責具體的業(yè)務邏輯,如所示：代碼清單5ＦorumＳerviｃｅＩmpｌ：移除性能監(jiān)視橫切代碼pａckａgecom.bａｏbaｏtao．proxy;

puｂlicclａｓsFｏrumServｉceImpｌｉｍｐｌｅmenｔｓFoｒuｍSerｖｉcｅ{

ｐubｌicvoiｄｒeｍoｖeＴopｉc(iｎｔｔｏpicＩd)｛

①

Systｅm.ｏut.prｉnｔln("模擬刪除Ｔｏｐic記錄:"＋ｔｏpicＩd）；?

try{

Thread．ｃurrｅntThreａｄ().sｌeep（20);?

}caｔch(Eｘceｐtione)｛?

throｗｎeｗRuntｉmeExｃｅpｔion(e);

｝

②

}?

publicｖoidremｏｖeForum(ｉｎｔfoｒｕmＩd){?

①

Ｓysｔem.ｏｕt.println（"模擬刪除Forｕm記錄:＂＋forumId);?

try{?

Thread.curｒenｔＴhｒeａｄ()．sleep(40);

}catｃh(Exceptione)｛

ｔhrownｅwＲuntimeEｘｃeptｉon(e）;?

}

②?

}?}在代碼清單５中的①和②處，本來的性能監(jiān)視代碼被移除了，我們只保存了真正的業(yè)務邏輯。

?從業(yè)務類中移除的橫切代碼當然還得找到一個寄居之所,ＩnvocatioｎＨandｌer就是橫切代碼的家園樂土,我們將性能監(jiān)視的代碼安頓在PerｆｏｒmａｃeＨandｌer中，如代碼清單6所示：代碼清單6PerformａｃeHaｎdleｒｐacｋagｅｃom.ｂaobaotａo．proxy;

imｐｏrtjavａ．lang.reｆｌect.Inｖｏcａt(yī)ionHandler;?impoｒtjava.lang.refｌecｔ．Mｅthod；publicclassPerfoｒｍａceHａnｄleｒimｐｌemenｔｓＩnｖocａt(yī)ioｎHaｎdlｅr{

privateObｊecｔtａrgｅt;?

ｐｕbliｃPerｆormacｅHaｎｄler(Objecttargｅｔ){//①targeｔ為目的的業(yè)務類?

this.taｒｇet=targeｔ;

｝?

pｕbｌicＯbｊeｃtinvoke(Objｅctprｏxｙ,Mｅｔhoｄmethoｄ,Objeｃt[]ａｒgs)

ｔhrowsThrｏwａblｅ{?

PeｒｆｏrmanceMonitoｒ.begin(taｒget.gｅtClass()．ｇｅｔＮame(）+"."+meｔhod．geｔName());?

Objectｏbj=ｍetｈod.ｉnvokｅ(taｒget,ａrgs）;//②通過反射方法調用目的業(yè)務類的業(yè)務方法?

PerfｏｒmaｎceMonｉｔor.ｅnｄ();?

ｒeturnobj；?

}?}粗體部分的代碼為性能監(jiān)視的橫切代碼,我們發(fā)現(xiàn),橫切代碼只出現(xiàn)一次,而不是本來那樣星灑各處。大家注意②處的methoｄ.invoke（)，該語句通過反射的機制調用目的對象的方法，這樣Ｉｎvｏcａt(yī)ionHandleｒ的inｖoke（Obｊecｔproxy,Methｏdmethod,Obｊeｃｔ[]args)方法就將橫切代碼和目的業(yè)務類代碼編織到一起了，所以我們可以將InvocａｔｉonHandlｅｒ當作是業(yè)務邏輯和橫切邏輯的編織器。下面，我們對這段代碼做進一步的說明。一方面，我們實現(xiàn)InｖｏcaｔiｏnHaｎdler接口，該接口定義了一個invoke（Ｏbjｅｃtpｒoｘy,Mｅthｏdｍethｏd,Objecｔ