2023年摩根面試準(zhǔn)備要點(diǎn)Java

摩根面試準(zhǔn)備要點(diǎn)ＪＶM架構(gòu)(Ｖｉncent)?

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

Ｃlａsｓloａdeｒ子系統(tǒng)的作用:根據(jù)給定的全限定名類名(如jａva.lang.Objeｃｔ）來裝載class文獻(xiàn)的內(nèi)容到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實(shí)現(xiàn)(JDK)的核心是Exｅｃｕtioneｎｇinｅ，換句話說:Sun的JＤK和IBM的JDK好壞重要取決于他們各自實(shí)現(xiàn)的Execution

ｅngine的好壞。每個(gè)運(yùn)營中的線程都有一個(gè)Eｘecutionengiｎe的實(shí)例。

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

?

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

Ｈeap

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

Ｊavasｔack?

Javａｓｔack以幀為單位保存線程的運(yùn)營狀態(tài)。虛擬機(jī)只會直接對Jaｖasｔａcｋ執(zhí)行兩種操作:以幀為單位的壓?；虺鰲?。每當(dāng)線程調(diào)用一個(gè)方法的時(shí)候,就對當(dāng)前狀態(tài)作為一個(gè)幀保存到j(luò)avastaｃk中（壓棧);當(dāng)一個(gè)方法調(diào)用返回時(shí)，從javastack彈出一個(gè)幀(出棧)。棧的大小是有一定的限制，這個(gè)也許出現(xiàn)StaｃkOverFｌow問題。下面的程序可以說明這個(gè)問題。ｐｕｂ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?每個(gè)運(yùn)營中的Java程序,每一個(gè)線程都有它自己的ＰC寄存器，也是該線程啟動時(shí)創(chuàng)建的。PＣ寄存器的內(nèi)容總是指向下一條將被執(zhí)行指令的地址;，這里的地址可以是一個(gè)本地指針,也可以是在方法區(qū)中相相應(yīng)于該方法起始指令的偏移量。

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

CＬassLoadｅｒ(Vincｅnt）Javａ的可執(zhí)行文獻(xiàn)不同于C/C＋＋，Javａ編譯器只產(chǎn)生中間字節(jié)碼文獻(xiàn)（．class文獻(xiàn))，由Ｊava虛擬機(jī)（jaｖａ.exe）解釋執(zhí)行。Jaｖa發(fā)布的程序（ＪAR包)也多半是一堆class文獻(xiàn),運(yùn)營時(shí)由ClaｓｓLｏaｄer加載到Jaｖａ虛擬機(jī)中執(zhí)行。CｌａｓsLoadｅr是Java虛擬機(jī)的重要組成部分,由Java語言編寫,用戶可以實(shí)現(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在運(yùn)營時(shí)會產(chǎn)生三個(gè)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ā)生變化呢，其實(shí)就是類的狀態(tài),也就是不變類的實(shí)例一旦被創(chuàng)建,其狀態(tài)就不會發(fā)生變化，舉個(gè)例子：假如人是一個(gè)class,那么我們中的每一個(gè)都是人這個(gè)類的具體的iｎstａnce,假如人這個(gè)類只有一個(gè)狀態(tài)就是生身父母,那么它就是一個(gè)不變類，由于每一個(gè)人在出生的那一剎那，生身父母就已經(jīng)被設(shè)立了值,并且終生都不會發(fā)生變化。不變類有什么好處呢?１)不變類是線程安全的,由于不變類的狀態(tài)在創(chuàng)建以后不再發(fā)生變化,所以它可以在線程之間共享，而不需要同步。2)不變類的ｉｎsｔance可以被rｅuse創(chuàng)建類的實(shí)例需要花費(fèi)CPU的時(shí)間,當(dāng)這個(gè)實(shí)例不再被引用時(shí)，將會被垃圾回收掉,這時(shí)候，又需要花費(fèi)CPU的時(shí)間。對于不變類而言，一個(gè)好處就是可以將常用的實(shí)例進(jìn)行緩存，從而減少了對象的創(chuàng)建。舉個(gè)例子，對于布爾型,最常用的便是trueａndfalse。JDK中的Ｂooleａn類就是一個(gè)不變類，并且對這兩個(gè)實(shí)例進(jì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ｅ)；//這個(gè)方法不會創(chuàng)建新的對象，而是重用已經(jīng)創(chuàng)建好的inｓtａｎceｐublicstaｔicBoｏｌeａnｖａluｅOf（ｂｏoleanb){rｅｔurn(b?TRＵE：ＦALSE);}}3）不變類的某些方法可以緩存計(jì)算的結(jié)果haｓhＣode這個(gè)方法來自于Obｊecｔ這個(gè)類，這個(gè)方法用來返回對象的ｈaｓｈCodｅ,重要用于將對象放置到hashtabｌe中時(shí),來擬定這個(gè)對象的存儲位置。對于一個(gè)不變類的實(shí)例,它的hashCode也是不變的,所以就可以緩存這個(gè)計(jì)算的結(jié)果，來提高性能，避免不必要的運(yùn)算,JDK中的Ｓtriｎｇ類就是一個(gè)例子。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都是不變類。假如一個(gè)類是不變類，這個(gè)類是不是就不能有改變狀態(tài)的方法呢?答案當(dāng)然是否認(rèn)的,Sｔrｉnｇ是一個(gè)不變類，仍然有ｒeｐlaｃe，ｒeｐlaceAll這樣的方法，而Ｓtｒing仍然是一個(gè)不變類，那是由于在這些改變狀態(tài)的方法中,每次都是新創(chuàng)建一個(gè)Ｓtｒiｎg對象。假如大家理解了不變類，那也就不難理解為什么在做Strｉnｇ的concａt(yī)enate時(shí),應(yīng)當(dāng)用SｔrinｇBuffeｒ而不是用＋的操作符。如何對的使用Ｓtrinｇ呢?1)不要用ｎew去創(chuàng)建Stｒiｎg對象。假如使用ｎew去創(chuàng)建Ｓtring,那么每次都會創(chuàng)建一個(gè)新對象。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)應(yīng)當(dāng)用StriｎgＢｕffer來做連接操作由于Ｓtriｎg是一個(gè)不變類，那么在做連接操作時(shí)，就會創(chuàng)建臨時(shí)對象來保存中間的運(yùn)算結(jié)果,而SｔｒｉngBｕｆfｅr是一個(gè)mutａblecｌａｓｓ,這樣就不需要創(chuàng)建臨時(shí)的對象來保存結(jié)果，從而提高了性能。JＡVAGarbageColｌｅction（Vｉnｃent)垃圾分代回收算法(GeneraｔionalColleｃting）

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

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

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

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

年老代存放從年輕代存活的對象。一般來說年老代存放的都是生命期較長的對象。?3.Ｐerm(持久代）JVMspｅcifiｃatｉoｎ中的Methodarea?用于存放靜態(tài)文獻(xiàn)，如今Java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應(yīng)用也許動態(tài)生成或者調(diào)用一些class,例如Hiｂernate等,在這種時(shí)候需要設(shè)立一個(gè)比較大的持久代空間來存放這些運(yùn)營過程中新增的類。持久代大小通過-XX:MaxPermSizｅ=進(jìn)行設(shè)立。?采用分區(qū)管理機(jī)制的JＶM將ＪVＭ所管理的所有內(nèi)存資源分為2個(gè)大的部分。永久存儲區(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的駐留內(nèi)存,用于存放JDＫ自身所攜帶的Ｃlaｓs,Inteｒfａce的元數(shù)據(jù)，應(yīng)用服務(wù)器允許必須的Clａsｓ，Ｉnｔｅrface的元數(shù)據(jù)和Jａva程序運(yùn)營時(shí)需要的Clａss和Ｉnterface的元數(shù)據(jù)。被裝載進(jìn)此區(qū)域的數(shù)據(jù)是不會被垃圾回收器回收掉的,關(guān)閉JＶM時(shí),釋放此區(qū)域所控制的內(nèi)存。?

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

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

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

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

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

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

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

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

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

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

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

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

reｆereｎce,Ｓoft

rｅference，Ｗeａｋ

refｅｒeｎｃe,Ｐhantom

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

Referｅｎce

強(qiáng)引用是JAVA中默認(rèn)采用的一種方式，我們平時(shí)創(chuàng)建的引用都屬于強(qiáng)引用。假如一個(gè)對象沒有強(qiá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的時(shí)候不會被回收,只有當(dāng)內(nèi)存不夠用的時(shí)候才會真正的回收,因此軟引用適合緩存的場合,這樣使得緩存中的對象可以盡量的再內(nèi)存中待長期一點(diǎn)。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ｅ弱引用有助于對象更快的被回收，假如一個(gè)對象沒有強(qiáng)引用只有弱引用,那么在GC后,這個(gè)對象肯定會被回收。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(標(biāo)記-清除收集器）標(biāo)記清除收集器最早由Lisp的發(fā)明人于1960年提出,標(biāo)記清除收集器停止所有的工作,從根掃描每個(gè)活躍的對象，然后標(biāo)記掃描過的對象，標(biāo)記完畢以后，清除那些沒有被標(biāo)記的對象。優(yōu)點(diǎn):1

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

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

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

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

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

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

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

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

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

Gｃ

或者M(jìn)ajor

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

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

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

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

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

{

//反射得到操作者的實(shí)例

Ｃ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ｂｌｅ

Ｊ＂);

}

}

??

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

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

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

組成Ｓpring框架的每個(gè)模塊(或組件)都可以單獨(dú)存在,或者與其他一個(gè)或多個(gè)模塊聯(lián)合實(shí)現(xiàn)。每個(gè)模塊的功能如下:核心容器：核心容器提供Spｒｉnｇ框架的基本功能。核心容器的重要組件是BeanFactｏry，它是工廠模式的實(shí)現(xiàn)。BｅanFａctorｙ使用控制反轉(zhuǎn)(IOC)模式將應(yīng)用程序的配置和依賴性規(guī)范與實(shí)際的應(yīng)用程序代碼分開。Ｓprinｇ上下文:Spｒｉng上下文是一個(gè)配置文獻(xiàn),向Sprｉｎg框架提供上下文信息。Spring上下文涉及公司服務(wù),例如JNDＩ、EJB、電子郵件、國際化、校驗(yàn)和調(diào)度功能。SｐriｎgＡＯP：通過配置管理特性，ＳpｒingAOP模塊直接將面向方面的編程功能集成到了Sprｉng框架中。所以，可以很容易地使Sｐring框架管理的任何對象支持AＯP。SprinｇＡＯＰ模塊為基于Spｒing的應(yīng)用程序中的對象提供了事務(wù)管理服務(wù)。通過使用SprinｇAOP，不用依賴EＪB組件,就可以將聲明性事務(wù)管理集成到應(yīng)用程序中。SprinｇDAO:JＤＢＣDAＯ抽象層提供了故意義的異常層次結(jié)構(gòu),可用該結(jié)構(gòu)來管理異常解決和不同數(shù)據(jù)庫供應(yīng)商拋出的錯誤消息。異常層次結(jié)構(gòu)簡化了錯誤解決，并且極大地減少了需要編寫的異常代碼數(shù)量(例如打開和關(guān)閉連接）。SpｒｉngDＡO的面向JDBＣ的異常遵從通用的DAO異常層次結(jié)構(gòu)。SprｉngOＲM：Ｓpring框架插入了若干個(gè)ＯＲM框架，從而提供了ＯRＭ的對象關(guān)系工具,其中涉及JDO、Ｈｉbｅrｎａt(yī)e和ｉBatｉsSQLMap。所有這些都遵從Spriｎｇ的通用事務(wù)和DAO異常層次結(jié)構(gòu)。ＳｐrｉngWｅb模塊:Ｗeｂ上下文模塊建立在應(yīng)用程序上下文模塊之上,為基于Weｂ的應(yīng)用程序提供了上下文。所以，Spring框架支持與ＪakaｒtaStruｔｓ的集成。Web模塊還簡化了解決多部分請求以及將請求參數(shù)綁定到域?qū)ο蟮墓ぷ?。SpringMVC框架:MVC框架是一個(gè)全功能的構(gòu)建Ｗeb應(yīng)用程序的MVC實(shí)現(xiàn)。通過策略接口，MＶC框架變成為高度可配置的,MVＣ容納了大量視圖技術(shù)，其中涉及JSＰ、Velocｉty、Tiｌes、iText和POＩ。Spring框架的功能可以用在任何J２ＥＥ服務(wù)器中，大多數(shù)功能也合用于不受管理的環(huán)境。Ｓｐｒinｇ的核心要點(diǎn)是:支持不綁定到特定Ｊ2EE服務(wù)的可重用業(yè)務(wù)和數(shù)據(jù)訪問對象。毫無疑問，這樣的對象可以在不同Ｊ2EE環(huán)境（Wｅb或EＪB)、獨(dú)立應(yīng)用程序、測試環(huán)境之間重用。SpringAOＰ兩種實(shí)現(xiàn)機(jī)制(ＢaｏminｇChai）SPＲＩNG是通過動態(tài)代理來實(shí)現(xiàn)ＡＯＰ的,SＰＲING內(nèi)部提供了2種實(shí)現(xiàn)機(jī)制?1．假如是有接口聲明的類進(jìn)行AＯP,ｓpring調(diào)用的是ｊａva.lang.reflｅctioｎ.Prｏxｙ類來做解決org.sprinｇframeworｋ．a(chǎn)op.ｆ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ｏｎA(yù)dvicｅ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ｏｎA(yù)dｖice).invoｋｅ(ｔhis)； ?} }2.假如是沒有接口聲明的類呢?SPRING通過CGLＩB包和內(nèi)部類來實(shí)現(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方式?

先來一個(gè)接口

IHelloWorld.jaｖapacｋagekris.aｏp.tesｔ;pｕｂｌｉcｉnteｒｆａｃeＩHelloWoｒlｄ｛?publicvｏidpｒinｔ(Strinｇname)； pｕblicvoidwｒite（Stringsｔｈ);｝再來一個(gè)實(shí)現(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(chǎn)ｏｐ.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ｓ調(diào)用的方法 *obj 外部已經(jīng)已經(jīng)包裝好ＩｎｖｏｃationHaｎdｌer的實(shí)例?＊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Ｗo(hù)rｌｄｉ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進(jìn)行AＯP包裝 ?IHelloＷo(hù)rldihw=（ＩHｅlloＷo(hù)rld)Prｏxy.ｎewＰroｘｙInsｔａｎce(cｌ,classes,ih);? ihw.ｐrinｔ("ｔest"）;??ihw．ｗｒite("test"); ｝}2.用CGLIＢ包實(shí)現(xiàn)，一方面不要忘了引入那個(gè)包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Ｗo(hù)rｌ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(hù)ｒld"); ｝}代理類(沒用內(nèi)部類,看起來清楚點(diǎn))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ｓ); //設(shè)立回調(diào)方法實(shí)現(xiàn)類 ｅnｈancer.ｓetCallback(newＭeｔhodIntercepｔorImpl()）;??／/實(shí)例化已經(jīng)添加回調(diào)實(shí)現(xiàn)的ＨELLＯWORＬD實(shí)例 HellｏWｏrldmｙ=(ＨelｌｏWorld)enhａnceｒ．cｒeaｔe(); ｍy.pｒint();?}}SprｉｎgAOP的底層實(shí)現(xiàn)技術(shù)（BaｏmｉngＣhai，SｔephenYu)AOＰ概述軟件的編程語言最終的目的就是用更自然更靈活的方式模擬世界,從原始機(jī)器語言到過程語言再到面向?qū)ο蟮恼Z言,我們看到編程語言在一步步用更自然、更強(qiáng)大的方式描述軟件。AＯＰ是軟件開發(fā)思想的一個(gè)奔騰，AＯP的引入將有效填補(bǔ)ＯＯＰ的局限性,OOP和AOP分別從縱向和橫向?qū)浖M(jìn)行抽象，有效地消除反復(fù)性的代碼，使代碼以更優(yōu)雅的更有效的方式進(jìn)行邏輯表達(dá)。AOP有三種植入切面的方法:其一是編譯期織入,這規(guī)定使用特殊的Java編譯器,AspeｃtJ是其中的代表者;其二是類裝載期織入,而這規(guī)定使用特殊的類裝載器，ＡｓpecｔJ和AspecｔWeｒkｚ是其中的代表者；其三為動態(tài)代理織入，在運(yùn)營期為目的類添加增強(qiáng)生成子類的方式,SpringAOＰ采用動態(tài)代理織入切面。SｐringＡOP使用了兩種代理機(jī)制，一種是基于JDＫ的動態(tài)代理，另一種是基于CGLｉb的動態(tài)代理，之所以需要兩種代理機(jī)制,很大限度上是由于JDＫ自身只提供基于接口的代理，不支持類的代理?；贘DK的代理和基于CGLｉb的代理是SｐrｉｎgAＯP的核心實(shí)現(xiàn)技術(shù)，結(jié)識這兩代理技術(shù),有助于探究ＳｐringＡOＰ的實(shí)現(xiàn)機(jī)理。只要你樂意,你甚至可以拋開Ｓpring，提供自己的AOP實(shí)現(xiàn)。帶有橫切邏輯的實(shí)例

?一方面，我們來看一個(gè)無法通過OOP進(jìn)行抽象的反復(fù)代碼邏輯，它們就是AＯP改造的重要對象。下面,我們通過一個(gè)業(yè)務(wù)方法性能監(jiān)視的實(shí)例了解橫切邏輯。業(yè)務(wù)方法性能監(jiān)視,在每一個(gè)業(yè)務(wù)方法調(diào)用之前開始監(jiān)視,業(yè)務(wù)方法結(jié)束后結(jié)束監(jiān)視并給出性能報(bào)告:代碼清單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é)束監(jiān)視、并給出性能報(bào)告信息?

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é)束監(jiān)視、并給出性能報(bào)告信息

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

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

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

/／通過一個(gè)ThｒeａdＬｏｃaｌ保存線程相關(guān)的性能監(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è)務(wù)方法性能監(jiān)視的信息

}

｝PerformaｎｃeMｏniｔｏｒ提供了兩個(gè)方法,bｅgｉｎ（Strinｇｍeｔhod)方法開始對某個(gè)業(yè)務(wù)類方法的監(jiān)視,ｍethod為業(yè)務(wù)方法的署名，而eｎd(）方法結(jié)束對業(yè)務(wù)方法的監(jiān)視，并給出性能監(jiān)視的信息。由于每一個(gè)業(yè)務(wù)方法都必須單獨(dú)記錄性能監(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();／/記錄方法調(diào)用開始時(shí)的系統(tǒng)時(shí)間?

｝?

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

//以下兩行程序得到方法調(diào)用后的系統(tǒng)時(shí)間,并計(jì)算出方法執(zhí)行花費(fèi)時(shí)間

end=System．currentTimeMillis(）;?

ｌongelapse=end－bｅgin；

//報(bào)告業(yè)務(wù)方法執(zhí)行時(shí)間?

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

}?｝通過下面代碼測試這個(gè)擁有方法性能監(jiān)視能力的業(yè)務(wù)方法：ｐ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ｍ花費(fèi)47毫秒。begｉｎmｏnｉｔoｒ..．?模擬刪除Topｉc記錄:1012

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

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

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

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

?一方面,我們從業(yè)務(wù)類ForuｍSｅrviceImｐl中刪除性能監(jiān)視的橫切代碼,使ForuｍSeｒviｃeImpｌ只負(fù)責(zé)具體的業(yè)務(wù)邏輯,如所示：代碼清單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è)務(wù)邏輯。

?從業(yè)務(wù)類中移除的橫切代碼當(dāng)然還得找到一個(gè)寄居之所,Ｉ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è)務(wù)類?

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）;//②通過反射方法調(diào)用目的業(yè)務(wù)類的業(yè)務(wù)方法?

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

ｒeturnobj；?

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