地址:http://imaiyi.com
試用地址:http://imaiyi.com/tryhtmleditor.htm
來幾個截圖:






2006年12月21日 #
1.Duplicated Code
代碼重復幾乎是最常見的異味了。他也是Refactoring 的主要目標之一。代碼重復往
往來自于copy-and-paste 的編程風格。與他相對應OAOO 是一個好系統的重要標志
(請參見我的duplicated code 一文:http://www.erptao.org/download.php?op=viewsdownload&sid=6)。
2.Long method
它是傳統結構化的“遺毒“。一個方法應當具有自我獨立的意圖,不要把幾個意圖
放在一起,我的《大類和長方法》一文中有詳細描述。
3.Large Class
大類就是你把太多的責任交給了一個類。這里的規則是One Class One Responsibility。
4.Divergent Change
一個類里面的內容變化率不同。某些狀態一個小時變一次,某些則幾個月一年才變
一次;某些狀態因為這方面的原因發生變化,而另一些則因為其他方面的原因變一次。
面向對象的抽象就是把相對不變的和相對變化相隔離。把問題變化的一方面和另一
方面相隔離。這使得這些相對不變的可以重用。問題變化的每個方面都可以單獨重用。
這種相異變化的共存使得重用非常困難。
5.Shotgun Surgery
這正好和上面相反。對系統一個地方的改變涉及到其他許多地方的相關改變。這些
變化率和變化內容相似的狀態和行為通常應當放在同一個類中。
6.Feature Envy
對象的目的就是封裝狀態以及與這些狀態緊密相關的行為。如果一個類的方法頻繁
用get 方法存取其他類的狀態進行計算,那么你要考慮把行為移到涉及狀態數目最多的
那個類。
7.Data Clumps
某些數據通常像孩子一樣成群玩耍:一起出現在很多類的成員變量中,一起出現在
許多方法的參數中…..,這些數據或許應該自己獨立形成對象。
8.Primitive Obsession
面向對象的新手通常習慣使用幾個原始類型的數據來表示一個概念。譬如對于范圍,
他們會使用兩個數字。對于Money,他們會用一個浮點數來表示。因為你沒有使用對象
來表達問題中存在的概念,這使得代碼變的難以理解,解決問題的難度大大增加。
好的習慣是擴充語言所能提供原始類型,用小對象來表示范圍、金額、轉化率、郵
政編碼等等。
9.Switch Statement
基于常量的開關語句是OO 的大敵,你應當把他變為子類、state 或strategy。
10. Parallel Inheritance Hierarchies
并行的繼承層次是shotgun surgery 的特殊情況。因為當你改變一個層次中的某一個
類時,你必須同時改變另外一個層次的并行子類。
11. Lazy Class
一個干活不多的類。類的維護需要額外的開銷,如果一個類承擔了太少的責任,應
當消除它。
12. Speculative Generality
一個類實現了從未用到的功能和通用性。通常這樣的類或方法唯一的用戶是test
case。不要猶豫,刪除它。
13. Temporary Field
一個對象的屬性可能只在某些情況下才有意義。這樣的代碼將難以理解。專門建立
一個對象來持有這樣的孤兒屬性,把只和他相關的行為移到該類。最常見的是一個特定
的算法需要某些只有該算法才有用的變量。
14. Message Chain
消息鏈發生于當一個客戶向一個對象要求另一個對象,然后客戶又向這另一對象要
求另一個對象,再向這另一個對象要求另一個對象,如此如此。這時,你需要隱藏分派。
15. Middle Man
對象的基本特性之一就是封裝,而你經常會通過分派去實現封裝。但是這一步不能走得太遠,如果你發現一個類接口的一大半方法都在做分派,你可能需要移去這個中間
人。
16. Inappropriate Intimacy
某些類相互之間太親密,它們花費了太多的時間去磚研別人的私有部分。對人類而
言,我們也許不應該太假正經,但我們應當讓自己的類嚴格遵守禁欲主義。
17. Alternative Classes with Different Interfaces
做相同事情的方法有不同的函數signature,一致把它們往類層次上移,直至協議一
致。
18. Incomplete Library Class
要建立一個好的類庫非常困難。我們大量的程序工作都基于類庫實現。然而,如此
廣泛而又相異的目標對庫構建者提出了苛刻的要求。庫構建者也不是萬能的。有時候我
們會發現庫類無法實現我們需要的功能。而直接對庫類的修改有非常困難。這時候就需
要用各種手段進行Refactoring。
19. Data Class
對象包括狀態和行為。如果一個類只有狀態沒有行為,那么肯定有什么地方出問題
了。
20. Refused Bequest
超類傳下來很多行為和狀態,而子類只是用了其中的很小一部分。這通常意味著你
的類層次有問題。
21. Comments
經常覺得要寫很多注釋表示你的代碼難以理解。如果這種感覺太多,表示你需要
Refactoring。
1.什么是xp編程(極限編程):
XP是勇氣,交流,反饋和簡單。
XP是軟件開發過程中的紀律,它規定你:必須在編程前些測試,必須兩個人一起編程,必須遵守編程規范……。
XP是把最好的實踐經驗提取出來,形成了一個嶄新的開發方法。
2. XP適用范圍:
極限編程,也被叫做XP,適用于中小型團隊在需求不明確或者迅速變化的情況下進行軟件開發的輕量級方法學。
推薦使用范圍為10人左右的團隊
3.XP工作模式體現:
一、工作環境
二、立式晨會
三、結對編程
四、測試驅動開發
五、重構
六、持續集成
七、頻繁地發布小版本
4.結對編程:
開發任務會細化分解為很多Task,一個Task的開發周期一般不超過2天。
每個Task的Owner會尋找一個Partner進行結對開發。
Task開發的次序由程序員們自己協商。他可以先作為Partner和其他Owner一起開發某個Task,然后再找另一個程序員作為Partner來共同開發自己承擔的Task。
結對開發時,Task的Owner主要負責編碼, Partner負責在一旁看Owner編程并在其編寫有錯誤提出自己的意見,當其遇到困難時一起討論、互相幫助完成任務
5.測試驅動開發:
在動手編碼之前,必須先寫功能測試腳本、單元測試腳本。
寫好測試腳本后,開始編碼、重構、運行單元測試、集成、運行功能測試,以此循環
6.重構:
減少重復設計,優化設計結構,提高技術上的重用性和可擴展性。
XP提倡毫不留情的重構。
任何人可以重構任何代碼,前提是重構后的代碼一定要通過100%測試單元測試后才能被Check-in
7.持續集成:
測試先行是持續集成的一個重要前提。
持續集成指不斷地把完成的功能模塊整合在一起。目的在于不斷獲得客戶反饋以及盡早發現BUG。
隨時整合,越頻繁越好;集成及測試過程的自動化程度越高越好。
每次只有一個新增加部分在整合,而且必須運行功能測試
8.頻繁地發布小版本:
發布過程應該盡可能地自動化、規范化。
不斷地發布可用的系統可以告訴客戶你在做正確的事情。
客戶使用發布的系統,可以保證頻繁地反饋和交流。
保證客戶有足夠的依據調控開發過程(增加、刪除或改變需求)。
降低開發風險。
隨著開發的推進,發布越來越頻繁。
所有的發布都要經過功能測試。
9.XP的關鍵詞:
測試優先原則
結對編程
持續集成
頻繁小版本
不斷重構
立式晨會
交流和溝通,“只有沒有溝通不夠的項目,沒有溝通過度的項目”
分解任務、制定計劃是關鍵一環
10.XP作用:
一、平穩的工作效率
平穩的工作效率指團隊和個人在很長的時期內保持一定的開發效率。
保證了項目速度和計劃過程的有效性和準確性;
保證了程序員可以持續地完成任務,團隊可以持續地向客戶交付可運行的系統;
結對編程已經加大了工作強度,并且和其它XP的規則一起提高了工作效率,使少加班和維持平穩的工作效率可能而且可行。
提倡平穩的工作效率,體現了XP以人為本的價值觀。
二、高質量
測試優先、并堅持單元測試、每個版本進行功能測試的原則是保證了高質量的一個關鍵;
充分的溝通交流進一步減少了寫低質量代碼的風險;
結對開發模式在互相學習中會產出高質量的代碼
三、Open
結對開發、每一處修改都需要測試等等規則使得實現集體擁有代碼, “我們”的代碼,而不是“我”的代碼;
充分的溝通交流可以將每個人的知識、思想共享;
讓每個人都知道項目的設計、計劃、進展情況等信息;
大家都知道每個人都在做什么和怎么做;
四、對人的挑戰
暴露自己的缺點,人的本性
懶惰
自尊
封閉
……
克服自己的缺點
高效率
不怕告訴別人自己不會,樂于問人
懂得尊重別人,樂于幫助別人
……
11.受益于XP:
一個曾經在XP模式下工作過的人,回到傳統開發模式下才深刻體會到XP給他帶來的財富。
在傳統開發模式下他堅持每天有計劃、總結,堅持測試驅動開發……
發現他總是按時下班甚至提前下班,可是同事們越來越多且越來越晚下班,是自己不認真?是同事們愛表現?……
都不是!!
是XP給他帶來的受益終身的開發方式,他的同事bug量遠遠比他多,他只有不多的幾個;同事們任務總是延時,而自己都是輕松按時完成……
給你一個標準的定義:
在RUP中,迭代被定義為:迭代包括產生產品發布(穩定、可執行的產品版本)的全部開發活動和要使用該發布必需的所有其他外圍元素。 這個定義太學究氣,半天看不明白。這樣解釋可能更容易理解: 我們開發一個產品,如果不太復雜,會采用瀑布模型,簡單的說就是先需求定義,然后構建框架,然后寫代碼,然后測試,最后發布一個產品。 這樣,幾個月過去了,直到最后一天發布時,大家才能見到一個產品。 這樣的方式有明顯的缺點,假如我們對用戶的需求判斷的不是很準確時——這是很常見的問題,一點也不少見——你工作了幾個月甚至是幾年,當你把產品拿給客戶看時,客戶往往會大吃一驚,這就是我要的東西嗎? 迭代的方式就有所不同,假如這個產品要求6個月交貨,我在第一個月就會拿出一個產品來,當然,這個產品會很不完善,會有很多功能還沒有添加進去,bug很多,還不穩定,但客戶看了以后,會提出更詳細的修改意見,這樣,你就知道自己距離客戶的需求有多遠,我回家以后,再花一個月,在上個月所作的需求分析、框架設計、代碼、測試等等的基礎上,進一步改進,又拿出一個更完善的產品來,給客戶看,讓他們提意見。 就這樣,我的產品在功能上、質量上都能夠逐漸逼近客戶的要求,不會出現我花了大量心血后,直到最后發布之時才發現根本不是客戶要的東西。 這樣的方法很不錯,但他也有自己的缺陷,那就是周期長、成本很高。在應付大項目、高風險項目——就比如是航天飛機的控制系統時,迭代的成本比項目失敗的風險成本低得多,用這種方式明顯有優勢。 如果你是給自己的單位開發一個小MIS,自己也比較清楚需求,工期上也不過花上個把月的時間,用迭代就有點殺雞用了牛刀,那還是瀑布模型更管用,即使是做得不對,頂多再花一個月重來,沒什么了不起 賣藝網 |
說到為什么我喜歡在實驗室推廣XP,我們先來看看幾個軟件過程
首先是RUP,RUP有什么特點呢?迭代性開發,用例驅動,使用UML對軟件建模,提倡事先設計好以組件為核心的體系結構(以體系結構為中心),不斷的評估和測試軟件質量,(使用用例)控制軟件的變化。在這些原則的基礎上,把軟件人員分成各種角色(分析,開發,管理,測試,工具支持,配置)等等,在軟件開發過程中的各種產品叫做工件(Artifact)。
再看TSP,TSP把人員分成小組領導者、開發經理、計劃經理、質量/生產經理,以及技術支持經理(注意這點和RUP的雷同),要求各個人員嚴格記錄在軟件開發過程中的每一步,比如程序的Bug率,使用的時間等等。
最后一個是XP,XP的特點,雙人編程,簡單用例(User Story),Refactoring,以周為基礎的迭代。持續集成,現場客戶,測試驅動,自動化測試,代碼同步。同樣的,XP也把人員分成測試,交流人員,設計師,技術作者,客戶,程序員等等。
OK,說了這么多長篇大論,是為了把幾個軟件過程拿出來比較。所有的軟件過程無非是為了避免風險,保證項目的成功。
拿交通工具做比方的話,TSP就好比坐火車,由于TSP是CMM那幫子人搞的,所以TSP不強調迭代性開發。TSP強調的是質量管理和控制,通過每個人自覺自愿的記錄每天的行為,從而的得到嚴格的項目的數據,缺乏了這種嚴格控制,TSP就好比火車沒有軌道,一點用處也沒有。而在我們實驗室一幫懶懶散散的學生中搞數據,要他們每天填表,從而知道項目消耗了多少人時,Bug率為多少,不要做夢了吧,所以TSP那套方式肯定是行不通的。
再看XP和RUP的差別,迭代性開發,兩者都強調,不過兩者的含義不同,在RUP中,每次迭代,強調產生的是一個個工件,比如完成了用例。而在XP中,產生的是可用的軟件。為什么RUP的迭代里面可能沒有產生可用的軟件呢?因為RUP強調的是用例驅動和體系結構為中心,所以RUP花在設計體系結構和用例上的時間會比較多,這樣帶來的好處是軟件的后期變更會比較少。而XP本身強調的是擁抱變化,不管三七二十一,先開發出來一個能用的再說,如果客戶不滿意(別忘了,XP是現場客戶),Refactoring之。所以在XP的開頭的時候,根本就不提倡太復雜的用例(客戶在現場嘛,不懂客戶的意思,現場交流?。膊惶岢^多的設計(測試驅動嘛,通不過的話Refactoring之)。
然而RUP沒有現場客戶的概念,所以清晰的用例描述是RUP中很重要的一環。只有這些用例在客戶和團隊之間達成了共識,才能做下一步的工作,同樣的,需求的變更也必須通過用例來體現,RUP很強調變更管理,就是這個意思。
而在我們實驗室做現在這個項目,不是和客戶交流的問題,而是沒有客戶!??!
所以,在這種程度下,我們的用例,不是要讓客戶理解,而是我們自己理解就足夠了。而體系結構,由于你們現在不用考慮分布式,并發,事務等等一系列東西。這些東西都由J2EE做了。
此外RUP在我們實驗室很難辦的一件事情是對各個階段產生的工件的質量監控,同學們互相哈哈哈,很難對一個文檔性的東西進行評價。
那么要改善我們現在做的項目,最重要的是做什么呢?第一是,小迭代,我們現在整個軟件開發周期太長了,應該縮短到2-6周以內。第二,測試,我們現在的測試很多都是手動的,需要自動化這個測試過程。第三是,快速構建,持續集成。整個軟件的部署周期不能像現在這么長,不能由同學們手工構建,而必須是自動化的部署。這些都是在XP中強調的。
RUP的不同就好比是做BUS和自己開小汽車的不同,盡管細微,但是,開小汽車更需要小心翼翼的調整方向,而公交車畢竟有線路。
如果在一個大公司做部門經理的話,我更愿意采用RUP那套方式,輔之于XP的各種實踐,然而在實驗室,我只有退而求其次,因地制宜,XP能推廣多少是多少,一些很難推廣的東西比如風險管理,BUG管理只能暫時放棄了。
首先要理解線程首先需要了解一些基本的東西,我們現在所使用的大多數操作系統都屬于多任務,分時操作系統。正是由于這種操作系統的出現才有了多線程這個概念。我們使用的windows,linux就屬于此列。什么是分時操作系統呢,通俗一點與就是可以同一時間執行多個程序的操作系統,在自己的電腦上面,你是不是一邊聽歌,一邊聊天還一邊看網頁呢?但實際上,并不上cpu在同時執行這些程序,cpu只是將時間切割為時間片,然后將時間片分配給這些程序,獲得時間片的程序開始執行,不等執行完畢,下個程序又獲得時間片開始執行,這樣多個程序輪流執行一段時間,由于現在cpu的高速計算能力,給人的感覺就像是多個程序在同時執行一樣。
一般可以在同一時間內執行多個程序的操作系統都有進程的概念.一個進程就是一個執行中的程序,而每一個進程都有自己獨立的一塊內存空間,一組系統資源.在進程概念中,每一個進程的內部數據和狀態都是完全獨立的.因此可以想像創建并執行一個進程的系統開像是比較大的,所以線程出現了。在java中,程序通過流控制來執行程序流,程序中單個順序的流控制稱為線程,多線程則指的是在單個程序中可以同時運行多個不同的線程,執行不同的任務.多線程意味著一個程序的多行語句可以看上去幾乎在同一時間內同時運行.(你可以將前面一句話的程序換成進程,進程是程序的一次執行過程,是系統運行程序的基本單位)
線程與進程相似,是一段完成某個特定功能的代碼,是程序中單個順序的流控制;但與進程不同的是,同類的多個線程是共享一塊內存空間和一組系統資源,而線程本身的數據通常只有微處理器的寄存器數據,以及一個供程序執行時使用的堆棧.所以系統在產生一個線程,或者在各個線程之間切換時,負擔要比進程小的多,正因如此,線程也被稱為輕負荷進程(light-weight process).一個進程中可以包含多個線程.
多任務是指在一個系統中可以同時運行多個程序,即有多個獨立運行的任務,每個任務對應一個進程,同進程一樣,一個線程也有從創建,運行到消亡的過程,稱為線程的生命周期.用線程的狀態(state)表明線程處在生命周期的哪個階段.線程有創建,可運行,運行中,阻塞,死亡五中狀態.通過線程的控制與調度可使線程在這幾種狀態間轉化每個程序至少自動擁有一個線程,稱為主線程.當程序加載到內存時,啟動主線程.
[線程的運行機制以及調度模型]
java中多線程就是一個類或一個程序執行或管理多個線程執行任務的能力,每個線程可以獨立于其他線程而獨立運行,當然也可以和其他線程協同運行,一個類控制著它的所有線程,可以決定哪個線程得到優先級,哪個線程可以訪問其他類的資源,哪個線程開始執行,哪個保持休眠狀態。
下面是線程的機制圖:
線程的狀態表示線程正在進行的活動以及在此時間段內所能完成的任務.線程有創建,可運行,運行中,阻塞,死亡五中狀態.一個具有生命的線程,總是處于這五種狀態之一:
1.創建狀態
使用new運算符創建一個線程后,該線程僅僅是一個空對象,系統沒有分配資源,稱該線程處于創建狀態(new thread)
2.可運行狀態
使用start()方法啟動一個線程后,系統為該線程分配了除CPU外的所需資源,使該線程處于可運行狀態(Runnable)
3.運行中狀態
Java運行系統通過調度選中一個Runnable的線程,使其占有CPU并轉為運行中狀態(Running).此時,系統真正執行線程的run()方法.
4.阻塞狀態
一個正在運行的線程因某種原因不能繼續運行時,進入阻塞狀態(Blocked)
5.死亡狀態
線程結束后是死亡狀態(Dead)
同一時刻如果有多個線程處于可運行狀態,則他們需要排隊等待CPU資源.此時每個線程自動獲得一個線程的優先級(priority),優先級的高低反映線程的重要或緊急程度.可運行狀態的線程按優先級排隊,線程調度依據優先級基礎上的"先到先服務"原則.
線程調度管理器負責線程排隊和CPU在線程間的分配,并由線程調度算法進行調度.當線程調度管理器選種某個線程時,該線程獲得CPU資源而進入運行狀態.
線程調度是先占式調度,即如果在當前線程執行過程中一個更高優先級的線程進入可運行狀態,則這個線程立即被調度執行.先占式調度分為:獨占式和分時方式.
獨占方式下,當前執行線程將一直執行下去,直 到執行完畢或由于某種原因主動放棄CPU,或CPU被一個更高優先級的線程搶占
分時方式下,當前運行線程獲得一個時間片,時間到時,即使沒有執行完也要讓出CPU,進入可運行狀態,等待下一個時間片的調度.系統選中其他可運行狀態的線程執行
分時方式的系統使每個線程工作若干步,實現多線程同時運行
另外請注意下面的線程調度規則(如果有不理解,不急,往下看):
①如果兩個或是兩個以上的線程都修改一個對象,那么把執行修改的方法定義為被同步的(Synchronized),如果對象更新影響到只讀方法,那么只度方法也應該定義為同步的
②如果一個線程必須等待一個對象狀態發生變化,那么它應該在對象內部等待,而不是在外部等待,它可以調用一個被同步的方法,并讓這個方法調用wait()
③每當一個方法改變某個對象的狀態的時候,它應該調用notifyAll()方法,這給等待隊列的線程提供機會來看一看執行環境是否已發生改變
④記住wait(),notify(),notifyAll()方法屬于Object類,而不是Thread類,仔細檢查看是否每次執行wait()方法都有相應的notify()或notifyAll()方法,且它們作用與相同的對象 在java中每個類都有一個主線程,要執行一個程序,那么這個類當中一定要有main方法,這個man方法也就是java class中的主線程。你可以自己創建線程,有兩種方法,一是繼承Thread類,或是實現Runnable接口。一般情況下,最好避免繼承,因為java中是單根繼承,如果你選用繼承,那么你的類就失去了彈性,當然也不能全然否定繼承Thread,該方法編寫簡單,可以直接操作線程,適用于單重繼承情況。至于選用那一種,具體情況具體分析。
eg.繼承Thread
public class MyThread_1 extends Thread
{
public void run()
{
//some code
}
}
eg.實現Runnable接口
public class MyThread_2 implements Runnable
{
public void run()
{
//some code
}
}
當使用繼承創建線程,這樣啟動線程:
new MyThread_1().start()
當使用實現接口創建線程,這樣啟動線程:
new Thread(new MyThread_2()).start()
注意,其實是創建一個線程實例,并以實現了Runnable接口的類為參數傳入這個實例,當執行這個線程的時候,MyThread_2中run里面的代碼將被執行。
下面是完成的例子:
public class MyThread implements Runnable
{
public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
new Thread(new MyThread()).start();
}
}
執行后將打印出:
My Name is Thread-0
你也可以創建多個線程,像下面這樣
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
那么會打印出:
My Name is Thread-0
My Name is Thread-1
My Name is Thread-2
看了上面的結果,你可能會認為線程的執行順序是依次執行的,但是那只是一般情況,千萬不要用以為是線程的執行機制;影響線程執行順序的因素有幾點:首先看看前面提到的優先級別
public class MyThread implements Runnable
{
public void run()
{
System.out.println("My Name is "+Thread.currentThread().getName());
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//賦予最高優先級
t1.start();
t2.start();
t3.start();
}
}
再看看結果:
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2
線程的優先級分為10級,分別用1到10的整數代表,默認情況是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等價與t2.setPriority(10)
然后是線程程序本身的設計,比如使用sleep,yield,join,wait等方法(詳情請看JDKDocument)
public class MyThread implements Runnable
{
public void run()
{
try
{
int sleepTime=(int)(Math.random()*100);//產生隨機數字,
Thread.currentThread().sleep(sleepTime);//讓其休眠一定時間,時間又上面sleepTime決定
//public static void sleep(long millis)throw InterruptedException (API)
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由于線程在休眠可能被中斷,所以調用sleep方法的時候需要捕捉異常
{
ie.printStackTrace();
}
}
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}
執行后觀察其輸出:
Thread-0 睡了 11
Thread-2 睡了 48
Thread-1 睡了 69
上面的執行結果是隨機的,再執行很可能出現不同的結果。由于上面我在run中添加了休眠語句,當線程休眠的時候就會讓出cpu,cpu將會選擇執行處于runnable狀態中的其他線程,當然也可能出現這種情況,休眠的Thread立即進入了runnable狀態,cpu再次執行它。
[線程組概念]
線程是可以被組織的,java中存在線程組的概念,每個線程都是一個線程組的成員,線程組把多個線程集成為一個對象,通過線程組可以同時對其中的多個線程進行操作,如啟動一個線程組的所有線程等.Java的線程組由java.lang包中的Thread——Group類實現.
ThreadGroup類用來管理一組線程,包括:線程的數目,線程間的關系,線程正在執行的操作,以及線程將要啟動或終止時間等.線程組還可以包含線程組.在Java的應用程序中,最高層的線程組是名位main的線程組,在main中還可以加入線程或線程組,在mian的子線程組中也可以加入線程和線程組,形成線程組和線程之間的樹狀繼承關系。像上面創建的線程都是屬于main這個線程組的。
借用上面的例子,main里面可以這樣寫:
public static void main(String[] args)
{
/***************************************
ThreadGroup(String name)
ThreadGroup(ThreadGroup parent, String name)
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}
線程組的嵌套,t1,t2,t3被加入group2,group2加入group1。
另外一個比較多就是關于線程同步方面的,試想這樣一種情況,你有一筆存款在銀行,你在一家銀行為你的賬戶存款,而你的妻子在另一家銀行從這個賬戶提款,現在你有1000塊在你的賬戶里面。你存入了1000,但是由于另一方也在對這筆存款進行操作,人家開始執行的時候只看到賬戶里面原來的1000元,當你的妻子提款1000元后,你妻子所在的銀行就認為你的賬戶里面沒有錢了,而你所在的銀行卻認為你還有2000元。
看看下面的例子:
class BlankSaving //儲蓄賬戶
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向銀行存入了 [¥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向銀行取走了 [¥"+i+"]");
if(money<0)
System.out.println("余額不足!");
}
public int showMoney()
{
return money;
}
}
class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;
}
public static void oper(String name,BlankSaving bs)
{
if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
}
}
public class BankTest
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}
}
下面是其中一次的執行結果:
---------first--------------
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Husband 向銀行存入了 [¥1000]
看到了嗎,這可不是正確的需求,在husband還沒有結束操作的時候,wife就插了進來,這樣很可能導致意外的結果。解決辦法很簡單,就是將對數據進行操作方法聲明為synchronized,當方法被該關鍵字聲明后,也就意味著,如果這個數據被加鎖,只有一個對象得到這個數據的鎖的時候該對象才能對這個數據進行操作。也就是當你存款的時候,這筆賬戶在其他地方是不能進行操作的,只有你存款完畢,銀行管理人員將賬戶解鎖,其他人才能對這個賬戶進行操作。
修改public static void oper(String name,BlankSaving bs)為public static void oper(String name,BlankSaving bs),再看看結果:
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Husband 向銀行存入了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
Wife 向銀行取走了 [¥1000]
當丈夫完成操作后,妻子才開始執行操作,這樣的話,對共享對象的操作就不會有問題了。
[wait and notify]
你可以利用這兩個方法很好的控制線程的執行流程,當線程調用wait方法后,線程將被掛起,直到被另一線程喚醒(notify)或則是如果wait方法指定有時間得話,在沒有被喚醒的情況下,指定時間時間過后也將自動被喚醒。但是要注意一定,被喚醒并不是指馬上執行,而是從組塞狀態變為可運行狀態,其是否運行還要看cpu的調度。
事例代碼:
class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}
執行結果如下:
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified
可能你注意到了在使用wait and notify方法得時候我使用了synchronized塊來包裝這兩個方法,這是由于調用這兩個方法的時候線程必須獲得鎖,也就是上面代碼中的lock[],如果你不用synchronized包裝這兩個方法的得話,又或則鎖不一是同一把,比如在MyThread_2中synchronized(lock)改為synchronized(this),那么執行這個程序的時候將會拋出java.lang.IllegalMonitorStateException執行期異常。另外wait and notify方法是Object中的,并不在Thread這個類中。最后你可能注意到了這點:int[] in=new int[0];為什么不是創建new Object而是一個0長度的數組,那是因為在java中創建一個0長度的數組來充當鎖更加高效。
Thread作為java中一重要組成部分,當然還有很多地方需要更深刻的認識,上面只是對Thread的一些常識和易錯問題做了一個簡要的總結,若要真正的掌握java的線程,還需要自己多做總結
synchronized 關鍵字,它包括兩種用法:synchronized 方法和 synchronized 塊。
1. synchronized 方法:通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如:
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變量的訪問:每個類實例對應一把鎖,每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行,否則所屬線程阻塞,方法一旦執行,就獨占該鎖,直到從該方法返回時才將鎖釋放,此后被阻塞的線程方能獲得該鎖,重新進入可執行狀態。這種機制確保了同一時刻對于每一個類實例,其所有聲明為 synchronized 的成員函數中至多只有一個處于可執行狀態(因為至多只有一個能夠獲得該類實例對應的鎖),從而有效避免了類成員變量的訪問沖突(只要所有可能訪問類成員變量的方法均被聲明為 synchronized)。
在 Java 中,不光是類實例,每一個類也對應一把鎖,這樣我們也可將類的靜態成員函數聲明為 synchronized ,以控制其對類的靜態成員變量的訪問。
synchronized 方法的缺陷:若將一個大的方法聲明為synchronized 將會大大影響效率,典型地,若將線程類的方法 run() 聲明為 synchronized ,由于在線程的整個生命期內它一直在運行,因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變量的代碼放到專門的方法中,將其聲明為 synchronized ,并在主方法中調用來解決這一問題,但是 Java 為我們提供了更好的解決辦法,那就是 synchronized 塊。
2. synchronized 塊:通過 synchronized關鍵字來聲明synchronized 塊。語法如下:
synchronized(syncObject)
synchronized 塊是這樣一個代碼塊,其中的代碼必須獲得對象 syncObject (如前所述,可以是類實例或類)的鎖方能執行,具體機制同前所述。由于可以針對任意代碼塊,且可任意指定上鎖的對象,故靈活性較高。
notify()及notifyAll()是Object的方法,與Object的wait()方法配合使用,而且這三個方法必須在同步塊中調用.
如下:
在線程1中執行如下代碼
...
synchronized(obj1) //1.進入同步塊
{
try {
...
obj1.wait(); //2.進入暫停狀態
}catch (InterruptedException exp) {}
}
1.當前同步對象(monitor)為obj1,obj1是任一實例,若是同步方法,則同步對象是this.進入同步塊后,obj1為鎖定狀態,鎖定狀態對obj1本身無任何影響,而其它線程執行到同一代碼時,因不能獲得鎖,處于Block狀態,一旦解鎖,被block的線程自動繼續執行.
2.調用obj1.wait()有兩個作用,一是使線程進入等待狀態,二是解鎖obj1,這時被block的線程將獲得鎖.線程1要退出等待必須要由其它線程顯式的調用obj1.notify()或notifyAll()方法.
如
...
synchronized(obj1)
{
...
obj1.notify(); //3. 向wait的線程發通知信息
...
}
...
若其它線程執行到此時,線程1處于wait狀態,則wait狀態解除,解除后,若線程1若得到鎖就能繼續執行,若有多個線程處于obj1的wait狀態,notify將隨機選一個線程激活,而notifyAll是同時解除所有的wait狀態.
notifyAll()讓等待某個對象K的所有線程離開阻塞狀態,
notify()隨機地選取等待某個對象K的線程,讓它離開阻塞狀態。
notify(),notifyAll()非常有用,在一個synchronized(lockObj)塊中當調用lockObj.wait()時,線程就已經將鎖放開來了,這時當另外一個線程調用lockObj.notify()時,等待的線程就會繼續執行下去了。這是一種非常高效的線程同步機制。如果沒有他,用sleep()來同步的話就太浪費時間了。
一個簡單的例子:
thread1 receive data
thread2 pase received data
lockObj是buf
當buf中沒有數據時,thread2中調用buf.wait釋放鎖,讓thread1有機會執行。
當thread1收到數據時,調用buf.notify()通知thread1去處理收到的數據。
如果在同步塊入口點阻塞,不須其它線程調用notify(),調了也沒效果,同步塊能自動獲得鎖
如果是wait造成了阻塞,須用notfiy()激活,這兩個方法是配合使用
notify、notifyAll、wait :
主要是為了解決持有監視器鑰匙的線程暫停等待另一線程完成時可能發生死鎖的問題。wait()方法使調用線程等待,直到發生超時或另一線程調用同一對象的notify()或notifyAll()方法。wait() 方法的用法如下:wait()或wait(long timeoutPeriodInMilliseconds)前者等待被通知,后者等待超時或通知。線程調用wait()方法時,釋放所持有的鑰匙讓另一等待線程進入監視區。notify()方法只喚醒一個等待線程,而notifyAll()喚醒所有等待該監視器的線程。注意,這些方法只能在監視區內調用。否則會輸出一種RuntimeException類型的IllegaMonitorStateException異常狀態。
夠詳細清楚的吧。
總之wait()讓線程等待,notify()和notifyall()激活某個等待線程,其實就是撤銷該線程的中斷狀態,從而使他們有機會再次運行
有時會遇到如下問題,程序的一部分在寫數據,另一部分讀數據,但有時會出現讀部分超前寫部分,
這就是典型的產生者/消耗者問題.
.wait:是一個線程睡眠,直到在相同的對象上調用notify或notifyAll
.notify:啟動第一個在相同對象調用wait的線程
.notifyAll:啟動在相同的對象調用wait的所有線程
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
Collection是最基本的集合接口,一個Collection代表一組Object,即Collection的元素(Elements)。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類,Java SDK提供的類都是繼承自Collection的“子接口”如List和Set。
所有實現Collection接口的類都必須提供兩個標準的構造函數:無參數的構造函數用于創建一個空的Collection,有一個Collection參數的構造函數用于創建一個新的Collection,這個新的Collection與傳入的Collection有相同的元素。后一個構造函數允許用戶復制一個Collection。
如何遍歷Collection中的每一個元素?不論Collection的實際類型如何,它都支持一個iterator()的方法,該方法返回一個迭代子,使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下:
Iterator it = collection.iterator(); // 獲得一個迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一個元素
}
由Collection接口派生的兩個接口是List和Set。
List接口
List是有序的Collection,使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引(元素在List中的位置,類似于數組下標)來訪問List中的元素,這類似于Java的數組。
和下面要提到的Set不同,List允許有相同的元素。
除了具有Collection接口必備的iterator()方法外,List還提供一個listIterator()方法,返回一個ListIterator接口,和標準的Iterator接口相比,ListIterator多了一些add()之類的方法,允許添加,刪除,設定元素,還能向前或向后遍歷。
實現List接口的常用類有LinkedList,ArrayList,Vector和Stack。
LinkedList類
LinkedList實現了List接口,允許null元素。此外LinkedList提供額外的get,remove,insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧(stack),隊列(queue)或雙向隊列(deque)。
注意LinkedList沒有同步方法。如果多個線程同時訪問一個List,則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List:
List list = Collections.synchronizedList(new LinkedList(...));
ArrayList類
ArrayList實現了可變大小的數組。它允許所有元素,包括null。ArrayList沒有同步。
size,isEmpty,get,set方法運行時間為常數。但是add方法開銷為分攤的常數,添加n個元素需要O(n)的時間。其他的方法運行時間為線性。
每個ArrayList實例都有一個容量(Capacity),即用于存儲元素的數組的大小。這個容量可隨著不斷添加新元素而自動增加,但是增長算法并沒有定義。當需要插入大量元素時,在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。
和LinkedList一樣,ArrayList也是非同步的(unsynchronized)。
Vector類
Vector非常類似ArrayList,但是Vector是同步的。由Vector創建的Iterator,雖然和ArrayList創建的Iterator是同一接口,但是,因為Vector是同步的,當一個Iterator被創建而且正在被使用,另一個線程改變了Vector的狀態(例如,添加或刪除了一些元素),這時調用Iterator的方法時將拋出ConcurrentModificationException,因此必須捕獲該異常。
Stack 類
Stack繼承自Vector,實現一個后進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用?;镜膒ush和pop方法,還有peek方法得到棧頂的元素,empty方法測試堆棧是否為空,search方法檢測一個元素在堆棧中的位置。Stack剛創建后是空棧。
Set接口
Set是一種不包含重復的元素的Collection,即任意的兩個元素e1和e2都有e1.equals(e2)=false,Set最多有一個null元素。
很明顯,Set的構造函數有一個約束條件,傳入的Collection參數不能包含重復的元素。
請注意:必須小心操作可變對象(Mutable Object)。如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true將導致一些問題。
Map接口
請注意,Map沒有繼承Collection接口,Map提供key到value的映射。一個Map中不能包含相同的key,每個key只能映射一個value。Map接口提供3種集合的視圖,Map的內容可以被當作一組key集合,一組value集合,或者一組key-value映射。
Hashtable類
Hashtable繼承Map接口,實現一個key-value映射的哈希表。任何非空(non-null)的對象都可作為key或者value。
添加數據使用put(key, value),取出數據使用get(key),這兩個基本操作的時間開銷為常數。
Hashtable通過initial capacity和load factor兩個參數調整性能。通常缺省的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大,這會影響像get和put這樣的操作。
使用Hashtable的簡單示例如下,將1,2,3放到Hashtable中,他們的key分別是”one”,”two”,”three”:
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一個數,比如2,用相應的key:
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作為key的對象將通過計算其散列函數來確定與之對應的value的位置,因此任何作為key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object,如果你用自定義的類當作key的話,要相當小心,按照散列函數的定義,如果兩個對象相同,即obj1.equals(obj2)=true,則它們的hashCode必須相同,但如果兩個對象不同,則它們的hashCode不一定不同,如果兩個不同對象的hashCode相同,這種現象稱為沖突,沖突會導致操作哈希表的時間開銷增大,所以盡量定義好的hashCode()方法,能加快哈希表的操作。
如果相同的對象有不同的hashCode,對哈希表的操作會出現意想不到的結果(期待的get方法返回null),要避免這種問題,只需要牢記一條:要同時復寫equals方法和hashCode方法,而不要只寫其中一個。
Hashtable是同步的。
HashMap類
HashMap和Hashtable類似,不同之處在于HashMap是非同步的,并且允許null,即null value和null key。,但是將HashMap視為Collection時(values()方法可返回Collection),其迭代子操作時間開銷和HashMap的容量成比例。因此,如果迭代操作的性能相當重要的話,不要將HashMap的初始化容量設得過高,或者load factor過低。
WeakHashMap類
WeakHashMap是一種改進的HashMap,它對key實行“弱引用”,如果一個key不再被外部所引用,那么該key可以被GC回收。
總結
如果涉及到堆棧,隊列等操作,應該考慮用List,對于需要快速插入,刪除元素,應該使用LinkedList,如果需要快速隨機訪問元素,應該使用ArrayList。
如果程序在單線程環境中,或者訪問僅僅在一個線程中進行,考慮非同步的類,其效率較高,如果多個線程可能同時操作一個類,應該使用同步的類。
要特別注意對哈希表的操作,作為key的對象要正確復寫equals和hashCode方法。
盡量返回接口而非實際的類型,如返回List而非ArrayList,這樣如果以后需要將ArrayList換成LinkedList時,客戶端代碼不用改變。這就是針對抽象編程。
下面介紹一下Jakarta下的Commons:一個csdn網友描述得很貼切,Commons就好比一個java百寶箱。
commons分為3部分Commons Proper、Commons Sandbox和Commons Dormant
Commons Proper:提供了設計良好可重用的java組件,并都經過了廣泛、嚴格的測試。
Commons Sandbox:處于實驗、測試階段的組件。
Commons Dormant:處于停滯狀態,從Sandbox退出的,不活躍的組件,謹慎使用。
Commons Proper組件:
Commons Sandbox組件:
1.?概述?
本文主要包括以下幾個方面:編碼基本知識,java,系統軟件,url,工具軟件等。?
??? 在下面的描述中,將以"中文"兩個字為例,經查表可以知道其GB2312編碼是"d6d0?cec4",Unicode編碼為"4e2d?6587",UTF編碼就是"e4b8ad?e69687"。注意,這兩個字沒有iso8859-1編碼,但可以用iso8859-1編碼來"表示"。?
2.?編碼基本知識?
??? 最早的編碼是iso8859-1,和ascii編碼相似。但為了方便表示各種各樣的語言,逐漸出現了很多標準編碼,重要的有如下幾個。?
2.1.?iso8859-1?
??? 屬于單字節編碼,最多能表示的字符范圍是0-255,應用于英文系列。比如,字母'a'的編碼為0x61=97。?
??? 很明顯,iso8859-1編碼表示的字符范圍很窄,無法表示中文字符。但是,由于是單字節編碼,和計算機最基礎的表示單位一致,所以很多時候,仍舊使用iso8859-1編碼來表示。而且在很多協議上,默認使用該編碼。比如,雖然"中文"兩個字不存在iso8859-1編碼,以gb2312編碼為例,應該是"d6d0?cec4"兩個字符,使用iso8859-1編碼的時候則將它拆開為4個字節來表示:"d6?d0?ce?c4"(事實上,在進行存儲的時候,也是以字節為單位處理的)。而如果是UTF編碼,則是6個字節"e4?b8?ad?e6?96?87"。很明顯,這種表示方法還需要以另一種編碼為基礎。?
2.2.?GB2312/GBK?
??? 這就是漢子的國標碼,專門用來表示漢字,是雙字節編碼,而英文字母和iso8859-1一致(兼容iso8859-1編碼)。其中gbk編碼能夠用來同時表示繁體字和簡體字,而gb2312只能表示簡體字,gbk是兼容gb2312編碼的。?
2.3.?unicode?
??? 這是最統一的編碼,可以用來表示所有語言的字符,而且是定長雙字節(也有四字節的)編碼,包括英文字母在內。所以可以說它是不兼容iso8859-1編碼的,也不兼容任何編碼。不過,相對于iso8859-1編碼來說,uniocode編碼只是在前面增加了一個0字節,比如字母'a'為"00?61"。?
需要說明的是,定長編碼便于計算機處理(注意GB2312/GBK不是定長編碼),而unicode又可以用來表示所有字符,所以在很多軟件內部是使用unicode編碼來處理的,比如java。?
2.4.?UTF?
??? 考慮到unicode編碼不兼容iso8859-1編碼,而且容易占用更多的空間:因為對于英文字母,unicode也需要兩個字節來表示。所以unicode不便于傳輸和存儲。因此而產生了utf編碼,utf編碼兼容iso8859-1編碼,同時也可以用來表示所有語言的字符,不過,utf編碼是不定長編碼,每一個字符的長度從1-6個字節不等。另外,utf編碼自帶簡單的校驗功能。一般來講,英文字母都是用一個字節表示,而漢字使用三個字節。?
??? 注意,雖然說utf是為了使用更少的空間而使用的,但那只是相對于unicode編碼來說,如果已經知道是漢字,則使用GB2312/GBK無疑是最節省的。不過另一方面,值得說明的是,雖然utf編碼對漢字使用3個字節,但即使對于漢字網頁,utf編碼也會比unicode編碼節省,因為網頁中包含了很多的英文字符。?
3.?java對字符的處理?
??? 在java應用軟件中,會有多處涉及到字符集編碼,有些地方需要進行正確的設置,有些地方需要進行一定程度的處理。?
3.1.?getBytes(charset)?
?? 這是java字符串處理的一個標準函數,其作用是將字符串所表示的字符按照charset編碼,并以字節方式表示。注意字符串在java內存中總是按unicode編碼存儲的。比如"中文",正常情況下(即沒有錯誤的時候)存儲為"4e2d?6587",如果charset為"gbk",則被編碼為"d6d0?cec4",然后返回字節"d6?d0?ce?c4"。如果charset為"utf8"則最后是"e4?b8?ad?e6?96?87"。如果是"iso8859-1",則由于無法編碼,最后返回?"3f?3f"(兩個問號)。?
3.2.?new?String(charset)?
??? 這是java字符串處理的另一個標準函數,和上一個函數的作用相反,將字節數組按照charset編碼進行組合識別,最后轉換為unicode存儲。參考上述getBytes的例子,"gbk"?和"utf8"都可以得出正確的結果"4e2d?6587",但iso8859-1最后變成了"003f?003f"(兩個問號)。?
??? 因為utf8可以用來表示/編碼所有字符,所以new?String(?str.getBytes(?"utf8"?),?"utf8"?)?===?str,即完全可逆。?
3.3.?setCharacterEncoding()?
??? 該函數用來設置http請求或者相應的編碼。?
???? 對于request,是指提交內容的編碼,指定后可以通過getParameter()則直接獲得正確的字符串,如果不指定,則默認使用iso8859-1編碼,需要進一步處理。參見下述"表單輸入"。值得注意的是在執行setCharacterEncoding()之前,不能執行任何getParameter()。java?doc上說明:This?method?must?be?called?prior?to?reading?request?parameters?or?reading?input?using?getReader()。而且,該指定只對POST方法有效,對GET方法無效。分析原因,應該是在執行第一個getParameter()的時候,java將會按照編碼分析所有的提交內容,而后續的getParameter()不再進行分析,所以setCharacterEncoding()無效。而對于GET方法提交表單是,提交的內容在URL中,一開始就已經按照編碼分析所有的提交內容,setCharacterEncoding()自然就無效。?
??? 對于response,則是指定輸出內容的編碼,同時,該設置會傳遞給瀏覽器,告訴瀏覽器輸出內容所采用的編碼。?
3.4.?處理過程?
下面分析兩個有代表性的例子,說明java對編碼有關問題的處理方法。?
3.4.1.?表單輸入?
??? User?input??*(gbk:d6d0?cec4)??browser??*(gbk:d6d0?cec4)??web?server??iso8859-1(00d6?00d?000ce?00c4)??class,需要在class中進行處理:getbytes("iso8859-1")為d6?d0?ce?c4,new?String("gbk")為d6d0?cec4,內存中以unicode編碼則為4e2d?6587。?
l?用戶輸入的編碼方式和頁面指定的編碼有關,也和用戶的操作系統有關,所以是不確定的,上例以gbk為例。?
??? 從browser到web?server,可以在表單中指定提交內容時使用的字符集,否則會使用頁面指定的編碼。而如果在url中直接用?的方式輸入參數,則其編碼往往是操作系統本身的編碼,因為這時和頁面無關。上述仍舊以gbk編碼為例。?
??? Web?server接收到的是字節流,默認時(getParameter)會以iso8859-1編碼處理之,結果是不正確的,所以需要進行處理。但如果預先設置了編碼(通過request.?setCharacterEncoding?()),則能夠直接獲取到正確的結果。?
??? 在頁面中指定編碼是個好習慣,否則可能失去控制,無法指定正確的編碼。
在Java編程中,中文字體編碼難倒了不少程序員,如果抓住了影響Java中文顯示的幾個關鍵因素,問題將迎刃而解。
Java是目前最流行的面向對象的編程語言之一,Java支持UTF-8、ISO-8
影響Java中字體編碼正確顯示的有幾個因素: 1)數據庫的連接方式; 2)網頁中使用的字體編碼; 3)數據庫里存放數據的字體編碼; 4)Java的缺省字體編碼。如果在編程中遇到不能正確顯示中文時,要先弄清楚以上幾項所使用的字體編碼,再分析找出原因,即可解決問題。
眾所周知,JSP是Java的一種,和網頁有關,而網頁也有自己的中文編碼系統,所以JSP處理中文要比純Java的類文件更為麻煩。本文的測試數據庫是MySQL3.2,數據庫連接驅動是用org.gjt.mm.mysql.Driver,這里主要討論UTF-8和GBK的顯示( GB2312是GBK的一個子集,Java中可以使用GBK來代替GB系列)。我們先來研究JSP中字體編碼問題, 下面第一到第六點是針對JSP的(因為從數據庫里讀出中文數據與寫入中文數據有所區別,咱們分別說明,前三點是從讀取數據庫到顯示在網頁,后三點是從網頁輸入數據到存入數據庫),第七到第九點針對純Java的類文件。 以下rs表示ResultSet的一個實例,是執行Select語句之后產生的數據集。
一、數據庫連接方式使用UTF-8
在連接數據庫的驅動后面加上這句參數useUnicode=true&characterEncoding=
UTF-8,例如jdbc:mysql://localhost/DBVF?autoReconnect=true&useUnicode=
true&characterEncoding=UTF-8,從數據庫里讀出中文顯示在使用GBK的JSP的網頁里,如果數據庫里存放的字體編碼是UTF-8,在JSP中使用 str=new String(rs.getBytes(1),"UTF-8")或者str=rs.getString(1),可以正確顯示中文。如果數據庫里存放的是GBK數據,那么JSP中也要使用str=new String(rs.getBytes(1),"GBK")來顯示正確的中文。值得注意的是如果頁面使用UTF-8,數據庫里存放的是UTF-8,也可以用str=new String(rs.getBytes(1),"GBK")正確顯示中文。如果網頁是UTF-8,而數據庫里存放的是GBK,無法直接顯示中文,需要2步轉換, str=new String(rs.getBytes(1),"GBK"); 再str=new String(str.getBytes("UTF-8"),"GBK"),才可以正確顯示中文。
二、數據庫連接方式使用GBK
在連接數據庫的驅動后面加上這句參數useUnicode=true&characterEncoding=
GBK,例如jdbc:mysql://localhost/DBVF?autoReconnect=true&UseUnicode=true&
characterEncoding=GBK,從數據庫里讀出中文,顯示在使用GBK的JSP的網頁里,如果數據庫里存放的字體編碼是UTF-8,在JSP中一定要使用 str=new String(rs.getBytes(1),"UTF-8"),才正確顯示中文。如果數據庫里存放的是GBK數據,那么JSP中也要使用str=new String(rs.getBytes(1),"GBK") 或者直接使用str=rs.getString(1),即可顯示正確的中文。 如果網頁是UTF-8,而數據庫里存放的是GBK,只能用str=new String(rs.getString(1).getBytes("UTF-8"),"GBK")的方法來顯示中文; 如果網頁是UTF-8,而數據庫里存放的是UTF-8,可用str=new String(rs.getBytes(1),"GBK") 或者rs.getString(1)方法來顯示中文。
三、使用缺省數據庫連接方式
連接數據庫的驅動后面沒有這句參數useUnicode=&characterEncoding=,例如jdbc:mysql://localhost/DBVF?autoReconnect=true,沒有參數useUnicode=true&characterEncoding,表示使用默認的ISO-8895-1編碼。
1. 從數據庫里讀出中文,顯示在GBK的網頁里。如果數據庫里存放的字體編碼是UTF-8,在JSP網頁中一定要使用語句 str=new String(rs.getBytes(1),"UTF-8") 或者str= new String(rs.getString(1).getBytes("ISO-8859-1"),"UTF-8"),才可正確顯示中文。如果數據庫里存放的是GBK數據,那么JSP中也要使用str=new String(rs.getBytes(1),"GBK")或str=new String(rs.getString(1).getBytes("ISO-8859-1"),"GBK") 顯示正確的中文。
2. 如果網頁是UTF-8,不能直接正確顯示GBK,需要2步轉換,str=new String(rs.getBytes(1),"GBK"),再str=new String(str.getBytes("UTF-8"),"GBK") 才可以正確顯示中文。如果數據庫里存的是UTF-8,直接用str=new String(rs.getBytes(1),"GBK")或者str=new String(rs.getString(1).getBytes("ISO-8859-1"),"GBK")就可以顯示中文了。
以上是讀取數據庫里中文正確顯示在網頁上,下面三點是如何正確存入數據庫。
四、數據庫連接方式使用UTF-8編碼
JSP中要把網頁輸入的中文存入數據庫,通常有一個提交(Submit)的過程,是用str=request.getParameter("username"),然后執行update或者insert語句來存入數據庫。如何賦值給str很重要,而且這里中文輸入與網頁所使用的字體編碼有關。
1、 網頁使用UTF-8,使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"UTF-8")或者str= new String(request.getParameter("username").getBytes(),"UTF-8"),都可以使得存到數據庫里的數據是UTF-8編碼。
2. 網頁使用GBK,使用str= new String(request.getParameter("username").getBytes(),"GBK"),那么存入數據庫的是UTF-8編碼。
3. 值得注意的是使用UTF-8的數據庫連接方式不能存得GBK。
五、數據庫連接方式使用GBK編碼
1. 輸入使用GBK網頁,存到數據庫里是GBK的方法: str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"GBK") 或者str= new String(request.getParameter("username").getBytes(),"GBK")。
2. 網頁使用GBK,想存入UTF-8到數據庫里,要分2步: 先str=new String(request.getParameter("username").getBytes(),"GBK"),再str=new String(str.getBytes("UTF-8"),"GBK")即可。
3. 網頁使用UTF-8,而且使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"GBK") 或者str= new String(request.getParameter("username").getBytes(),"UTF-8"),那么存到數據庫里的數據是UTF-8編碼。
4. 網頁使用UTF-8,而且使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"UTF-8"),那么存到數據庫里的數據是GBK編碼。
六、數據庫連接方式使用缺省,即不使用參數useUnicode和characterEncoding
1. 網頁使用GBK,如果使用str= request.getParameter("username")或者str= new String(request.getParameter("username").getBytes()),那么在數據庫里的數據是GBK碼。網頁使用UTF-8 和使用str= request.getParameter("username"),則存入數據庫是UTF-8編碼。
2. 如果使用str= new String(request.getParameter("username").getBytes("ISO-8859-1")),那么根據網頁提供的字體編碼而存到數據庫里,比如是UTF-8的網頁,那么存到數據庫中就是UTF-8編碼,如果使用GBK網頁,那么存到數據庫里的字就是GBK編碼。
3. 如果使用str= new String(request.getParameter("username").getBytes("UTF-8"),"UTF-8")這一種組合能存到正確的數據外,其他存到數據庫里的數據則都是亂碼或者錯誤碼。在這個UTF-8組合的特例中,網頁使用的是GBK,則存放到數據庫里就是GBK,網頁使用UTF-8,那么存到數據庫里的就是UTF-8。
4. 網頁是GBK的要存得UTF-8,一定需要2步: company=new String(request.getParameter("company").getBytes(),"GBK")和company=new String(company.getBytes("UTF-8"))。
5. 網頁是UTF-8的,不能存得GBK在數據庫里,一句話,改變數據庫連接方式不能存得GBK碼。
以上所有的都是基于JSP網頁和數據庫交換數據,下面討論一下純JAVA編程下的字體編碼轉換。
七、數據庫連接方式使用UTF-8編碼
1. 數據庫里的中文是UTF-8,可以轉換為GBK,但不能把GBK存入數據庫。
2. 數據庫是GBK,如果轉換為UTF-8,使用content=new String(rs.getBytes(2),"GBK")直接將content存入數據庫就可為UTF-8。
八、數據庫連接方式使用GBK編碼
1. 數據庫里的中文是UTF-8,如果轉換為GBK,使用content= new String(rs.getString(2).getBytes(),"UTF-8"),再直接使用update或者insert語句插入到數據庫,即存得GBK。如果使用content= new String(rs.getString(2).getBytes(),"GBK")或者content= new String(rs.getString(2).getBytes()),再存入數據庫即存得還是UTF-8編碼。
2. 數據庫里的中文是GBK,如果轉換為UTF-8,使用content= new String(rs.getString(2).getBytes("UTF-8"))或者content= new String(rs.getString(2).getBytes("UTF-8"),"GBK"),再直接使用update或者insert語句插入到數據庫,即存得UTF-8。
3. 如果某個String是GBK,要轉換為UTF-8,也是使用content= new String(GBKstr.getBytes("UTF-8"))或者content= new String(GBKstr.getBytes("UTF-8"),"GBK"); 如果某個String是UTF-8,要轉換為GBK,應該使用new String(UTFstr.getBytes("GBK"),"UTF-8")。
九、數據庫連接方式使用缺省,即不跟參數
1. str2=new String(GBKstr.getBytes("UTF-8"),"ISO-8859-1"),可以將數據庫里的GBK編碼轉換為UTF-8。
2. 讀取UTF-8然后存入UTF-8,則用str1=new String(UTFstr.getBytes(),"ISO-8859-1")或者str1=new String(UTFstr.getBytes("GBK"),"ISO-8859-1")。
3. 不能實現數據庫里的UTF-8轉換為GBK。
如果采用UTF-8的數據庫連接方式或者缺省數據連接方式,那么無法將UTF-8轉為GBK;而GBK的數據庫連接方式可以實現UTF-8和GBK的相互轉換。建議大家采用GBK的數據連接方式。