2013年7月19日
#
摘要: 轉載：http://www.tkk7.com/qcyycom/archive/2013/07/11/401467.htmlSpring MVC 3 深入總結
一、前言：
大家好，Spring3 MVC是非常優秀的MVC框架，由其是在3.0版本發布后，現在有越來越多的團隊選擇了Spring3 MVC了。Spring3 MVC結構簡單，應了那句話簡單就是美，而且他強大不失靈活，性能...
閱讀全文
2012年12月5日
#
1.delete from 表名 where ID in (select id from 表名 group by id having count(id) >1)
and rowid not in (select min(rowid) from 表名 group by id having count(id )>1)
2012年9月25日
#
使用POI對excel表數據進行操作時出現了該問題，從數據庫導出數據到excel表中，datetime類型的數據以String類型存儲，當對表內的該列數據做修改后，excel將自動修改單元格的格式，從而導致在重新讀取時出現了以上錯誤。
解決辦法：
判斷讀取的單元格是否為HSSFCell.CELL_TYPE_NUMERIC類型，然后利用cell.getNumericCellValue()，讀取該單元格的數據。
getNumericCellValue()讀出的數據類型是double型，
因此，需要重新進行數據轉換：HSSFDateUtil.getJavaDate(d).toLocaleString()。其中d為讀出的double類型數據。
至此，則成功的將excel表內的數據讀取出來。
單元格的格式總共有以下幾種：
HSSFCell.CELL_TYPE_BLANK;
HSSFCell.CELL_TYPE_BOOLEAN;
HSSFCell.CELL_TYPE_ERROR;
HSSFCell.CELL_TYPE_FORMULA;
HSSFCell.CELL_TYPE_NUMERIC;
HSSFCell.CELL_TYPE_STRING;
2012年8月15日
#
轉載：
http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達式匹配結果包含在源文本中的【和】之間，有的例子會使用java來實現，如果是java本身正則表達式的用法，會在相應的地方說明。所有java例子都在JDK1.6.0_13下測試通過。
一、有多少個匹配
前面幾篇講的都是匹配一個字符，但是一個字符或字符集合要匹配多次，應該怎么做呢？比如要匹配一個電子郵件地址，用之前說到的方法，可能有人會寫出像\w@\w\.\w這樣的正則表達式，但這個只能匹配到像a@b.c這樣的地址，明顯是不正確的，接下來就來看看如何匹配電子郵件地址。
首先要知道電子郵件地址的組成：以字母數字或下劃線開頭的一組字符，后面跟@符號，再后面是域名，即用戶名@域名地址。不過這也跟具體的郵箱服務提供商有關，有的在用戶名中也允許.字符。
1、匹配一個或多個字符
要想匹配同一個字符（或字符集合）的多次重復，只要簡單地給這個字符（或字符集合）加上一個+字符作為后綴就可以了。+匹配一個或多個字符（至少一個）。如：a匹配a本身，a+將匹配一個或多個連續出現的a；[0-9]+匹配多個連續的數字。
注意：在給一個字符集合加上+后綴的時候，必須把+放在字符集合的外面，否則就不是重復匹配了。如[0-9+]這樣就表示數字或+號了，雖然語法上正確，但不是我們想要的了。
文本：Hello, mhmyqn@qq.com or mhmyqn@126.com is my email.
正則表達式：\w+@(\w+\.)+\w+
結果：Hello, 【mhmyqn@qq.com】 or 【mhmyqn@126.com】 is my email.
分析：\w+可以匹配一個或多個字符，而子表達式(\w+\.)+可匹配像xxxx.edu.這樣的字符串，而最后不會是.字符結尾，所以后面還會有一個\w+。像mhmyqn@xxxx.edu.cn這樣的郵件地址也會匹配到。
2、匹配零個或多個字符
匹配零個或多個字符使用元符*，它的用法和+完全一樣，只要把它放在一下字符或字符集合的后面，就可以匹配該字符（或字符集合）連續出現零次或多次。如正則表達式ab*c可以匹配ac、abc、abbbbbc等。
3、匹配零個或一個字符
匹配零個或一個字符使用元字符?。像上一篇說到的匹配一個空白行使用正則表達式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n這樣既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面來看一個匹配http或https協議的URL的例子：
文本：The URL is http://www.mikan.com, to connect securely use https://www.mikan.cominstead.
正則表達式：https?://(\w+\.)+\w+
結果：The URL is 【http://www.mikan.com】, to connect securely use 【https://www.mikan.com】 instead.
分析：這個模式以https?開頭，表示?之前的一個字符可以有，也可以沒有，所以它能匹配http或https，后面部分和前一個例子一樣。
二、匹配的重復次數
正則表達式里的+、*和?解決了很多問題，但是：
1）+和*匹配的字符個數沒有上限。我們無法為它們將匹配的字符個數設定一個最大值。
2）+、*和?至少匹配一個或零個字符。我們無法為它們將匹配的字符個數另行設定一個最小值。
3）如果只使用*和+，我們無法把它們將匹配的字符個數設定為一個精確的數字。
正則表達式里提供了一個用來設定重復次數的語法，重復次數要用{和}字符來給出，把數值寫在它們中間。
1、為重復匹配次數設定一個精確值
如果想為重復匹配次數設定一個精確的值，把那個數字寫在{和}之間即可。如{4}表示它前面的那個字符（或字符集合）必須在原始文本中連續重復出現4次才算是一個匹配，如果只出現了3次，也不算是一個匹配。
如前面幾篇中說到的匹配頁面中顏色的例子，就可以用重復次數來匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。
2、為重復匹配次數設定一個區間
{}語法還可以用來為重復匹配次數設定一個區間，也就是為重復匹配次數設定一個最小值和最大值。這種區間必須以{n, m}這樣的形式給出，其中n>=m>=0。如檢查日期格式是否正確（不檢查日期的有效性）的正則表達式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。
3、匹配至少重復多少次
{}語法的最后一種用法是給出一個最小的重復次數（但不必給出最大重復次數），如{3,}表示至少重復3次。注意：{3,}中一定要有逗號，而且逗號后不能有空格。否則會出錯。
來看一個例子，使用正則表達式把所有金額大于$100的金額找出來：
文本：
$25.36
$125.36
$205.0
$2500.44
$44.30
正則表達式：$\d{3,}\.\d{2}
結果：
$25.36
【$125.36】
【$205.0】
【$2500.44】
$44.30
+、*、?可以表示成重復次數：
+等價于{1,}
*等價于{0,}
?等價于{0,1}
三、防止過度匹配
?只能匹配零個或一個字符，{n}和{n,m}也有匹配重復次數的上限，但是像*、+、{n,}都沒有上限值，這樣有時會導致過度匹配的現象。
來看匹配一個html標簽的例子
文本：
Yesterday is <b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>.
正則表達式：<[Bb]>.*</[Bb]>
結果：
Yesterday is 【<b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>】.
分析：<[Bb]>匹配<b>標簽（不區分大小寫），</[Bb]>匹配</b>標簽（不區分大小寫）。但結果卻不是預期的那樣有三個，第一個</b>標簽之后，一直到最后一個</b>之間的東西全部匹配出來了。
為什么會這樣呢？因為*和+都是貪婪型的元字符，它們在匹配時的行為模式是多多益善，它們會盡可能從一段文本的開頭一直匹配到這段文本的末尾，而不是從這段文本的開頭匹配到碰到第一個匹配時為止。
當不需要這種貪婪行為時，可以使用這些元字符的懶惰型版本。懶惰意思是匹配盡可能少的字符，與貪婪型相反。懶惰型元字符只需要給貪婪型元字符加上一個?后綴即可。下面是貪婪型元字符的對應懶惰型版本：
* *?
+ +?
{n,} {n,}?
所以上面的例子中，正則表達式只需要改成<[Bb]>.*?</[Bb]>即可，結果如下：
<b>history</b>
<B>mystery</B>
<b>gift</b>
四、總結
正則表達式的真下威力體現在重復次數匹配方面。這里介紹了+、*、?幾種元字符的用法，如果要精確的確定匹配次數，使用{}。元字符分貪婪型和懶惰型兩種，在需要防止過度匹配的場合下，請使用懶惰型元字符來構造正則表達式
轉載：http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達式匹配結果包含在源文本中的【和】之間，有的例子會使用java來實現，如果是java本身正則表達式的用法，會在相應的地方說明。所有java例子都在JDK1.6.0_13下測試通過。
一、對特殊字符進行轉義
元字符是一些在正則表達式里有著特殊含義的字符。因為元字符在正則表達式里有著特殊的含義，所以這些字符就無法用來代表它們本身。在元字符前面加上一個反斜杠就可以對它進行轉義，這樣得到的轉義序列將匹配那個字符本身而不是它特殊的元字符含義。如，如果想要匹配[和]，就必須對它進行轉義：\[和\]。
對元字符轉義需要用到斜杠\字符，這就意味著\字符本向也是一個元字符，要匹配\字符本身，必須轉義成\\。如匹配windows文件路徑。
二、匹配空白字符
元字符大致可以分為兩種：一種是用來匹配文本的（如.），另一種是正則表達式的語法所要求的（如[和]）。
在進行正則表達式搜索的時候，我們經常會遇到需要對原始文本中里的非打印空白字符進行匹配的情況。比如說，我們可能需要把所有的制表符找出來，或者我們需要把換行符找出來，這類字符很難被直接輸入到一個正則表達式里，這時我們可以使用如下列出的特殊元字符來輸入它們：
\b 回退（并刪除）一個字符（Backspace鍵）
\f 換頁符
\n 換行符
\r 回車符
\t 制表符（Tab鍵）
\v 垂直制表符
來看一個例子，把文件中的空白行去掉：
文本：
8 5 4 1 6 3 2 7 9
7 6 2 9 5 8 3 4 1
9 3 1 4 2 7 8 5 6
6 9 3 8 7 5 1 2 4
5 1 8 3 4 2 6 9 7
2 4 7 6 1 9 5 3 8
3 26 7 8 4 9 1 5
4 8 9 5 3 1 7 6 2
1 7 5 2 9 6 4 8 3
正則表達式：\r\n\r\n
分析：\r\n匹配一個回車+換行組合，windows操作系統中把它作為文本行的結束標簽。使用正則表達式\r\n\r\n進行的搜索將匹配兩個連續的行尾標簽，而這正好是空白行。
注意：Unix和Linux操作系統中只使用一個換行符來結束一個文本行，換句話說，在Unix或Linux系統中匹配空白行只使用\n\n即可，不需要加上\r。同時適用于windows和Unix/Linux的正則表達式應該包括一個可先的\r和一個必須匹配的\n，即\r?\n\r?\n，這將會在后面的文章中講到。
Java代碼如下：
public static void matchBlankLine() throws Exception{
BufferedReader br = new BufferedReader(new FileReader(new File("E:/九宮格.txt")));
StringBuilder sb = new StringBuilder();
char[] cbuf = new char[1024];
int len = 0;
while(br.ready() && (len = br.read(cbuf)) > 0){
br.read(cbuf);
sb.append(cbuf, 0, len);
}
String reg = "\r\n\r\n";
System.out.println("原內容：\n" + sb.toString());
System.out.println("處理后：-----------------------------");
System.out.println(sb.toString().replaceAll(reg, "\r\n"));
}
運行結果如下：
原內容：
8 5 4 1 6 3 2 7 9
7 6 2 9 5 8 3 4 1
9 3 1 4 2 7 8 5 6
6 9 3 8 7 5 1 2 4
5 1 8 3 4 2 6 9 7
2 4 7 6 1 9 5 3 8
3 2 6 7 8 4 9 1 5
4 8 9 5 3 1 7 6 2
1 7 5 2 9 6 4 8 3
處理后：-----------------------------
8 5 4 1 6 3 2 7 9
7 6 2 9 5 8 3 4 1
9 3 1 4 2 7 8 5 6
6 9 3 8 7 5 1 2 4
5 1 8 3 4 2 6 9 7
2 4 7 6 1 9 5 3 8
3 2 6 7 8 4 9 1 5
4 8 9 5 3 1 7 6 2
1 7 5 2 9 6 4 8 3
三、匹配特定的字符類別
字符集合（匹配多個字符中的某一個）是最常見的匹配形式，而一些常用的字符集合可以用特殊元字符來代替。這些元字符匹配的是某一類別的字符（類元字符），類元字符并不是必不可少的，因為可以通過逐一列舉有關字符或通過定義一個字符區間來匹配某一類字符，但是使用它們構造出來的正則表達式簡明易懂，在實際應用中很常用。
1、匹配數字與非數字
\d 任何一個數字，等價于[0-9]或[0123456789]
\D 任何一個非數字，等價于[^0-9]或[^0123456789]
2、匹配字母和數字與非字母和數字
字母（A-Z不區分大小寫）、數字、下劃線是一種常用的字符集合，可用如下類元字符：
\w 任何一個字母（不區分大小寫）、數字、下劃線，等價于[0-9a-zA-Z_]
\W 任何一個非字母數字和下劃線，等價于[^0-9a-zA-Z_]
3、匹配空白字符與非空白字符
\s 任何一下空白字符，等價于[\f\n\r\t\v]
\S 任何一下空白字符，等價于[^\f\n\r\t\v]
注意：退格元字符\b沒有不在\s的范圍之內。
4、匹配十六進制或八進制數值
十六進制：用前綴\x來給出，如：\x0A對應于ASCII字符10（換行符），其效果等價于\n。
八進制：用前綴\0來給出，數值本身可以是兩位或三位數字，如：\011對應于ASCII字符9（制表符），其效果等價于\t。
四、使用POSIX字符類
POSIX字符類是很多正則表達式實現都支持的一種簡寫形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：
[:alnum:] 任何一個字母或數字，等價于[a-zA-Z0-9]
[:alpha:] 任何一個字母，等價于[a-zA-Z]
[:blank:] 空格或制表符，等價于[\t]
[:cntrl:] ASCII控制字符（ASCII 0到31，再加上ASCII 127）
[:digit:] 任何一個數字，等價于[0-9]
[:graph:] 任何一個可打印字符，但不包括空格
[:lower:] 任何一個小寫字母，等價于[a-z]
[:print:] 任何一個可打印字符
[:punct:] 既不屬于[:alnum:]和[:cntrl:]的任何一個字符
[:space:] 任何一個空白字符，包括空格，等價于[^\f\n\r\t\v]
[:upper:] 任何一個大寫字母，等價于[A-Z]
[:xdigit:] 任何一個十六進制數字，等價于[a-fA-F0-9]
POSIX字符和之前見過的元字符不太一樣，我們來看一個前面利用正則表達式來匹配網頁中的顏色的例子：
文本：<span style="background-color:#3636FF;height:30px;width:60px;">測試</span>
正則表達式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]
結果：<span style="background-color:【#3636FF】;height:30px;width:60px;">測試</span>
注意：這里使用的模式以[[開頭、以]]結束，這是使用POSIX字符類所必須的，POSIX字符必須括在[:和:]之間，外層[和]字符用來定義一個集合，內層的[和]字符是POSIX字符類本身的組成部分。
在java中的POSIX字符表示有所不同，不是包括在[:和:]之間，而是以\p開頭，包括在{和}之間，且大小寫有區別，同時增加了\p{ASCII}，如下所示：
\p{Alnum} 字母數字字符：[\p{Alpha}\p{Digit}]
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]
\p{ASCII} 所有 ASCII：[\x00-\x7F]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{Digit} 十進制數字：[0-9]
\p{Graph} 可見字符：[\p{Alnum}\p{Punct}]
\p{Lower} 小寫字母字符：[a-z]
\p{Print} 可打印字符：[\p{Graph}\x20]
\p{Punct} 標點符號：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Space} 空白字符：[ \t\n\x0B\f\r]
\p{Upper} 大寫字母字符：[A-Z]
\p{XDigit} 十六進制數字：[0-9a-fA-F]
2012年6月14日
#
一、final
根據程序上下文環境，Java關鍵字final有“這是無法改變的”或者“終態的”含義，它可以修飾非抽象類、非抽象類成員方法和變量。你可能出于兩種理解而需要阻止改變：設計或效率。
final類不能被繼承，沒有子類，final類中的方法默認是final的。
final方法不能被子類的方法覆蓋，但可以被繼承。
final成員變量表示常量，只能被賦值一次，賦值后值不再改變。
final不能用于修飾構造方法。
注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。
1、final類
final類不能被繼承，因此final類的成員方法沒有機會被覆蓋，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，并且確信這個類不會載被擴展，那么就設計為final類。
2、final方法
如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。
使用final方法的原因有二：
第一、把方法鎖定，防止任何繼承類修改它的意義和實現。
第二、高效。編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。
例如：
public class Test1 {
public static void main(String[] args) {
// TODO 自動生成方法存根
}
public void f1() {
System.out.println("f1");
}
//無法被子類覆蓋的方法
public final void f2() {
System.out.println("f2");
}
public void f3() {
System.out.println("f3");
}
private void f4() {
System.out.println("f4");
}
}
public class Test2 extends Test1 {
public void f1(){
System.out.println("Test1父類方法f1被覆蓋!");
}
public static void main(String[] args) {
Test2 t=new Test2();
t.f1();
t.f2(); //調用從父類繼承過來的final方法
t.f3(); //調用從父類繼承過來的方法
//t.f4(); //調用失敗，無法從父類繼承獲得
}
} |
3、final變量（常量）
用final修飾的成員變量表示常量，值一旦給定就無法改變！
final修飾的變量有三種：靜態變量、實例變量和局部變量，分別表示三種類型的常量。
從下面的例子中可以看出，一旦給final變量初值后，值就不能再改變了。
另外，final變量定義的時候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什么情況，編譯器都確?？瞻譮inal在使用之前必須被初始化。但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，卻有保持其恒定不變的特征。
package org.leizhimin;
public class Test3 {
private final String S="final實例變量S";
private final int A=100;
public final int B=90;
public static final int C=80;
private static final int D=70;
public final int E; //final空白,必須在初始化對象的時候賦初值
public Test3(int x){
E=x;
}
/**
* @param args
*/
public static void main(String[] args) {
Test3 t=new Test3(2);
//t.A=101; //出錯,final變量的值一旦給定就無法改變
//t.B=91; //出錯,final變量的值一旦給定就無法改變
//t.C=81; //出錯,final變量的值一旦給定就無法改變
//t.D=71; //出錯,final變量的值一旦給定就無法改變
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C); //不推薦用對象方式訪問靜態字段
System.out.println(t.D); //不推薦用對象方式訪問靜態字段
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E); //出錯,因為E為final空白,依據不同對象值有所不同.
System.out.println(t.E);
Test3 t1=new Test3(3);
System.out.println(t1.E); //final空白變量E依據對象的不同而不同
}
private void test(){
System.out.println(new Test3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
public void test2(){
final int a; //final空白,在需要的時候才賦值
final int b=4; //局部常量--final用于局部變量的情形
final int c; //final空白,一直沒有給賦值.
a=3;
//a=4; 出錯,已經給賦過值了.
//b=2; 出錯,已經給賦過值了.
}
} |
4、final參數
當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。
public class Test4 {
public static void main(String[] args) {
new Test4().f1(2);
}
public void f1(final int i){
//i++; //i是final類型的,值不允許改變的.
System.out.print(i);
}
} |
二、static static表示“全局”或者“靜態”的意思，用來修飾成員變量和成員方法，也可以形成靜態static代碼塊，但是
Java語言中沒有全局變量的概念。
被static修飾的成員變量和成員方法獨立于該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。只要這個類被加載，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們。因此，static對象可以在它的任何對象創建之前訪問，無需引用任何對象。
用public修飾的static成員變量和成員方法本質是全局變量和全局方法，當聲明它類的對象市，不生成static變量的副本，而是類的所有實例共享同一個static變量。
static變量前可以有private修飾，表示這個變量可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問權限限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問權限關鍵字的效果也以此類推。
static修飾的成員變量和成員方法習慣上稱為靜態變量和靜態方法，可以直接通過類名來訪問，訪問語法為：
類名.靜態方法名(參數列表...)
類名.靜態變量名
用static修飾的代碼塊表示靜態代碼塊，當Java虛擬機（JVM）加載類時，就會執行該代碼塊（用處非常大，呵呵）。
1、static變量 按照是否靜態的對類成員變量進行分類可分兩種：一種是被static修飾的變量，叫靜態變量或類變量；另一種是沒有被static修飾的變量，叫實例變量。兩者的區別是：
對于靜態變量在內存中只有一個拷貝（節省內存），JVM只為靜態分配一次內存，在加載類的過程中完成靜態變量的內存分配，可用類名直接訪問（方便），當然也可以通過對象來訪問（但是這是不推薦的）。
對于實例變量，沒創建一個實例，就會為實例變量分配一次內存，實例變量可以在內存中有多個拷貝，互不影響（靈活）。
2、靜態方法 靜態方法可以直接通過類名調用，任何的實例也都可以調用，因此靜態方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變量和實例方法(就是不帶static的成員變量和成員成員方法)，只能訪問所屬類的靜態成員變量和成員方法。因為實例成員與特定的對象關聯！這個需要去理解，想明白其中的道理，不是記憶?。。?
因為static方法獨立于任何實例，因此static方法必須被實現，而不能是抽象的abstract。
3、static代碼塊 static代碼塊也叫靜態代碼塊，是在類中獨立于類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內，JVM加載類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先后順序依次執行它們，每個代碼塊只會被執行一次。例如：
public class Test5 {
private static int a;
private int b;
static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自動生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
} |
運行結果：
3
hhahhahah
1000
4
5
利用靜態代碼塊可以對一些static變量進行賦值，最后再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調用而不用創建實例。
4、static和final一塊用表示什么 static final用來修飾成員變量和成員方法，可簡單理解為“全局常量”！
對于變量，表示一旦給值就不可修改，并且通過類名可以訪問。
對于方法，表示不可覆蓋，并且可以通過類名直接訪問。
2012年5月31日
#
什么是ThreadLocal？
顧名思義它是local variable（線程局部變量）。它的功用非常簡單，就是為每一個使用該變量的線程都提供一個變量值的副本，是每一個線程都可以獨立地改變自己的副本，而不會和其它線程的副本沖突。從線程的角度看，就好像每一個線程都完全擁有該變量。
使用場景
- To keep state with a thread (user-id, transaction-id, logging-id)
- To cache objects which you need frequently
ThreadLocal類
它主要由四個方法組成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，該方法是一個protected的方法，顯然是為了子類重寫而特意實現的。該方法返回當前線程在該線程局部變量的初始值，這個方法是一個延遲調用方法，在一個線程第1次調用get()或者set(Object)時才執行，并且僅執行1次。ThreadLocal中的確實實現直接返回一個null：
ThreadLocal的原理
ThreadLocal是如何做到為每一個線程維護變量的副本的呢？其實實現的思路很簡單，在ThreadLocal類中有一個Map，用于存儲每一個線程的變量的副本。比如下面的示例實現：
public class ThreadLocal
{
private Map values = Collections.synchronizedMap(new HashMap());
public Object get()
{
Thread curThread = Thread.currentThread();
Object o = values.get(curThread);
if (o == null && !values.containsKey(curThread))
{
o = initialValue();
values.put(curThread, o);
}
return o;
}
public void set(Object newValue)
{
values.put(Thread.currentThread(), newValue);
}
public Object initialValue()
{
return null;
}
}
ThreadLocal 的使用
使用方法一：
Hibernate的文檔時看到了關于使ThreadLocal管理多線程訪問的部分。具體代碼如下
1. public static final ThreadLocal session = new ThreadLocal();
2. public static Session currentSession() {
3. Session s = (Session)session.get();
4. //open a new session,if this session has none
5. if(s == null){
6. s = sessionFactory.openSession();
7. session.set(s);
8. }
return s;
9. }
我們逐行分析
1。 初始化一個ThreadLocal對象，ThreadLocal有三個成員方法 get()、set()、initialvalue()。
如果不初始化initialvalue，則initialvalue返回null。
3。session的get根據當前線程返回其對應的線程內部變量，也就是我們需要的net.sf.hibernate.Session（相當于對應每個數據庫連接）.多線程情況下共享數據庫鏈接是不安全的。ThreadLocal保證了每個線程都有自己的s（數據庫連接）。
5。如果是該線程初次訪問，自然，s（數據庫連接）會是null，接著創建一個Session，具體就是行6。
6。創建一個數據庫連接實例 s
7。保存該數據庫連接s到ThreadLocal中。
8。如果當前線程已經訪問過數據庫了，則從session中get()就可以獲取該線程上次獲取過的連接實例。
使用方法二
當要給線程初始化一個特殊值時，需要自己實現ThreadLocal的子類并重寫該方法，通常使用一個內部匿名類對ThreadLocal進行子類化，EasyDBO中創建jdbc連接上下文就是這樣做的：
public class JDBCContext{
private static Logger logger = Logger.getLogger(JDBCContext.class);
private DataSource ds;
protected Connection connection;
private boolean isValid = true;
private static ThreadLocal jdbcContext;
private JDBCContext(DataSource ds){
this.ds = ds;
createConnection();
}
public static JDBCContext getJdbcContext(javax.sql.DataSource ds)
{
if(jdbcContext==null)jdbcContext=new JDBCContextThreadLocal(ds);
JDBCContext context = (JDBCContext) jdbcContext.get();
if (context == null) {
context = new JDBCContext(ds);
}
return context;
}
private static class JDBCContextThreadLocal extends ThreadLocal {
public javax.sql.DataSource ds;
public JDBCContextThreadLocal(javax.sql.DataSource ds)
{
this.ds=ds;
}
protected synchronized Object initialValue() {
return new JDBCContext(ds);
}
}
}
使用單例模式，不同的線程調用getJdbcContext()獲得自己的jdbcContext，都是通過JDBCContextThreadLocal 內置子類來獲得JDBCContext對象的線程局部變量，這個變
1.目的
ThreadLocal目的是保存一些線程級別的全局變量，比如connection，或者事務上下文，避免這些值需要一直通過函數參數的方式一路傳遞。
2. 常見用法
舉例其中一種常見用法：
public class Test2 {
public static void main(String[] args) throws InterruptedException {
testThreadLocal();
}
private static void testThreadLocal() {
Util.setGlobalName("zili.dengzl");
new Foo().printName();
}
}
class Foo{
public void printName(){
System.out.println("globalName="+Util.getGlobalName());
}
}
class Util {
private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
public static String getGlobalName() {
return globalName.get();
}
public static void setGlobalName(String name) {
globalName.set(name);
}
}
3.實現分析
要實現上面這樣的功能，最簡單的想法是用一個Map<Thread,T>,如下：
class MockThreadLocal<T> {
private Map<Thread, T> map = new HashMap<Thread, T>();
public T get() {
return (T) map.get(Thread.currentThread());
}
public void set(T value) {
map.put(Thread.currentThread(), value);
}
}
這樣也能實現ThreadLocal的效果，但是有一個問題，當對應的線程消失后，map中對應的線程值并不會被回收，從而造成內存泄露。
事實上ThreadLocal是這樣做的：
每個Thread都有一個threadLocalMap，key是threadLocal對象，value是具體使用的值。ThreadLocal對象的get就是先取得當前的Thread，然后從這個Thread的threadLcoalMap中取出值。set類似。
下面看下具體代碼：
/**
* Returns the value in the current thread's copy of this
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
注意這里如果取到沒有該線程對應的值，會調用setInitialValue();，最終調用initialValue()生成一個值，這也是我們很多場景下要override這個方法的原因；
下面看一下getMap(Thread t)方法：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
在Thread類中：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
由此可見，所有的ThreadLocal的信息，最終是關聯到Thread上的，線程消失后，對應的Thread對象也被回收，這時對應的ThreadLocal對象(該線程部分)也會被回收。
這里為什么是一個ThreadLocalMap呢，因為一個線程可以有多個ThreadLocal變量，通過map.getEntry(this)取得對應的某個具體的變量。
private Entry getEntry(ThreadLocal key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
最后要注意的一點是，ThreadLocalMap的Entry是一個weakReference：
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
這里主要因為ThreadLocalMap的key是ThreadLocal對象，如果某個ThreadLocal對象所有的強引用沒有了，會利用weakref的功能把他回收掉，然后復用這個entry。
考慮一下如果不用weakReference會出現什么情況：假設某個對象是這樣引用的
private final ThreadLocal<String> globalName = new ThreadLocal<String>();
注意沒有static，然后這個對象被不斷的new出來，然后死掉，每次ThreadLocalmap中都會多出一個entry，然后這個entry強引用一個ThreadLocal對象，ThreadLocalMap本身就沒有辦法確定哪個entry是不用了的，如果恰好這個線程是線程池中的，會存活很久，那就杯具了。
ThreadLocalMap用了weakReference，失去強引用的ThreadLocal對象會在下次gc時被回收，然后ThreadLocalMap本身在get和set的時候會考察key為空的Entry，并復用它或者清除，從而避免內存泄露。
這樣看來，HashMap也有一樣的問題，但為什么hashMap不這樣呢，因為hashMap的put是業務代碼操作的，因此如果有長期存活的HashMap，（比如static的）業務代碼put進去就有義務去remove，但ThreadLocal的put操作時ThreadLocal類干的，業務代碼不知道，因此也不會去做remove，而ThreadLocalMap本身不知道引用他的某個entry的key的對象什么時候死掉了，那么如果不用弱引用，就不知道這個ThreadLocal對象什么時候需要回收了。
附：
這里補充一下weakReference的用法供參考（當強引用不存在時，下次垃圾回收會回收弱引用所引用的對象）：
Object o = new Object();
WeakReference<Object> ref = new WeakReference<Object>(o);
System.out.println(ref.get());
o=null;
System.gc();
System.out.println(ref.get());
結果輸出：
java.lang.Object@de6ced
null
4. FAQ
4.1 為什么一般的ThreadLocal用法都要加static，如下：
class Test {
private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
}
answer:事實上，不一定是要static，但使用它的對象在業務需要范圍類一定要是單例。因為根據前面的分析，ThreadLocalMap是以ThreadLocal對象為key的，如果Test類不是static，也不是單例的，那么兩個Test對象就有兩個key，取出來的數據肯定不同
class TestThreadLocal{
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
t1.pool.set("a");
System.out.println(t1.pool.get());
System.out.println(t2.pool.get());
}
}
class Test{
public ThreadLocal pool = new ThreadLocal();
}
輸出將會是：a，null
原因就無需多解釋了。唯一需要啰嗦的一點是，就算一般情況都是單例，上面那個weakreference還是必要的，因為作為框架代碼，不能保證正常使用的情況下一個線程有很多ThreadLocal，如果不用weakreference，就會有內存泄漏的風險，特別是針對線程池中的線程。
2012年5月30日
#
摘要: 轉載：http://www.tkk7.com/f6k66ve/archive/2012/05/30/379516.htmlSpring配置文件中關于事務配置總是由三個組成部分，分別是DataSource、TransactionManager和代理機制這三部分，無論哪種配置方式，一般變化的只是代理機制這部分。
DataSource、TransactionManager這兩部分只是會根...
閱讀全文
2012年5月15日
#