Java面试宝典4.0版
JAVA 面試寶典 V4.0 版本
基礎
1. 簡述 JDK 跟 JRE 的區別
Jdk 是 java 開發人員在開發過程使用的軟件開發包，他提供了 java 的開發環境和運行環境 JRE 是 Java Runtime Enviroment 是指 Java 的運行環境
如果你只想跑 java 程序，只要安裝 jre 就夠了，如果要從事開發就得安裝 jdk
2. 簡述 path 跟 classpath 的區別
Path 是系統變量，跟 java 無關，里面存放的是各種可執行的應用程序的路徑
Classpath 是給 java 使用的，從字面上來理解，就是類的路徑，主要是模仿 path ，將類文件 的路徑配置到 classpath 中實現在系統的任何位置可以對類文件進行編譯和執行
3.Java 的關鍵字中有沒有 goto
Goto 是 java 中的保留字不是關鍵字的一員
4. ”static”關鍵字是什么意思？ Java 中是否可以覆蓋 (override) 一個 private 或者是 static 的方法？
“static”關鍵字表明一個成員變量或者是成員方法可以在沒有所屬的類的實例變量的情況下 被訪問。
Java 中 static 方法不能被覆蓋，因為方法覆蓋是基于運行時動態綁定的，而 static 方法是編 譯時靜態綁定的。 static 方法跟類的任何實例都不相關，所以概念上不適用。
5.Java 中的方法覆蓋 (Overriding) 和方法重載 (Overloading) 是 什么意思？
Java 中的方法重載發生在同一個類里面兩個或者是多個方法的方法名相同但是參數不同的 情況。與此相對，方法覆蓋是說子類重新定義了父類的方法。方法覆蓋必須有相同的方法名， 參數列表和返回類型。覆蓋者可能不會限制它所覆蓋的方法的訪問。
6.Overload 和 Override 的區別 ?
方法的重寫 Overriding 和重載 Overloading 是 Java 多態性的不同表現。重寫 Overriding 是 父類與子類之間多態性的一種表現，重載 Overloading 是一個類中多態性的一種表現。如果 在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding) 。子 類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。 如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則 稱為方法的重載 (Overloading) 。
7. 接口和抽象類的區別是什么？
Java 提供和支持創建抽象類和接口。它們的實現有共同點，不同點在于：
接口中所有的方法隱含的都是抽象的。而抽象類則可以同時包含抽象和非抽象的方法。 類可以實現很多個接口，但是只能繼承一個抽象類
類可以不實現抽象類和接口聲明的所有方法，當然，在這種情況下，類也必須得聲明成是抽 象的。
抽象類可以在不提供接口方法實現的情況下實現接口。
Java 接口中聲明的變量默認都是 final 的。抽象類可以包含非 final 的變量。
Java 接口中的成員函數默認是 public 的。抽象類的成員函數可以是 private ， protected 或者 是 public 。
接口是絕對抽象的，不可以被實例化。抽象類也不可以被實例化，但是，如果它包含 main 方法的話是可以被調用的。
也可以參考 JDK8 中抽象類和接口的區別
8. 接 口 是 否 可 繼 承 接 口 ? 抽 象 類 是 否 可 實 現 (implements) 接 口 ? 抽象類是否可繼承實體類 (concrete class)?
接口可以繼承接口。抽象類可以實現 (implements) 接口，抽象類是否可繼承實體類，但前提 是實體類必須有明確的構造函數。
9.Java 的基本數據類型跟引用數據類型分別有哪些？
Java 的基本數據類型有 8 個分別是 整數型 byte shrot int long char 浮點型 float double 字符型 char 布爾型 bollean
10.char? ?型變量中能不能存貯一個中文漢字 ? 為什么 ?
char 型變量是用來存儲 Unicode 編碼的字符的， unicode 編碼字符集中包含了漢字，所以， char 型變量中當然可以存儲漢字啦。
11. 簡述 & 和 && 的區別
& 和 && 都可以用作邏輯與的運算符，表示邏輯與（ and ），當運算符兩邊的表達式的結果都 為 true 時，整個運算結果才為 true ，否則，只要有一方為 false ，則結果為 false 。 && 還具有短路的功能，即如果第一個表達式為 false ，則不再計算第二個表達式 & 還可以用作位運算符
12.Java 中垃圾回收有什么目的？什么時候進行垃圾回收？
垃圾回收的目的是識別并且丟棄應用不再使用的對象來釋放和重用資源。
13. 如果對象的引用被置為 null ，垃圾收集器是否會立即釋放 對象占用的內存？
不會，在下一個垃圾回收周期中，這個對象將是可被回收的。
多線程
1. 進程和線程的區別是什么？
進程是執行著的應用程序，而線程是進程內部的一個執行序列。一個進程可以有多個線程。 線程又叫做輕量級進程。
2. 創建線程有幾種不同的方式？
有三種方式可以用來創建線程：
繼承 Thread 類
實現 Runnable 接口
應用程序可以使用 Executor 框架來創建線程池
實現 Runnable 接口這種方式更受歡迎，因為這不需要繼承 Thread 類。在應用設計中已經繼 承了別的對象的情況下，這需要多繼承（而 Java 不支持多繼承），只能實現接口。同時，線 程池也是非常高效的，很容易實現和使用。
3. 概括的解釋下線程的幾種可用狀態。
1. 新建 ( new ) ：新創建了一個線程對象。
2. 可運行 ( runnable ) ：線程對象創建后，其他線程 ( 比如 main 線程）調用了該對象 的 start () 方法。該狀態的線程位于可運行線程池中，等待被線程調度選中，獲 取 cpu 的使用權 。 3. 運行 ( running ) ：可運行狀態 ( runnable ) 的線程獲得了 cpu 時間片（ timeslice ） ，執 行程序代碼。
4. 阻 塞 ( block ) ： 阻塞狀態是指線 程因為某種原因放棄了 cpu 使 用權，也即讓出了 cpu timeslice ，暫時停止運行。直到線程進入可運行 ( runnable ) 狀態，才有 機會再次獲得 cpu timeslice 轉到運行 ( running ) 狀態。阻塞的情況分三種：
( 一 ). 等待阻塞：運行 ( running ) 的線程執行 o . wait () 方法， JVM 會把該線程放 入等待隊 列 ( waitting queue ) 中。
( 二 ). 同步阻塞：運行 ( running ) 的線程在獲取對象的同步鎖時，若該同步鎖 被別的線程占 用，則 JVM 會把該線程放入鎖池 ( lock pool ) 中。
( 三 ). 其他阻塞 : 運行 ( running ) 的線程執行 Thread . sleep ( long ms ) 或 t . join () 方法，或者 發出了 I / O 請求時， JVM 會把該線程置為阻塞狀態。 當 sleep () 狀態超時、 join () 等待線程終止或者超時、或者 I / O 處理完畢時，線程重新轉入可運行 ( runnable ) 狀 態。
5. 死亡 ( dead ) ：線程 run () 、 main () 方法執行結束，或者因異常退出了 run () 方法，則該 線程結束生命周期。死亡的線程不可再次復生。 舉例：早上打車去上班
新建（準備叫一輛嘀嘀打車）
可運行（找到一輛可以帶你去上班的車） 運行（司機接到你，帶你去上班） 阻塞（路上堵車了）
死亡（到公司了，付錢下車）
4. 同步方法和同步代碼塊的區別是什么？
同步方法默認用 this 或者當前類 class 對象作為鎖；
同步代碼塊可以選擇以什么來加鎖，比同步方法要更細顆粒度，我們可以選擇只同步會發 生同步問題的部分代碼而不是整個方法；
5. 什么是死鎖 (deadlock) ？
兩個線程或兩個以上線程都在等待對方執行完畢才能繼續往下執行的時候就發生了死鎖。結 果就是這些線程都陷入了無限的等待中。
6. 如何確保 N 個線程可以訪問 N 個資源同時又不導致死鎖？
使用多線程的時候，一種非常簡單的避免死鎖的方式就是：指定獲取鎖的順序，并強制線程 按照指定的順序獲取鎖。因此，如果所有的線程都是以同樣的順序加鎖和釋放鎖，就不會出 現死鎖了。
7.sleep() 和 wait() 的區別
sleep 指線程被調用時，占著 CPU 不工作，形象地說明為“占著 CPU 睡覺”，此時，系統的 CPU 部分資源被占用，其他線程無法進入，會增加時間限制。
wait 指線程處于進入等待狀態，形象地說明為“等待使用 CPU”，此時線程不占用任何資源， 不增加時間限制。
8. 實現同步的方式
同步是多線程中的重要概念。同步的使用可以保證在多線程運行的環境中，程序不會產生設 計 之 外 的 錯 誤 結 果 。 同 步 的 實 現 方 式 有 兩 種 ， 同 步 方 法 和 同 步 塊 ， 這 兩 種 方 式 都 要 用到 synchronized 關鍵字。 1. 同步方法
即有 synchronized 關鍵字修飾的方法。
由于 java 的每個對象都有一個內置鎖，當用此關鍵字修飾方法時，
內置鎖會保護整個方法。在調用該方法前，需要獲得內置鎖，否則就處于阻塞狀態。 代碼如：
public synchronized void save(){}
注： synchronized 關鍵字也可以修飾靜態方法，此時如果調用該靜態方法，將會鎖住整
個類
2. 同步代碼塊
即有 synchronized 關鍵字修飾的語句塊。
被該關鍵字修飾的語句塊會自動被加上內置鎖，從而實現同步 代碼如：
synchronized(object){ }
注：同步是一種高開銷的操作，因此應該盡量減少同步的內容。
通常沒有必要同步整個方法，使用 synchronized 代碼塊同步關鍵代碼即可。
集合
1.Java 集合類框架的基本接口有哪些？
Java 集合類提供了一套設計良好的支持對一組對象進行操作的接口和類。 Java 集合類里面 最基本的接口有：
Collection ：代表一組對象，每一個對象都是它的子元素。 Set ：不包含重復元素的 Collection 。
List ：有順序的 collection ，并且可以包含重復元素。
Map ：可以把鍵 (key) 映射到值 (value) 的對象，鍵不能重復。
2. 為什么集合類沒有實現 Cloneable 和 Serializable 接口？
克隆 (cloning) 或者是序列化 (serialization) 的語義和含義是跟具體的實現相關的。因此，應該 由集合類的具體實現來決定如何被克隆或者是序列化。
3. 什么是迭代器 (Iterator) ？
Iterator 接口提供了很多對集合元素進行迭代的方法。每一個集合類都包含了可以返回迭代 器實例的 迭代方法。迭代器可以在迭代的過程中刪除底層集合的元素 , 但是不可以直接調用 集合的 remove(Object Obj) 刪除，可以通過迭代器的 remove() 方法刪除。
4.Iterator 和 ListIterator 的區別是什么？
Iterator 可用來遍歷 Set 和 List 集合，但是 ListIterator 只能用來遍歷 List 。 Iterator 對集合只能是前向遍歷， ListIterator 既可以前向也可以后向。
ListIterator 實現了 Iterator 接口，并包含其他的功能，比如：增加元素，替換元素，獲取前 一個和后一個元素的索引，等等。
5.hashCode() 和 equals() 方法的重要性體現在什么地方？
Java 中的 HashMap 使用 hashCode() 和 equals() 方法來確定鍵值對的索引，當根據鍵獲取值 的時候也會用到這兩個方法。如果沒有正確的實現這兩個方法，兩個不同的鍵可能會有相同 的 hash 值，因此，可能會被集合認為是相等的。而且，這兩個方法也用來發現重復元素。 所以這兩個方法的實現對 HashMap 的精確性和正確性是至關重要的。
6.HashMap 和 Hashtable 有什么區別？
HashMap 和 Hashtable 都實現了 Map 接口，因此很多特性非常相似。但是，他們有以下不
同點：
HashMap 允許鍵和值是 null ，而 Hashtable 不允許鍵或者值是 null 。
Hashtable 是同步的，而 HashMap 不是。因此， HashMap 更適合于單線程環境，而 Hashtable 適合于多線程環境。
7.ArrayList 和 LinkedList 有什么區別？
ArrayList 和 LinkedList 都實現了 List 接口，他們有以下的不同點：
ArrayList 是基于索引的數據接口，它的底層是數組。它可以以 O(1) 時間復雜度對元素進行隨 機訪問，因此查詢某個元素的時間短。與此對應， LinkedList 是以元素列表的形式存儲它的 數據，每一個元素都和它的前一個和后一個元素鏈接在一起，在這種情況下，查找某個元素 的時間長。
相對于 ArrayList ， LinkedList 的插入，添加，刪除操作速度更快，因為當元素被添加到集合 任意位置的時候，不需要像數組那樣重新計算大小或者是更新索引。
8.Comparable 和 Comparator 接口是干什么的？列出它們的 區別。
java 提供了只包含一個 compareTo() 方法的 Comparable 接口。這個方法可以個給兩個對象 排序。具體來說，它返回負數， 0 ，正數來表明輸入對象小于，等于，大于已經存在的對象。 Java 提供了包含 compare() 和 equals() 兩個方法的 Comparator 接口。 compare() 方法用來給 兩個輸入參數排序，返回負數， 0 ，正數表明第一個參數是小于，等于，大于第二個參數。 equals() 方法需要一個對象作為參數，它用來決定輸入參數是否和 comparator 相等。只有當 輸入參數也是一個 comparator 并且輸入參數和當前 comparator 的排序結果是相同的時候， 這個方法才返回 true 。
9.Enumeration 接口和 Iterator 接口的區別有哪些？
Enumeration 速度是 Iterator 的 2 倍，同時占用更少的內存。但是， Iterator 遠遠比 Enumeration 安全，因為其他線程不能夠修改正在被 iterator 遍歷的集合里面的對象。同時， Iterator 允許 調用者刪除底層集合里面的元素，這對 Enumeration 來說是不可能的。
10.HashSet 和 TreeSet 有什么區別？
Treeset 中的數據是自動排好序的，不允許放入 null 值
HashSet 中的數據是無序的，可以放入 null ，但只能放入一個 null ，兩者中的值都不能重復， 就如數據庫中唯一約束
HashSet 要求放入的對象必須實現 HashCode() 方法，放入的對象，是以 hashcode 碼作為標 識的，而具有相同內容的 String 對象， hashcode 是一樣，所以放入的內容不能重復。但是 同一個類的對象可以放入不同的實例
JAVAWEB
1.Ajax
Ajax 的原理簡單來說通過 XmlHttpRequest 對象來向服務器發異步請求，從服務器獲得數據， 然后用 javascript 來操作 DOM 而更新頁面。這其中最關鍵的一步就是從服務器獲得請求數 據。
XMLHttpRequest 是 ajax 的核心機制，它是在 IE5 中首先引入的，是一種支持異步請求的技 術。簡單的說，也就是 javascript 可以及時向服務器提出請求和處理響應，而不阻塞用戶。 達到無刷新的效果。 優點：
Ajax 的給我們帶來的好處大家基本上都深有體會：
1 、最大的一點是頁面無刷新，在頁面內與服務器通信，給用戶的體驗非常好。 2 、使用異步方式與服務器通信，不需要打斷用戶的操作，具有更加迅速的響應能力。 3 、可以把以前一些服務器負擔的工作轉嫁到客戶端，利用客戶端閑置的能力來處理，減輕 服務器和帶寬的負擔，節約空間和寬帶租用成本。并且減輕服務器的負擔， ajax 的原則是“按 需取數據”，可以最大程度的減少冗余請求，和響應對服務器造成的負擔。 缺點：
下面所闡述的 ajax 的缺陷都是它先天所產生的。
1 、 ajax 干掉了 back 按鈕，即對瀏覽器后退機制的破壞。后退按鈕是一個標準的 web 站點 的重要功能，但是它沒法和 js 進行很好的合作。這是 ajax 所帶來的一個比較嚴重的問題 . 2 、安全問題
技術同時也對 IT 企業帶來了新的安全威脅， ajax 技術就如同對企業數據建立了一個直接通 道。這使得開發者在不經意間會暴露比以前更多的數據和服務器邏輯。 ajax 的邏輯可以對客 戶端的安全掃描技術隱藏起來，允許黑客從遠端服務器上建立新的攻擊。還有 ajax 也難以 避免一些已知的安全弱點，諸如跨站點腳步攻擊、 SQL 注入攻擊和基于 credentials 的安全漏 洞等。
2.Servlet
主要分四大選擇器，分別是基本選擇器、層次選擇器、過濾選擇器、屬性過濾選擇器。 常用的選擇器分為以下幾種。 1. 基本選擇器：
Id 選擇器、 class 選擇器、 element 選擇器、 * 選擇器、并列選擇器。 2. 層級選擇器：
parent > child （直系子元素）、
prev + next （下一個兄弟元素，等同于 next() 方法）、
prev ~ siblings （ prev 元素的所有兄弟元素，等同于 nextAll() 方法）、 3. 過濾選擇器：
first 和 :last （取第一個元素或最后一個元素）
even 和 :odd （取偶數索引或奇數索引元素，索引從 0 開始， even 表示偶數， odd 表示奇數） t （取非元素）
eq(x) （取指定索引的元素）
gt(x) 和 :lt(x) （取大于 x 索引或小于 x 索引的元素） header （取 H1~H6 標題元素）
3.Cookie&Session
會話（ Session ）跟蹤是 Web 程序中常用的技術，用來跟蹤用戶的整個會話。常用的會話跟蹤技術是 Cookie 與 Session 。 Cookie 通過在客戶端記錄信息確定用戶身份， Session 通過在服務器端記錄信息確定用戶身 份。
4. 什么是 Cookie
Cookie 實際上是一小段的文本信息。客戶端請求服務器，如果服務器需要記錄該用戶狀態， 就使用 response 向客戶端瀏覽器頒發一個 Cookie 。客戶端瀏覽器會把 Cookie 保存起來。當 瀏覽器再請求該網站時，瀏覽器把請求的網址連同該 Cookie 一同提交給服務器。服務器檢 查該 Cookie ，以此來辨認用戶狀態。服務器還可以根據需要修改 Cookie 的內容。
5.Cookie 機制
在程序中，會話跟蹤是很重要的事情。理論上，一個用戶的所有請求操作都應該屬于同一個 會話，而另一個用戶的所有請求操作則應該屬于另一個會話，二者不能混淆。例如，用戶 A 在超市購買的任何商品都應該放在 A 的購物車內，不論是用戶 A 什么時間購買的，這都是 屬于同一個會話的，不能放入用戶 B 或用戶 C 的購物車內，這不屬于同一個會話。 而 Web 應用程序是使用 HTTP 協議傳輸數據的。 HTTP 協議是無狀態的協議。一旦數據交換 完畢，客戶端與服務器端的連接就會關閉，再次交換數據需要建立新的連接。這就意味著服 務器無法從連接上跟蹤會話。即用戶 A 購買了一件商品放入購物車內，當再次購買商品時 服務器已經無法判斷該購買行為是屬于用戶 A 的會話還是用戶 B 的會話了。要跟蹤該會話， 必須引入一種機制。
Cookie 就是這樣的一種機制。它可以彌補 HTTP 協議無狀態的不足。在 Session 出現之前， 基本上所有的網站都采用 Cookie 來跟蹤會話。
6. 什么是 Session
Session 是另一種記錄客戶狀態的機制，不同的是 Cookie 保存在客戶端瀏覽器中，而 Session 保存在服務器上。客戶端瀏覽器訪問服務器的時候，服務器把客戶端信息以某種形式記錄在 服務器上。這就是 Session 。客戶端瀏覽器再次訪問時只需要從該 Session 中查找該客戶的 狀態就可以了。
如果說 Cookie 機制是通過檢查客戶身上的“通行證”來確定客戶身份的話，那么 Session 機制
就是通過檢查服務器上的“客戶明細表”來確認客戶身份。 Session 相當于程序在服務器上建 立的一份客戶檔案，客戶來訪的時候只需要查詢客戶檔案表就可以了。
7.Session 機制
除了使用 Cookie ， Web 應用程序中還經常使用 Session 來記錄客戶端狀態。 Session 是服務 器端使用的一種記錄客戶端狀態的機制，使用上比 Cookie 簡單一些，相應的也增加了服務 器的存儲壓力。
8. 如何利用 cookie 實現自動登錄 ?
當用戶在某個網站注冊后，就會收到一個惟一用戶 ID 的 cookie 。客戶后來重新連接時，這 個用戶 ID 會自動返回，服務器對它進行檢查，確定它是否為注冊用戶且選擇了自動登錄， 從而使用戶無需給出明確的用戶名和密碼，就可以訪問服務器上的資源 .
9. 保存 session id 有幾種方法 ?
A 保存 session id 的方式可以采用 cookie ，這樣在交互過程中瀏覽器可以自動的按照規則把 這個標識發送給服務器。
B ．由于 cookie 可以被人為的禁止，必須有其它的機制以便在 cookie 被禁止時仍然能夠把 session id 傳遞回服務器，經常采用的一種技術叫做 URL 重寫，就是把 session id 附加在 URL 路徑的后面，附加的方式也有兩種，一種是作為 URL 路徑的附加信息，另一種是作為查詢 字符串附加在 URL 后面。網絡在整個交互過程中始終保持狀態，就必須在每個客戶端可能 請求的路徑后面都包含這個 session id 。
C ．另一種技術叫做表單隱藏字段。就是服務器會自動修改表單，添加一個隱藏字段，以便 在表單提交時能夠把 session id 傳遞回服務器
10.session 什么時候被創建 ?
一個常見的錯誤是以為 session 在有客戶端訪問時就被創建，然而事實是直到某 server 端程 序 ( 如 Servlet) 調用 HttpServletRequest.getSession(true) 這樣的語句時才會被創建。
11.session 何時被刪除 ?
A. 程序調用 HttpSession.invalIDAte()
B ．距離上一次收到客戶端發送的 session id 時間間隔超過了 session 的最大有效時間 C ．服務器進程被停止
注意關閉瀏覽器只會使存儲在客戶端瀏覽器內存中的 session cookie 失效，不會使服務器端 的 session 對象失效 .
12.cookie 機制和 session 機制的區別？
具體來說 cookie 機制采用的是在客戶端保持狀態的方案，而 session 機制采用的是在服務器 端保持狀態的方案。同時我們也看到，由于在服務器端保持狀態的方案在客戶端也需要保存 一個標識，所以 session 機制可能需要借助于 cookie 機制來達到保存標識的目的，但實際上 還有其他選擇。
MySQL 數據庫
1.MySQL 事務
MySQL 事務主要用于處理操作量大，復雜度高的數據。比如說，在人員管理系統中，你刪除一個人員，
你即需要刪除人員的基本資料，也要刪除和該人員相關的信息，如信箱，文章等等，這樣，這些數據庫操 作語句就構成一個事務！
1. 在 MySQL 中只有使用了 Innodb 數據庫引擎的數據庫或表才支持事務
2. 事務處理可以用來維護數據庫的完整性，保證成批的 SQL 語句要么全部執行，要么全部不執行
3. 事務用來管理 insert,update,delete 語句
一般來說，事務是必須滿足 4 個條件（ ACID ）： Atomicity （原子性）、 Consistency （穩定性）、 Isolation （隔離性）、 Durability （可靠性）
1. 事務的原子性：一組事務，要么成功；要么撤回。
2 、穩定性 ： 有非法數據（外鍵約束之類），事務撤回。
3 、隔離性：事務獨立運行。一個事務處理后的結果，影響了其他事務，那么其他事務會撤回。事務的
100% 隔離，需要犧牲速度。
4 、可靠性：軟、硬件崩潰后， InnoDB 數據表驅動會利用日志文件重構修改。可靠性和高速度不可兼
得， innodb_flush_log_at_trx_commit 選項 決定什么時候吧事務保存到日志里。
在 MySQL 控制臺使用事務來操作
1 ，開始一 個事務
start transaction
2, 做保存點
savepoint 保存點名稱
3, 操作
4 ，可以回滾，可以提交，沒有問題，就提交，有問題就回滾。
2. MySQL 索引
MySQL 索引的建立對于 MySQL 的高效運行是很重要的，索引可以大大提高 MySQL 的檢索速
度。
打個比方，如果合理的設計且使用索引的 MySQL 是一輛蘭博基尼的話，那么沒有設計和使用索引 的 MySQL 就是一個人力三輪車。
索引分單列索引和組合索引。單列索引，即一個索引只包含單個列，一個表可以有多個單列索
引，但這不是組合索引。組合索引，即一個索包含多個列。
創建索引時，你需要確保該索引是應用在 SQL 查詢語句的條件 ( 一般作為 WHERE 子句的條
件 ) 。
實際上，索引也是一張表，該表保存了主鍵與索引字段，并指向實體表的記錄。
上面都在說使用索引的好處，但過多的使用索引將會造成濫用。因此索引也會有它的缺點：雖然索
引大大提高了查詢速度，同時卻會降低更新表的速度，如對表進行 INSERT 、 UPDATE 和 DELETE 。因為更新表時， MySQL 不僅要保存數據，還要保存一下索引文件。
建立索引會占用磁盤空間的索引文件。
1. 普通索引
1. 創建索引
這是最基本的索引，它沒有任何限制。它有以下幾種創建方式：
CREATE INDEX indexName ON mytable(username(length));
如果是 CHAR ， VARCHAR 類型， length 可以小于字段實際長度；如果是 BLOB 和 TEXT 類型， 必須指定 length 。
2. 修改表結構
ALTER mytable ADD INDEX [indexName] ON (username(length))
3. 創建表的時候直接指定
CREATE TABLE mytable(
ID INT NOT NULL,
username VARCHAR(16) NOT NULL,
INDEX [indexName] (username(length))
);
4. 刪除索引的語法
DROP INDEX [indexName] ON mytable;
2. 唯一索引
它與前面的普通索引類似，不同的就是：索引列的值必須唯一，但允許有空值。如果是組合索引，則列值 的組合必須唯一。它有以下幾種創建方式：
1. 創建索引
REATE UNIQUE INDEX indexName ON mytable(username(length))
2. 修改表結構
ALTER mytable ADD UNIQUE [indexName] ON (username(length))
3. 創建表的時候直接指定
CREATE TABLE mytable(
ID INT NOT NULL,
username VARCHAR(16) NOT NULL,
UNIQUE [indexName] (username(length))
);
3. 使用 ALTER 命令添加和刪除索引
有四種方式來添加數據表的索引：
? ? 1. ALTER TABLE tbl_name ADD PRIMARY KEY (column_list): ? ? 該語句添加一個主鍵，這意味著索引值必須是唯一的，且不能為 NULL 。
? ? 2. ALTER TABLE tbl_name ADD UNIQUE index_name (column_list): ? ? 這條語句創建索引的值必須是唯一的（除了 NULL 外， NULL 可能會出現多次）。 ? ? 3. ALTER TABLE tbl_name ADD INDEX index_name (column_list): ? ? 添加普通索引，索引值可出現多次。
? ? 4. ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list): ? ? 該語句指定了索引為 FULLTEXT ，用于全文索引。
4. 顯示索引信息
你可以使用 SHOW INDEX 命令來列出表中的相關的索引信息。可以通過添加 \G 來格式化輸出
信息。
嘗試以下實例 :
mysql> SHOW INDEX FROM table_name\G ........
3. MySQL 臨時表
MySQL 臨時表在我們需要保存一些臨時數據時是非常有用的。臨時表只在當前連接可見，當關閉
連接時， MySQL 會自動刪除表并釋放所有空間。
臨時表在 MySQL 3.23 版本中添加，如果你的 MySQL 版本低于 3.23 版本就無法使用 MySQL 的
臨時表。不過現在一般很少有再使用這么低版本的 MySQL 數據庫服務了。
如果你使用了其他 MySQL 客戶端程序連接 MySQL 數據庫服務器來創建臨時表，那么只有在關閉客
戶端程序時才會銷毀臨時表，當然你也可以手動銷毀。
4. MySQL 處理重復數據
1). MySQL 處理重復數據
有些 MySQL 數據表中可能存在重復的記錄，有些情況我們允許重復數據的存在，但有時 候
我們也需要刪除這些重復的數據。
2). 防止表中出現重復數據
你可以在 MySQL 數據表中設置指定的字段為 PRIMARY KEY （主鍵） 或者 UNIQUE （唯一） 索
引來保證數據的唯一性。
讓我們嘗試一個實例：下表中無索引及主鍵，所以該表允許出現多條重復記錄。
CREATE TABLE person_tbl (
first_name CHAR(20), last_name CHAR(20), sex CHAR(10)
);
如果你想設置表中字段 first_name ， last_name 數據不能重復，你可以設置雙主鍵模式來設置數據的唯 一性， 如果你設置了雙主鍵，那么那個鍵的默認值不能為 NULL ，可設置為 NOT NULL 。如下所示：
CREATE TABLE person_tbl (
first_name CHAR(20) NOT NULL, last_name CHAR(20) NOT NULL, sex CHAR(10),
PRIMARY KEY (last_name, first_name)
);
如果我們設置了唯一索引，那么在插入重復數據時， SQL 語句將無法執行成功 , 并拋出錯。
INSERT IGNORE INTO 與 INSERT INTO 的區別就是 INSERT IGNORE 會忽略數據庫中已經存在的
數據，如果數據庫沒有數據，就插入新的數據，如果有數據的話就跳過這條數據。這樣就可以保留數據庫 中已經存在數據，達到在間隙中插入數據的目的。
以下實例使用了 INSERT IGNORE INTO ，執行后不會出錯，也不會向數據表中插入重復數據：
mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
-> VALUES( 'Jay', 'Thomas');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT IGNORE INTO person_tbl (last_name, first_name)
-> VALUES( 'Jay', 'Thomas');
Query OK, 0 rows affected (0.00 sec)
INSERT IGNORE INTO 當插入數據時，在設置了記錄的唯一性后，如果插入重復數據，將不返回錯 誤，只以警告形式返回。 而 REPLACE INTO into 如果存在 primary 或 unique 相同的記錄，則先刪
除掉。再插入新記錄。
另一種設置數據的唯一性方法是添加一個 UNIQUE 索引，如下所示：
CREATE TABLE person_tbl
(
first_name CHAR(20) NOT NULL,
last_name CHAR(20) NOT NULL,
sex CHAR(10)
UNIQUE (last_name, first_name)
);
3). 查詢重復記錄
select user_name,count(*) as count
from user_table
group by user_name having count>1;
select *
from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1)
4) . 統計重復數據
以下我們將統計表中 first_name 和 last_name 的重復記錄數：
mysql> SELECT COUNT(*) as repetitions, last_name, first_name
-> FROM person_tbl
-> GROUP BY last_name, first_name -> HAVING repetitions > 1;
以上查詢語句將返回 person_tbl 表中重復的記錄數。 一般情況下，查詢重復的值，請執行以下操作：
? ? 確定哪一列包含的值可能會重復。
? ? 在列選擇列表使用 COUNT(*) 列出的那些列。 ? ? 在 GROUP BY 子句中列出的列。 ? ? HAVING 子句設置重復數大于 1 。
5). 過濾重復數據
如果你需要讀取不重復的數據可以在 SELECT 語句中使用 DISTINCT 關鍵字來過濾重復數據。
mysql> SELECT DISTINCT last_name, first_name
-> FROM person_tbl
-> ORDER BY last_name;
你也可以使用 GROUP BY 來讀取數據表中不重復的數據：
mysql> SELECT last_name, first_name
-> FROM person_tbl
-> GROUP BY (last_name, first_name);
6). 刪除重復數據
如果你想刪除數據表中的重復數據，你可以使用以下的 SQL 語句： mysql> CREATE TABLE tmp SELECT last_name, first_name, sex
->? ?? ?? ?? ?? ? FROM person_tbl;
->? ?? ?? ?? ?? ? GROUP BY (last_name, first_name);
mysql> DROP TABLE person_tbl;
mysql> ALTER TABLE tmp RENAME TO person_tbl;
當然你也可以在數據表中添加 INDEX （索引） 和 PRIMAY KEY （主鍵）這種簡單的方法來刪除
表中的重復記錄。方法如下：
mysql> ALTER IGNORE TABLE person_tbl
-> ADD PRIMARY KEY (last_name, first_name);
5. MySQL 導出數據
MySQL 中你可以使用 SELECT...INTO OUTFILE 語句來簡單的導出數據到文本文件上。
1). 使用 SELECT ... INTO OUTFILE 語句導出數據
以下實例中我們將數據表 w3cschool_tbl 數據導出到 /tmp/tutorials.txt 文件中 :
mysql> SELECT * FROM tutorials_tbl -> INTO OUTFILE '/tmp/tutorials.txt';
你可以通過命令選項來設置數據輸出的指定格式，以下實例為導出 CSV 格式：
mysql> SELECT * FROM passwd INTO OUTFILE '/tmp/tutorials.txt'
-> FIELDS TERMINATED BY ',' ENCLOSED BY '"' -> LINES TERMINATED BY '\r\n';
在下面的例子中，生成一個文件，各值用逗號隔開。這種格式可以被許多程序使用。
SELECT a,b,a+b INTO OUTFILE '/tmp/result.text'
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' LINES TERMINATED BY '\n' FROM test_table;
2).SELECT ... INTO OUTFILE 語句有以下屬性 :
? ? LOAD DATA INFILE 是 SELECT ... INTO OUTFILE 的逆操作， SELECT 句法。為了將一個數據 庫的數據寫入一個文件，使用 SELECT ... INTO OUTFILE ，為了將文件讀回數據庫，使用 LOAD DATA INFILE 。
? ? SELECT...INTO OUTFILE 'file_name' 形式的 SELECT 可以把被選擇的行寫入一個文件中。該文
件被創建到服務器主機上，因此您必須擁有 FILE 權限，才能使用此語法。
? ? 輸出不能是一個已存在的文件。防止文件數據被篡改。
? ? 你需要有一個登陸服務器的賬號來檢索文件。否則 SELECT ... INTO OUTFILE 不會起任何作
用。
? ? 在 UNIX 中，該文件被創建后是可讀的，權限由 MySQL 服務器所擁有。這意味著，雖然你就可以
讀取該文件，但可能無法將其刪除。
3). 導出表作為原始數據
mysqldump 是 MySQL 用于轉存儲數據庫的實用程序。它主要產生一個 SQL 腳本，其中包含從頭重新 創建數據庫所必需的命令 CREATE TABLE INSERT 等。
使用 mysqldump 導出數據需要使用 --tab 選項來指定導出文件指定的目錄，該目標必須是可寫的。
以下實例將數據表 tutorials_tbl 導出到 /tmp 目錄中：
$ mysqldump -u root -p --no-create-info \
--tab=/tmp W3CSCHOOL w3cschool_tbl
password ******
4). 導出 SQL 格式的數據
導出 SQL 格式的數據到指定文件，如下所示：
$ mysqldump -u root -p W3CSCHOOL w3cschool_tbl > dump.txt password ******
以上命令創建的文件內容如下：
-- MySQL dump 8.23 --
-- Host: localhost? ???Database: W3CSCHOOL
--------------------------------------------------------- -- Server version? ?? ? 3.23.58
--
-- Table structure for table `w3cschool_tbl` --
CREATE TABLE w3cschool_tbl (
w3cschool_id int(11) NOT NULL auto_increment, w3cschool_title varchar(100) NOT NULL default '', w3cschool_author varchar(40) NOT NULL default '', submission_date date default NULL, PRIMARY KEY? ?(w3cschool_id),
UNIQUE KEY AUTHOR_INDEX (w3cschool_author)
) TYPE=MyISAM;
--
-- Dumping data for table `w3cschool_tbl`
--
INSERT INTO w3cschool_tbl
VALUES (1,'Learn PHP','John Poul','2007-05-24');
INSERT INTO w3cschool_tbl
VALUES (2,'Learn MySQL','Abdul S','2007-05-24');
INSERT INTO w3cschool_tbl
VALUES (3,'JAVA Tutorial','Sanjay','2007-05-06');
如果你需要導出整個數據庫的數據，可以使用以下命令：
$ mysqldump -u root -p W3CSCHOOL > database_dump.txt password ******
如果需要備份所有數據庫，可以使用以下命令：
$ mysqldump -u root -p --all-databases > database_dump.txt password ******
--all-databases 選項在 MySQL 3.23.12 及以后版本加入。
該方法可用于實現數據庫的備份策略。
5). 將數據表及數據庫拷貝至其他主機
如果你需要將數據拷貝至其他的 MySQL 服務器上 , 你可以在 mysqldump 命令中指定數據庫名
及數據表。
在源主機上執行以下命令，將數據備份至 dump.txt 文件中 :
$ mysqldump -u root -p database_name table_name > dump.txt password *****
如果完整備份數據庫，則無需使用特定的表名稱。
如果你需要將備份的數據庫導入到 MySQL 服務器中，可以使用以下命令，使用以下命令你需要確
認數據庫已經創建：
$ mysql -u root -p database_name < dump.txt password *****
你也可以使用以下命令將導出的數據直接導入到遠程的服務器上，但請確保兩臺服務器是
相通的，是可以相互訪問的： </p>
$ mysqldump -u root -p database_name \
| mysql -h other-host.com database_name
以上命令中使用了管道來將導出的數據導入到指定的遠程主機上。
6. MySQL 導入數據
MySQL 中可以使用兩種簡單的方式來導入 MySQL 導出的數據。
使用 LOAD DATA 導入數據
MySQL 中提供了 LOAD DATA INFILE 語句來插入數據。 以下實例中將從當前目錄中讀取文件 dump.txt ，將該文件中的數據插入到當前數據庫的 mytbl 表中。
mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl;
如果指定 LOCAL 關鍵詞，則表明從客戶主機上按路徑讀取文件。如果沒有指定，則文件在服務器上按路
徑讀取文件。
你能明確地在 LOAD DATA 語句中指出列值的分隔符和行尾標記，但是默認標記是定位符和換行符。 兩個命令的 FIELDS 和 LINES 子句的語法是一樣的。兩個子句都是可選的，但是如果兩個同時被指 定， FIELDS 子句必須出現在 LINES 子句之前。
如果用戶指定一個 FIELDS 子句，它的子句 （ TERMINATED BY 、 [OPTIONALLY] ENCLOSED BY 和 ESCAPED BY) 也是可選的，不過，用戶必須至少指定它們中的一個。
mysql> LOAD DATA LOCAL INFILE 'dump.txt' INTO TABLE mytbl
-> FIELDS TERMINATED BY ':' -> LINES TERMINATED BY '\r\n';
LOAD DATA 默認情況下是按照數據文件中列的順序插入數據的，如果數據文件中的列與插入表中的列
不一致，則需要指定列的順序。
如，在數據文件中的列順序是 a,b,c ，但在插入表的列順序為 b,c,a ，則數據導入語法如下：
mysql> LOAD DATA LOCAL INFILE 'dump.txt'
-> INTO TABLE mytbl (b, c, a);
使用 mysqlimport 導入數據
mysqlimport 客戶端提供了 LOAD DATA INFILEQL 語句的一個命令行接口。 mysqlimport 的大多數 選項直接對應 LOAD DATA INFILE 子句。
從文件 dump.txt 中將數據導入到 mytbl 數據表中 , 可以使用以下命令：
$ mysqlimport -u root -p --local database_name dump.txt password *****
mysqlimport 命令可以指定選項來設置指定格式 , 命令語句格式如下：
$ mysqlimport -u root -p --local --fields-terminated-by=":" \ --lines-terminated-by="\r\n" database_name dump.txt
password *****
mysqlimport 語句中使用 --columns 選項來設置列的順序：
$ mysqlimport -u root -p --local --columns=b,c,a \
database_name dump.txt
password *****
mysqlimport 的常用選項介紹
選項? ?? ?? ?? ?? ? 功能
-d or --delete? ?? ?? ?? ???新數據導入數據表中之前刪除數據數據表中的所有信息
-f or --force? ?? ?? ?? ?? ?? ???不管是否遇到錯誤， mysqlimport 將強制繼續插入數據
-i or --ignore? ?? ?? ?? ???mysqlimport 跳過或者忽略那些有相同唯一 關鍵字的行， 導入文件
中的數據將被忽略。
-l or -lock-tables? ?? ?? ?? ?? ? 數據被插入之前鎖住表，這樣就防止了， 你在更新數據庫時，
用戶的查詢和更新受到影響。
-r or -replace? ?? ?? ?? ???這個選項與－ i 選項的作用相反；此選項將替代
表中有相同唯一關鍵字的記錄。
--fields-enclosed- by= char? ?? ?指定文本文件中數據的記錄時以什么括起的，
很多情況下 數據以雙引號括起。
默認的情況下數據是沒有被字符括起的。
--fields-terminated- by=char? ? 指定各個數據的值之間的分隔符，在句號分隔的文件中，
分隔符是句號。您可以用此選項指定數據之間的分隔符。 默認的分隔符是跳格符（ Tab ）
--lines-terminated- by=str 此選項指定文本文件中行與行之間數據的分隔字符串
或者字符。
默認的情況下 mysqlimport 以 newline 為行分隔符。 您可以選擇用一個字符串來替代一個單個的字符： 一個新行或者一個回車。
mysqlimport 命令? ?? ?常用的選項還有 -v 顯示版本（ version ）， -p 提示輸入密碼（ password ）
等。
7. 存儲過程
1). 創建存儲過程
1>. 基本語法：
create procedure sp_name() begin ………
end
2>. 參數傳遞
2) 調用存儲過程
基本語法： call sp_name()
注意：存儲過程名稱后面必須加括號，哪怕該存儲過程沒有參數傳遞
3). 刪除存儲過程 1>. 基本語法：
drop procedure sp_name//
2>. 注意事項
(1) 不能在一個存儲過程中刪除另一個存儲過程，只能調用另一個存儲過程
4 . 區塊，條件，循環
1). 區塊定義，常用
begin ……
end;
也可以給區塊起別名，如： lable:begin ………..
end lable;
可以用 leave lable; 跳出區塊，執行區塊以后的代碼
2). 條件語句
if 條件 then statement else
statement end if;
3). 循環語句
(1).while 循環
[label:] WHILE expression DO statements
END WHILE [label] ;
(2).loop 循環 [label:] LOOP statements
END LOOP [label];
(3).repeat until 循環 [label:] REPEAT statements
UNTIL expression
END REPEAT [label] ;
5 . 其他常用命令
1).show procedure status
顯示數據庫中所有存儲的存儲過程基本信息，包括所屬數據庫，存儲過程名稱，創建時間等
2).show create procedure sp_name 顯示某一個存儲過程的詳細信息
Oracle 數據庫
1. 對索引的理解：
1 、索引相當于字典的目錄，作用在于提升查詢效率，降低磁盤讀寫，提升數據庫性能 2 、索引是一種獨立于表的數據庫對象，可以存儲在于表不同的磁盤中間或表空間
3 、索引一旦創建，由 oracle 數據庫自己來維護，并且由 oracle 管理系統來指定何時使用索引，我們不需要 在查詢語句中自己指定索引
4 、索引的刪除或損毀不會對數據庫表帶來影響，只會影響查詢效率 5 、創建索引的時候，如果沒有指定表空間，會存儲到默認的表空間 6 、在刪除表的時候，基于表的索引會被刪除
2. 索引工作原理
創建索引的時候， oracle 會先在表空間中給索引開辟一個空間，并按索引字段對應的值進行分組，并把分 好組的地址 rowid 存入索引空間中，當再次查詢的時候，數據庫會自動判斷查詢的條件中是否建有索引， 如果有，則根據索引去查詢符合條件的數據
3. 索引的創建
兩種： 1. 自動創建 -------- 即在創建主鍵 primarykey 或唯一性約束 unique 的時候，
數據庫會自動在相應的列上? ?創建唯一性索引
一般業務過程中通過主鍵查詢比較頻繁，提升查詢效率
2. 手動創建 -------- 即在不唯一的列上創建非唯一的索引，加速查詢效率 create index index_xxx_xxx on 表（創建索引的列） tablespace 表空間（表空間
可以不指定）工具創建
4. 索引的弊端：
一般在數據量比較大的表中并且經常查詢的字段上才去建立索引，數據量小或不經常查詢的字段建立
索引的話，不僅會占用內存空間，而且會降低查詢效率，索引不是越多越好，
下列情形不要創建索引
1 、表很小
2 、列不經常作為連接條件的 3 、表經常更新的
系統日志歷史表必須增加索引，效率超高?
5. 執行計劃 explain plan
作用：查詢索引是否生效以及預估索引性能效果等 方式： 1 、 explain plan window 窗口
2 、對查詢語句按 f5
6. 數據字典
主要存儲的是數據庫系統信息，由數據庫系統自己去維護管理，一般我們只進行查詢，不做修改
7. Pl/sql
是 oracle 對 sql 語言的過程化擴張，是存儲過程的基礎 組成：聲明部分、可執行部分、異常處理部分
普通變量、引用變量 (%type) 、記錄型變量（ %rowtype ）
1 ， 使用引用類型，當列中的數據類型發生改變，不需要修改變列的類型。而使用普通方式，當列的類型
改變時，需要修改變列的類型
使用 %TYPE 是非常好的編程風格，因為它使得 PL/SQL 更加靈活，更加適應于對數據庫定義的更新。
8. 游標 cursor
可以理解為數據庫表返回的結果集，它帶有向前移動的指針，并且每次只向前移動一行數據 作用：可以臨時存儲返回的多行數據，通過變量游標，可以得到每一行的數據
9. 存儲過程 program window--procedure
定義： 是一組預編譯的 sql 語句，也就是給 plsql 語句包裝起來，完成一次創建任意調用的功能，相當于 java 中的方法
作用：在開發中，有時候為了某種特定的業務功能，需要對數據庫進行多次的連接關閉，這種連接關閉是 很耗費資源的，并且會對數據庫進行多次的 io 讀寫，性能比較低，如果把業務功能放在 plsql 中，只需要
連接關閉一次數據庫就可以實現我們的業務功能，大大提高了效率
2 、更好的安全機制，對于沒有權限執行存儲過程的用戶，也可以授權他們執行存儲過程 3 、對應大量的 sql 語句和重復執行的 sql 語句，存儲過程執行要快 =
參數：
不帶參數的、帶輸入參數的。帶輸入輸出參數的
關于寫存儲的 3 個窗口的選擇：
預發布的時候使用 command 測試使用 test
10. 存儲過程和存儲函數的區別：
1 、存儲過程可以有返回值也可以沒有返回值，存儲函數必須有返回值 2 、存儲過程和存儲函數都可以通過輸出參數 out 實現多個返回值 怎么選擇：
原則上只有一個返回值的用存儲函數，否則用存儲過程 但是我們一般都使用存儲過程，因為
1 、存儲過程可以有返回值也可以沒有返回值，存儲的靈活性 2 、存儲過程既然有返回值了，可以替代存儲函數 3 、 Oracle 新版中已經不推薦適用存儲函數了
Java 中通過 CallableStatement 調用存儲過程
11. 觸發器：
解釋：
1 、是一段 plsql 程序
2 、它用來觸發 dml(insert 、 update 、 delete) 操作的 3 、在進行 dml 操作時會自動觸發執行的一段程序
換句話說：觸發器就是在執行某個操作（增刪改）的時候觸發一個動作 ( 一段程序 ) 。 有點像 struts2 的攔截器，可以對 cud 增強
觸發器類型
1 、語句級觸發器（表級觸發器）
在指定的操作語句執行之前或之后執行一次，不管它影響了多少行
2 、行級觸發器（ for each row ）
觸發語句作用都的每一條語句都會被觸發
數據庫三范式是什么 ?
第一范式（ 1NF ）：
字段具有原子性 , 不可再分。所有關系型數據庫系統都滿足第一范式）
數據庫表中的字段都是單一屬性的，不可再分。例如，姓名字段，其中的姓和名必須作為一個整體，無法 區分哪部分是姓，哪部分是名，如果要區分出姓和名，必須設計成兩個獨立的字段。
第二范式（ 2NF ）：
第二范式（ 2NF ）是在第一范式（ 1NF ）的基礎上建立起來的，即滿足第二范式（ 2NF ）必須先滿
足第一范式（ 1NF ）。
要求數據庫表中的每個實例或行必須可以被惟一地區分。通常需要為表加上一個列，以存儲各個實例的惟 一標識。這個惟一屬性列被稱為主關鍵字或主鍵。
第二范式（ 2NF ）要求實體的屬性完全依賴于主關鍵字。所謂完全依賴是指不能存在僅依賴主關鍵字一部 分的屬性，如果存在，那么這個屬性和主關鍵字的這一部分應該分離出來形成一個新的實體，新實體與原 實體之間是一對多的關系。為實現區分通常需要為表加上一個列，以存儲各個實例的惟一標識。簡而言 之，第二范式就是非主屬性非部分依賴于主關鍵字。
第三范式的要求如下：
滿足第三范式（ 3NF ）必須先滿足第二范式（ 2NF ）。簡而言之，第三范式（ 3NF ）要求一個數據庫
表中不包含已在其它表中已包含的非主關鍵字信息。
所以第三范式具有如下特征： 1 ，每一列只有一個值 2 ，每一行都能區分。 3 ，每一個表都不包含其他表 已經包含的非主關鍵字信息。
例如，帖子表中只能出現發帖人的 id ，而不能出現發帖人的 id ，還同時出現發帖人姓名，否則，只要出現 同一發帖人 id 的所有記錄，它們中的姓名部分都必須嚴格保持一致，這就是數據冗余。
Struts2
1.1Struts2 的六個基本包
struts2-core-2.1.6.jar ：開發的核心類庫
freemarker-2.3.13.jar ： struts2 的 UI 標簽的模板使用 freemarker 編寫 commons-logging-1.0.4.jar ：日志包
ognl-2.6.11.jar ：對象圖導航語言，通過它來讀寫對象屬性 xwork-2.1.2.jar ： xwork 類庫， struts2 在其上進行構建
commons-fileupload-1.2.1.jar ：文件上傳組件， 2.1.6 版本后必須加入此 jar 包
1.2struts2 配置文件
（ 1 ）． web.xml 文件 主要完成對 StrutsPrepareAndExecuteFilter 的配置（在以前的版本中 是對 FilterDispatcher 配置，新版本同樣支持用 FilterDispatcher 配置），它的實質是一個過濾 器，它負責初始化整個 Struts 框架并且處理所有的請求。這個過濾器可以包括一些初始化參 數，有的參數指定了要加載哪些額外的 xml 配置文件，還有的會影響 struts 框架的行為。除 了 StrutsPrepareAndExecuteFilter 外， Struts 還提供了一個 ActionContexCleanUp 類，它的主 要任務是當有其它一些過濾器要訪問一個初始化好了的 struts 框架的時候，負責處理一些特 殊的清除任務。
（ 2 ）． struts.xml 文件? ? 框架的核心配置文件就是這個默認的 struts.xml 文件，在這個默認 的配置文件里面我們可以根據需要再包括其它一些配置文件。在通常的應用開發中，我們可
能想為每個不同的模塊單獨配置一個 struts.xml 文件，這樣也利于管理和維護。這也是我們 要配置的主要文件。
（ 3 ）． struts.properties （參 default.properties ） 在 Struts 框架使用了很多屬性，我們可以 通過改變這些屬性來滿足我們的需求。要改變這些屬性，只需在 struts.properties 文件中指 定屬性的 key 和 value 即可。屬性文件可以放在任何一個包含在 classpath 中的路徑上，但 是通常我們都把它放在 /WEB-INF/classes 目錄下面。我們可以在 struts-default.properties 文 件中找到一個屬性的列表。
（ 4 ） struts-default.xml 此文件是 struts2 框架默認加載的配置文件，它定義了 struts2 一 些核心 bean 和攔截器，它會自動包含 (included) 到 struts.xml 文件中 ( 實質是通過 <package extends="struts-default">) ，并為我們提供了一些標準的配置。我們可以在 struts2-core.jar 中找到這個文件。
1.3Struts2 常用注解
@ParentPackage ：定父包
@namespace?：指定命名空間 @Results ：一組結果的數組
@Result(name="success",location="/msg.jsp") ： 一個結果的映射（注意沒有 s ）
@Action(value="login") ：指定某個請求處理方法的請求 URL 。注意，它不能添加在 Action 類 上，要添加到方法上。
@ExceptionMappings ：一級聲明異常的數組
@ExceptionMapping ： 映射一個聲明異常自定義注解攔截器權限控制
1.4struts2 工作流程
Struts 2 框架本身大致可以分為 3 個部分：
核心控制器 FilterDispatcher 、業務控制器 Action 和用戶實現的企業業務邏輯組件。
核心控制器 FilterDispatcher 是 Struts 2 框架的基礎， 包含了框架內部的控制流程和處理機制。
業務控制器 Action 和業務邏輯組件是需要用戶來自己實現的。
用戶在開發 Action 和業務邏輯組件的同時，還需要編寫相關的配置文件， 供核心控制器 FilterDispatcher 來使用。
Struts 2 的工作流程相對于 Struts 1 要簡單，與 WebWork 框架基本相同， 所以說 Struts 2 是 WebWork 的升級版本。基本簡要流程如下： 1 、客戶端初始化一個指向 Servlet 容器的請求； 2 、 這個請求經過一系列的過濾器（ Filter ）
（這些過濾器中有一個叫做 ActionContextCleanUp 的可選過濾器，
這個過濾器對于 Struts2 和其他框架的集成很有幫助，例如： SiteMesh Plugin ） 3 、接著 FilterDispatcher 被調用，
FilterDispatcher 詢問 ActionMapper 來決定這個請是否需要調用某個 Action 4 、如果 ActionMapper 決定需要調用某個 Action ， FilterDispatcher 把請求的處理交給 ActionProxy
5 、 ActionProxy 通過 Configuration Manager 詢問框架的配置文件， 找到需要調用的 Action 類
6 、 ActionProxy 創建一個 ActionInvocation 的實例。 7 、 ActionInvocation 實例使用命名模式來調用，
在調用 Action 的過程前后，涉及到相關攔截器（ Intercepter ）的調用。
8 、一旦 Action 執行完畢， ActionInvocation 負責根據 struts.xml 中的配置找到對應的返回 結果。返回結果通常是（但不總是，也可 能是另外的一個 Action 鏈）一個需要被表示的 JSP 或者 FreeMarker 的模版。在表示的過程中可以使用 Struts2 框架中繼承的標簽。在這個 過程中需要涉及到 ActionMapper
9 、響應的返回是通過我們在 web.xml 中配置的過濾器
10 、如果 ActionContextCleanUp 是當前使用的，則 FilterDispatecher 將不會清理 sreadlocal ActionContext; 如果 ActionContextCleanUp 不使用，則將會去清理 sreadlocals 。
1.5Struts2 問題合集
1.5.1 、說下 Struts 的設計模式
MVC 模式 : web 應用程序啟動時就會加載并初始化 ActionServler 。用戶提交表單時，一個 配置好的 ActionForm 對象被創建，并被填入表單相應的數據， ActionServler 根據 Struts- config.xml 文件配置好的設置決定是否需要表單驗證，如果需要就調用 ActionForm 的 Validate （）驗證后選擇將請求發送到哪個 Action ，如果 Action 不存在， ActionServlet 會 先創建這個對象，然后調用 Action 的 execute （）方法。 Execute （）從 ActionForm 對象 中獲取數據，完成業務邏輯，返回一個 ActionForward 對象， ActionServlet 再把客戶請求 轉發給 ActionForward 對象指定的 jsp 組件， ActionForward 對象指定的 jsp 生 成動態的網頁，返回給客戶。
1.5.2 、攔截器和過濾器的區別
1 、攔截器是基于 java 反射機制的，而過濾器是基于函數回調的。 2 、過濾器依賴于 servlet 容器，而攔截器不依賴于 servlet 容器。
3 、攔截器只能對 Action 請求起作用，而過濾器則可以對幾乎所有請求起作用。
4 、攔截器可以訪問 Action 上下文、值棧里的對象，而過濾器不能。
5 、在 Action 的生命周期中，攔截器可以多次調用，而過濾器只能在容器初始化時被調用一次。
1.5.3struts2 有哪些優點？
1 ）在軟件設計上 Struts2 的應用可以不依賴于 Servlet API 和 struts API 。
Struts2 的這種設計屬于無侵入式設計；
2 ）攔截器，實現如參數攔截注入等功能；
3 ）類型轉換器，可以把特殊的請求參數轉換成需要的類型；
4 ）多種表現層技術，如： JSP 、 freeMarker 、 Velocity 等；
5 ） Struts2 的輸入校驗可以對指定某個方法進行校驗；
6 ）提供了全局范圍、包范圍和 Action 范圍的國際化資源文件管理實現
1.5.4struts2 框架的核心控制器是什么？它有什么作用？
1 ） Struts2 框架的核心控制器是 StrutsPrepareAndExecuteFilter 。
2 ）作用：
負責攔截由 <url-pattern>/*</url-pattern> 指定的所有用戶請求，當用戶請求到
達時，該 Filter 會過濾用戶的請求。默認情況下，如果用戶請求的路徑
不帶后綴或者后綴以 .action 結尾，這時請求將被轉入 struts2 框架處理，否則
struts2 框架將略過該請求的處理。
可以通過常量 "struts.action.extension" 修改 action 的后綴，如：
<constant name="struts.action.extension" value="do"/>
如果用戶需要指定多個請求后綴，則多個后綴之間以英文逗號（ , ）隔開。
<constant name="struts.action.extension" value="do,go"/>
1.5.5struts2 默認能解決 get 和 post 提交方式的亂碼問題嗎？
不能。 struts.i18n.encoding=UTF-8 屬性值只能解析 POST 提交下的亂碼問題。
1.5.6 值棧 ValueStack 的原理與生命周期？
1 ） ValueStack 貫穿整個 Action 的生命周期，保存在 request 域中，所以
ValueStack 和 request 的生命周期一樣。當 Struts2 接受一個請求時，會迅速創
建 ActionContext ，
ValueStack ， action 。然后把 action 存放進 ValueStack ，所以 action 的實例變量
可以被 OGNL 訪問。 請求來的時候， action 、 ValueStack 的生命開始，請求結
束， action 、 ValueStack 的生命結束；
2 ） action 是多例的，和 Servlet 不一樣， Servelt 是單例的；
3 ）每個 action 的都有一個對應的值棧，值棧存放的數據類型是該 action 的實
例，以及該 action 中的實例變量， Action 對象默認保存在棧頂；
4 ） ValueStack 本質上就是一個 ArrayList ；
5 ）關于 ContextMap ， Struts 會把下面這些映射壓入 ContextMap 中：
parameters : 該 Map 中包含當前請求的請求參數
request : 該 Map 中包含當前 request 對象中的所有屬性 session : 該 Map 中
包含當前 session 對象中的所有屬性
application : 該 Map 中包含當前 application 對象中的所有屬性
attr: 該 Map 按如下順序來檢索某個屬性 : request, session, application
6 ）使用 OGNL 訪問值棧的內容時，不需要 # 號，而訪問 request 、 session 、
application 、 attr 時，需要加 # 號；
7 ）注意： Struts2 中， OGNL 表達式需要配合 Struts 標簽才可以使用。如：
<s:property value="name"/>
8 ）在 struts2 配置文件中引用 ognl 表達式 , 引用值棧的值 ，此時使用的 "$" ，
而不是 # 或者 %;
1.5.7ActionContext 、 ServletContext 、 pageContext 的區別？
1 ） ActionContext 是當前的 Action 的上下文環境，通過 ActionContext 可以獲
取到 request 、 session 、 ServletContext 等與 Action 有關的對象的引用；
2 ） ServletContext 是域對象，一個 web 應用中只有一個 ServletContext ，生命
周期伴隨整個 web 應用；
3 ） pageContext 是 JSP 中的最重要的一個內置對象，可以通過 pageContext 獲
取其他域對象的應用，同時它是一個域對象，作用范圍只針對當前頁面，當前 頁面結束時， pageContext 銷毀，
生命周期是 JSP 四個域對象中最小的。
1.5.8result 的 type 屬性中有哪幾種結果類型？
一共 10 種： dispatcher
struts 默認的結果類型，把控制權轉發給應用程序里的某個資源不能把控制權轉發給一個外 部資源，若需要把控制權重定向到一個外部資源 , 應該使用 redirect 結果類型
redirect 把響應重定向到另一個資源（包括一個外部資源） redirectAction 把響應重定向到另一個 Action
freemarker 、 velocity 、 chain 、 httpheader 、 xslt 、 plainText 、 stream
1.5.9servlet 和 filter 的區別
Filter 可認為是 Servlet 的一種“變種”，它主要用于對用戶請求進行預處理，
也可以對 HttpServletResponse 進行后處理，是個典型的處理鏈。它與 Servlet 的區別在于：它不能直接向用戶生成響應。完整的流程是： Filter 對用戶請求進 行預處理，接著將請求交給 Servlet 進行處理并生成響應，最后 Filter 再對服 務器響應進行后處理。
Hibernate
2.1Hibernate 的 jar 包
最基本的 Hibernate3.3.2 之 JAR 包（必要）：
hibernate3.jar? ???核心 JAR 包
antlr.jar? ???Another Tool for Language Recognition ，可以構造語言識別器，解析
HQL 需要
commons-collections.jar? ? 包含了一些 Apache 開發的集合類，功能比 Java .util.*
強大
dom4j.jar? ?越來越多的 Java 軟件都在使用 dom4j 來操作 XML ， Hibernate 也不
例外
javassist.jar? ?操作字節碼，跟 cglib 相關
jta.jar? ? 定義 JTA 規范的 JAR 包，當 Hibernate 使用 JTA 的時候需要
slf4j.jar? ? 整合各志框架種日的工具
slf4j-nop.jar? ???包含了對 slf4j.jar 的實現類
2.2Hibernate 的核心配置文件
Hibernate 框架支持 properties 和 xml 兩種方式的 Hibernate 屬性的配置，對應的兩種核心 配置文件為：
hibernate.properties 配置常用的屬性 , 必須手動加載 hbm 文件或持久化類。（了解） hibernate.cfg.xml 配置常用的屬性 , 配置加載 hbm 映射 , 配置緩存策略等。（推薦）
2.3Hibernate 的核心 API 接口
所有的 Hibernate 應用中都會訪問 Hibernate 的 5 個核心接口。
Configuration 接口：配置 Hibernate, 根啟動 Hibernate ，創建 SessionFactory 對象。 SessionFactory 接口：初始化 Hibernate ，充當數據存儲源的代{過}{濾}理，創建 Session 對象。 Session 接口：負責保存、更新、刪除、加載和查詢對象。 Transaction 接口：管理事務。
Query 和 Criteria 接口：執行數據庫查詢。
2.3.1 Configuration 接口
Configuration 對象用于配置并且啟動 Hibernate 。 Hibernate 應用通過 Configuration 實例來 指定對象 - 關系映射文件的位置或者動態配置 Hibernate 的屬性，然后創建 SessionFactory 實 例。
2.3.2 SessionFactory 接口
一個 SessionFactory 實例對應一個數據存儲源，應用從 SessionFactory 中獲得 Session 實例。 SessionFactory 有以下特點：
它是線程安全的，這意味著它的同一個實例可以被應用的多個線程共享。
它是重量級的，這意味著不能隨意創建或銷毀它的實例。如果應用只訪問一個數據庫，只需 要創建一個 SessionFactory 實例，在應用初始化的時候創建該實例。如果應用同時訪問多個 數據庫，則需要為每個數據庫創建一個單獨的 SessionFactory 實例。
之所以稱 SessionFactory 是重量級的，是因為它需要一個很大的緩存，用來存放預定義的 SQL 語句以能映射元數據等。用戶還可以為 SesionFactory 配置一個緩存插件，這個緩存插 件被稱為 Hibernate 的第二級緩存。，該緩存用來存放被工作單元讀過的數據，將來其他工 作單元可能會重用這些數據，因此這個緩存中的數據能夠被所有工作單元共享。一個工作單 元通常對應一個數據庫事務。
2.3.3 Session 接口
Session 接口是 Hibernate 應用使用最廣泛的接口。 Session 也被稱為持久化管理器，它提供 了和持久化相關的操作，如添加、更新、刪除、加載和查詢對象。 Session 有以下特點：
不是線程安全的，因此在設計軟件架構時，應該避免多個線程共享同一個 Session 實例。 Session 實例是輕量級的，所謂輕量級，是指它的創建和銷毀不需要消耗太多的資源。這意 味著在程序中可以經常創建和銷毀 Session 對象，例如為每個客戶請示分配單獨的 Session 實例，或者為每個工作單元分配單獨的 Session 實例。
Session 有一個緩存，被稱為 Hibernate 的第一級緩存，它存放被當前工作單元加載的對象。 每個 Session 實例都有自己的緩存，這個 Sesion 實例的緩存只能被當前工作單元訪問。
2.3.4Transaction 接口
Transaction 接口是 Hibernate 的數據庫事務接口，它對底層的事務接口做了封裝，底層事務 接口包括：
JDBC API 、 JTA （ Java Transaction API ）、 CORBA （ Common Object Requet Broker Architecture ） API
Hibernate 應用可通過一致的 Transaction 接口來聲明事務邊界，這有助于應用在不同的環境 容器中移植。盡管應用也可以繞過 Transaction 接口，直接訪問底層的事務接口，這種方法 不值得推薦，因為它不利于應用在不同的環境移植。
2.3.5Query 和 Criteria 接口
Query 和 Criteria 接口是 Hibernate 的查詢接口，用于向數據庫查詢對象，以及控制執行查 詢的過程。 Query 實例包裝了一個 HQL 查詢語句， HQL 查詢語句和 SQL 查詢語句有些相似， 但 HQL 查詢語句是面向對象的，它引用類句及類的屬性句，而不是表句及表的字段句。 Criteria 接口完全封裝了基于字符串的查詢語句，比 Query 接口更加面向對象， Criteria 接口 擅長執行動態查詢。
Session 接口的 find （）方法也具有數據查詢功能，但它只是執行一些簡單的 HQL 查詢語句 的快捷方法，它的功能遠沒有 Query 接口強大。
2.4hibernate 常用注解
@entity?：聲明實體 bean ，每一個持久化 POJO 類都是一個實體 bean, 這可以通過在類的定 義中使用 @Entity 注解來進行聲明 :
@Id ：注解則聲明了該實體 bean 的標識屬性，對應相應表使用 id 列作為主鍵列
@Table?： 是 類 一 級 的 注 解 , 通 過 @Table 注 解 可 以 為 實 體 bean 映 射 指 定 表 (table), 目 錄 (catalog) 和 schema 的名字 . 如果沒有定義 @Table, 那么系統自動使用默認值：實體的短類名 ( 不附帶包名 ).
@Transient ：實體 bean 中所有的非 static 非 transient 的屬性都可以被持久化 , 除非你將其 注解為 @Transient ，所有沒有定義注解的屬性等價于在其上面添加了 @Basic 注解 . @GeneratedValue ：定義該標識符的生成策略
AUTO - 可以是 identity column 類型 , 或者 sequence 類型或者 table 類型 , 取決于不同的底層 數據庫 .
TABLE - 使用表保存 id 值 IDENTITY - identity column SEQUENCE - sequence
@OneToOne 注解可以建立實體 bean 之間的一對一的關聯 . @ManyToOne 注解來定義多對一關聯
2.5 Hibernate 的執行流程
1. 通過 Configuration.configure() 讀取并解析 hibernate.cfg.xml 配置文件；
2. 由 hibernate.cfg.xml 中的 <mapping resource= ” com/xx/User.hbm.xml ” /> 讀取并解析映 射信息；
3. 通過 config.buildSerssionFactory() 創建 SessionFactory; 4.sessionFactory.openSession() 打開 session ； 5.session.beginTransaction() 創建事務 transation ； 6.persistent operate （持久化操作）；
7.session.getTransaction().commit() 提交事務； 8. 關閉 session;
9. 關閉 SessionFactory 。
2.6Hibernate 問題合集
2.6.1Hibernate 中 get 和 load 有什么不同之處 ?
把 get 和 load 放到一起進行對比是 Hibernate 面試時最常問到的問題，這是因為只有正確 理解 get() 和 load() 這二者后才有可能高效地使用 Hibernate 。 get 和 load 的最大區別是，如 果在緩存中沒有找到相應的對象， get 將會直接訪問數據庫并返回一個完全初始化好的對象， 而這個過程有可能會涉及到多個數據庫調用；而 load 方法在緩存中沒有發現對象的情況下， 只會返回一個代{過}{濾}理對象，只有在對象 getId() 之外的其它方法被調用時才會真正去訪問數據 庫，這樣就能在某些情況下大幅度提高性能。你也可以參考 Hibernate 中 get 和 load 的不 同之處， 此鏈接給出了更多的不同之處并對該問題進行了更細致的討論。
2.6.2Hibernate 中 save 、 persist 和 saveOrUpdate 這三個方法的不同之處？
除了 get 和 load ，這又是另外一個經常出現的 Hibernate 面試問題。 所有這三個方法，也 就是 save() 、 saveOrUpdate() 和 persist() 都是用于將對象保存到數據庫中的方法，但其中有些 細微的差別。例如， save() 只能 INSERT 記錄，但是 saveOrUpdate() 可以進行 記錄的 INSERT 和 UPDATE 。還有， save() 的返回值是一個 Serializable 對象，而 persist() 方法返回值為 void 。 你還可以訪問 save 、 persist 以及 saveOrUpdate ，找到它們所有的不同之處。
2.6.3Hibernate 中的命名 SQL 查詢指的是什么 ?
Hibernate 的 這個面試問題同 Hibernate 提供的查詢功能相關。命名查詢指的是用 <sql- query> 標簽在影射文檔中定義的 SQL 查詢，可以通過使用 Session.getNamedQuery() 方法對 它進行調用。命名查詢使你可以使用你所指定的一個名字拿到某個特定的查詢。 Hibernate
中的 命名查詢可 以使用注解來 定義，也可 以使用我前面 提到的 xml 影 射問句來 定義。在 Hibernate 中， @NameQuery 用來定義單個的命名查詢， @NameQueries 用來定義多個命名 查詢。
2.6.4Hibernate 中的 SessionFactory 有什么作用 ? SessionFactory 是線程安全的嗎？
這 也 是 Hibernate 框 架 的 常 見 面 試 問 題 。 顧 名 思 義 ， SessionFactory 就 是 一 個 用 于 創 建 Hibernate 的 Session 對象的工廠。 SessionFactory 通常是在應用啟動時創建好的，應用程序 中的代碼用它來獲得 Session 對象。作為一個單個的數據存儲，它也是 線程安全的，所以多 個線程可同時使用同一個 SessionFactory 。 Java JEE 應用一般只有一個 SessionFactory ，服務 于 客 戶 請 求 的 各 線 程 都 通 過 這 個 工 廠 來 獲 得 Hibernate 的 Session 實 例 ， 這 也 是 為 什 么 SessionFactory 接口的實現必須是線程安全的原因。還有， SessionFactory 的內部狀態包含著 同對象關系影射有關的所有元數據，它是 不可變的，一旦創建好后就不能對其進行修改了。
2.6.5Hibernate 中的 Session 指的是什么 ? 可否將單個的 Session 在多個線程間進行共享？
前面的問題問完之后，通常就會接著再問這兩個問題。問完 SessionFactory 的問題后就該輪 到 Session 了。 Session 代表著 Hibernate 所做的一小部分工作，它負責維護者同數據庫的鏈 接而且 不是線程安全的，也就是說， Hibernage 中的 Session 不能在多個線程間進行共享。 雖然 Session 會以主動滯后的方式獲得數據庫連接，但是 Session 最好還是在用完之后立即 將其關閉。
2.6.6Hibernate 中二級緩存指的是什么？
這是同 Hibernate 的緩存機制相關的第一個面試問題，不出意外后面還會有更多這方面的問 題。二級緩存是在 SessionFactory 這個級別維護的緩存，它能夠通過節省幾番數據庫調用往 返來提高性能。還有一點值得注意，二級緩存是針對整個應用而不是某個特定的 session 的。
2.6.7Hibernate 中的查詢緩存指的是什么？
這個問題有時是作為上個 Hibernate 面試問題的后繼問題提出的。查詢緩存實際上保存的是 sql 查詢的結果，這樣再進行相同的 sql 查詢就可以之間從緩存中拿到結果了。為了改善性 能，查詢緩存可以同二級緩存一起來使用。 Hibernate 支持用多種不同的開源緩存方案，比 如 EhCache ，來實現查詢緩存。
Spring
3.1Spring 常用 jar 包
1. spring.jar 是包含有完整發布模塊的單個 jar 包。
2. org.springframework.aop 包含在應用中使用 Spring 的 AOP 特性時所需的類。
3. org.springframework.aspects 提供對 AspectJ 的支持，以便可以方便的將面向方面的功能 集成進 IDE 中，
比如 Eclipse AJDT 。
4. org.springframework.beans 所有應用都要用到的，它包含訪問配置文件、創建和管理 bean 以及進行 Inversion of Control / Dependency Injection （ IoC/DI ）操作相關的所有類。 5. org.springframework.context 為 Spring 核 心 提 供 了 大 量 擴 展 。 可 以 找 到 使 用 Spring ApplicationContext
特性時所需的全部類， JDNI 所需的全部類， UI 方面的用來與模板（ Templating ）引擎如
Velocity 、 FreeMarker 、
JasperReports 集成的類，以及校驗 Validation 方面的相關類。
6. org.springframework.core 包含 Spring 框架基本的核心工具類， Spring 其它組件要都要使 用到這個包里的類，
是其它組件的基本核心。
7. org.springframework.expression Spring 表達式語言。
8. org.springframework.oxm Spring 對 Object/XMl 的映射支持 , 可以讓 Java 與 XML 之間來 回切換。
9. org.springframework.test 對 Junit 等測試框架的簡單封裝。
10. org.springframework.transaction 為 JDBC 、 Hibernate 、 JDO 、 JPA 等提供的一致的聲明式 和編程式事務管理。
3.2Spring 核心 IOC AOP
3.2.1 IOC ， DI
IoC Inverse of Control 反轉控制的概念，就是將原本在程序中手動創建 UserService 對象的 控制權，交由 Spring 框架管理，簡單說，就是創建 UserService 對象控制權被反轉到了 Spring 框架
DI ： Dependency Injection 依賴注入，在 Spring 框架負責創建 Bean 對象時，動態的將依賴 對象注入到 Bean 組件
3.2.2AOP
面向切面編程（ AOP ）提供另外一種角度來思考程序結構，通過這種方式彌補了面向對象編 程（ OOP ）的不足，除了類（ classes ）以外， AOP 提供了切面。切面對關注點進行模塊化，
例如橫切多個類型和對象的事務管理
Spring 的一個關鍵的組件就是 AOP 框架，可以自由選擇是否使用 AOP 提供聲明式企業服 務，特別是為了替代 EJB 聲明式服務。最重要的服務是聲明性事務管理，這個服務建立在 Spring 的抽象事物管理之上。允許用戶實現自定義切面，用 AOP 來完善 OOP 的使用 , 可以 把 Spring AOP 看作是對 Spring 的一種增強
3.2.2.1AOP 中的名詞
切面（ Aspect ）：一個關注點的模塊化，這個關注點可能會橫切多個對象。事務管理是 J2EE 應用中一個關于橫切關注點的很好的例子。 在 Spring AOP 中，切面可以使用通用類（基于 模式的風格） 或者在普通類中以 @Aspect 注解（ @AspectJ 風格）來實現。
連接點（ Joinpoint ）：在程序執行過程中某個特定的點，比如某方法調用的時候或者處理異 常 的 時 候 。 在 Spring AOP 中 ， 一 個 連 接點 總 是 代 表 一 個 方 法 的 執 行 。 通 過 聲 明 一 個 org.aspectj.lang.JoinPoint 類型的參數可以使通知（ Advice ）的主體部分獲得連接點信息。 通知（ Advice ）：在切面的某個特定的連接點（ Joinpoint ）上執行的動作。通知有各種類型， 其中包括“ around ”、“ before ”和“ after ”等通知。 通知的類型將在后面部分進行討論。許 多 AOP 框架，包括 Spring ，都是以攔截器做通知模型， 并維護一個以連接點為中心的攔截 器鏈。
切入點（ Pointcut ）：匹配連接點（ Joinpoint ）的斷言。通知和一個切入點表達式關聯，并在 滿足這個切入點的連接點上運行（例如，當執行某個特定名稱的方法時）。 切入點表達式如 何和連接點匹配是 AOP 的核心： Spring 缺省使用 AspectJ 切入點語法。
引入（ Introduction ）： （ 也被稱為內部類型聲明（ inter-type declaration ））。聲明額外的方法 或者某個類型的字段。 Spring 允許引入新的接口（以及一個對應的實現）到任何被代{過}{濾}理的 對象。例如，你可以使用一個引入來使 bean 實現 IsModified 接口，以便簡化緩存機制。 目標對象（ Target Object ）： 被一個或者多個切面（ aspect ）所通知（ advise ）的對象。也有 人把它叫做 被通知（ advised ） 對象。 既然 Spring AOP 是通過運行時代{過}{濾}理實現的，這個對 象永遠是一個 被代{過}{濾}理（ proxied ） 對象。
AOP 代{過}{濾}理（ AOP Proxy ）： AOP 框架創建的對象，用來實現切面契約（ aspect contract ）（包 括通知方法執行等功能）。在 Spring 中， AOP 代{過}{濾}理可以是 JDK 動態代{過}{濾}理或者 CGLIB 代{過}{濾}理。注 意： Spring 2.0 最新引入的基于模式（ schema-based ）風格和 @AspectJ 注解風格的切面聲 明，對于使用這些風格的用戶來說，代{過}{濾}理的創建是透明的。
織入（ Weaving ）：把切面（ aspect ）連接到其它的應用程序類型或者對象上，并創建一個被 通知（ advised ）的對象。 這些可以在編譯時（例如使用 AspectJ 編譯器），類加載時和運行 時完成。 Spring 和其他純 Java AOP 框架一樣，在運行時完成織入。
3.3spring 常用注解
@Component ：所有受 Spring 管理組件的通用形式，不推薦使用 @Controller ：對應表現層的 Bean ，也就是 Action
使用 @Controller 注解標識 UserAction 之后，就表示要把 UserAction 交給 Spring 容器管理， 在 Spring 容器中會存在一個名字為 ”userAction” 的 action ，這個名字是根據 UserAction 類名 來取的。注意：如果 @Controller 不指定其 value 【 @Controller 】，則默認的 bean 名字為這
個 類 的 類 名 首 字 母 小 寫 ， 如 果 指 定 value 【 @Controller(value=”UserAction”) 】 或 者 【 @Controller(“UserAction”) 】，則使用 value 作為 bean 的名字。
@Scope("prototype") ：表示將 Action 的范圍聲明為原型。可以利用容器的 scope=”prototype” 來保證每一個請求有一個單獨的 Action 來處理，避免 struts 中 Action 的線程安全問題。 spring 默認 scope 是單例模式 (scope=”singleton”) ，這樣只會創建一個 Action 對象，每次訪 問都是同一 Action 對象，數據不安全， struts2 是要求每次次訪問都對應不同的 Action ， scope=”prototype” 可以保證當有請求的時候都創建一個 Action 對象 @Service ：對應的是業務層 Bean @Repository ：對應數據訪問層 Bean 補充：理解 Spring 中的 ” 控制反轉 ”
如，在 UserAction 中要用到 UserServiceImpl 中的方法，最初的方法是在 UserAction 中通過 UserService userService = new UserServiceImpl; 需要時就 new 出來，控制權在自己手里，但 是 使 用 spring 后 ， UserAction 就 不 用 主 動 去 創 建 UserServiceImpl 的 實 例 了 ， 創 建 UserServiceImpl 實例已經交給 Spring 來做了， Spring 把創建好的 UserServiceImpl 實例給 UserAction ， UserAction 拿到就可以直接用了。 UserAction 由原來的主動創建 UserServiceImpl 實例后就可以馬上使用，變成了被動等待由 Spring 創建好 UserServiceImpl 實例之后再注入 給 UserAction ， UserAction 才能夠使用。這說明 UserAction 對 UserServiceImpl 類的 ” 控制權 ” 已經被 “ 反轉 ” 了
3.4Spring 常見問題
3.4.1 spring 配置 bean 實例化有哪些方式？
1 ）使用類構造器實例化 ( 默認無參數 )
<bean id="bean1" class="cn.itcast.spring.b_instance.Bean1"></bean>
2 ）使用靜態工廠方法實例化 ( 簡單工廠模式 )
// 下面這段配置的含義：調用 Bean2Factory 的 getBean2 方法得到 bean2 <bean id="bean2" class="cn.itcast.spring.b_instance.Bean2Factory" factory- method="getBean2"></bean>
3 ）使用實例工廠方法實例化 ( 工廠方法模式 )
// 先創建工廠實例 bean3Facory ，再通過工廠實例創建目標 bean 實例
<bean id="bean3Factory" class="cn.itcast.spring.b_instance.Bean3Factory"></bean> <bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>
3.4.2 Spring Bean 的生命周期？
① instantiate bean 對象實例化 ② populate properties 封裝屬性
③如果 Bean 實現 BeanNameAware 執行 setBeanName
④ 如 果 Bean 實 現 BeanFactoryAware 或 者 ApplicationContextAware 設 置 工 廠 setBeanFactory 或者上下文對象 setApplicationContext
⑤如果存在類實現 BeanPostProcessor （后處理 Bean ），執行 postProcessBeforeInitialization ， BeanPostProcessor 接口提供鉤子函數，用來動態擴展修改 Bean 。 ( 程序自動調用后處理 Bean) ⑥如果 Bean 實現 InitializingBean 執行 afterPropertiesSet ⑦調用 <bean init-method="init"> 指定初始化方法 init
⑧如果存在類實現 BeanPostProcessor （處理 Bean ） ，執行 postProcessAfterInitialization ⑨執行業務處理
⑩如果 Bean 實現 DisposableBean 執行 destroy
⑪ 調用 <bean destroy-method="customerDestroy"> 指定銷毀方法 customerDestroy
3.4.3 Bean 注入屬性有哪幾種方式？
spring 支持構造器注入和 setter 方法注入
構造器注入，通過 <constructor-arg> 元素完成注入
setter 方法注入， 通過 <property> 元素完成注入【開發中常用方式】
3.4.4Spring 如何處理線程并發問題？
Spring 使用 ThreadLocal 解決線程安全問題
我們知道在一般情況下，只有無狀態的 Bean 才可以在多線程環境下共享，在 Spring 中， 絕 大 部 分 Bean 都 可 以 聲 明 為 singleton 作 用 域 。 就 是 因 為 Spring 對 一 些 Bean( 如
RequestContextHolder 、 TransactionSynchronizationManager 、 LocaleContextHolder 等 ) 中非 線程安全狀態采用 ThreadLocal 進行處理，讓它們也成為線程安全的狀態，因為有狀態的 Bean 就可以在多線程中共享了。
ThreadLocal 和線程同步機制都是為了解決多線程中相同變量的訪問沖突問題。
在同步機制中，通過對象的鎖機制保證同一時間只有一個線程訪問變量。這時該變量是多個 線程共享的，使用同步機制要求程序慎密地分析什么時候對變量進行讀寫，什么時候需要鎖 定某個對象，什么時候釋放對象鎖等繁雜的問題，程序設計和編寫難度相對較大。 而 ThreadLocal 則從另一個角度來解決多線程的并發訪問。 ThreadLocal 會為每一個線 程提供一個獨立的變量副本，從而隔離了多個線程對數據的訪問沖突。因為每一個線程都擁 有自己的變量副本，從而也就沒有必要對該變量進行同步了。 ThreadLocal 提供了線程安全 的共享對象，在編寫多線程代碼時，可以把不安全的變量封裝進 ThreadLocal 。
由于 ThreadLocal 中可以持有任何類型的對象，低版本 JDK 所提供的 get() 返回的是 Object 對象，需要強制類型轉換。但 JDK5.0 通過泛型很好的解決了這個問題，在一定程度地簡化 ThreadLocal 的使用。
概括起來說，對于多線程資源共享的問題，同步機制采用了 “ 以時間換空間 ” 的方式，而 ThreadLocal 采用了 “ 以空間換時間 ” 的方式。前者僅提供一份變量，讓不同的線程排隊訪問， 而后者為每一個線程都提供了一份變量，因此可以同時訪問而互不影響。
3.4.5 介紹一下 Spring 的事物管理
Spring 支持兩種類型的事務管理：
編程式事務管理：這意味你通過編程的方式管理事務，給你帶來極大的靈活性，但是難維護。 聲明式事務管理：這意味著你可以將業務代碼和事務管理分離，你只需用注解和 XML 配置 來管理事務。
3.4.6 通知有哪些類型？
前置通知 （ Before advice ）：在某連接點（ join point ）之前執行的通知，但這個通知不能阻 止連接點前的執行（除非它拋出一個異常）。
返回后通知 （ After returning advice ）：在某連接點（ join point ）正常完成后執行的通知：例 如，一個方法沒有拋出任何異常，正常返回。
拋出異常后通知 （ After throwing advice ）：在方法拋出異常退出時執行的通知。
后通知 （ After (finally) advice ）：當某連接點退出的時候執行的通知（不論是正常返回還是異 常退出）。
環繞通知 （ Around Advice ）：包圍一個連接點（ join point ）的通知，如方法調用。這是最強 大的一種通知類型。 環繞通知可以在方法調用前后完成自定義的行為。它也會選擇是否繼 續執行連接點或直接返回它們自己的返回值或拋出異常來結束執行。
環繞通知是最常用的一種通知類型。大部分基于攔截的 AOP 框架，例如 Nanning 和 JBoss4 ， 都只提供環繞通知。
切入點（ pointcut ）和連接點（ join point ）匹配的概念是 AOP 的關鍵，這使得 AOP 不同于 其它僅僅提供攔截功能的舊技術。 切入點使得定位通知（ advice ）可獨立于 OO 層次。 例 如，一個提供聲明式事務管理的 around 通知可以被應用到一組橫跨多個對象中的方法上（例
如服務層的所有業務操作）。
3.4.7 BeanFactory 接口和 ApplicationContext 接口有什么區別 ？
① ApplicationContext 接 口 繼 承 BeanFactory 接 口 ， Spring 核 心 工 廠 是 BeanFactory ,BeanFactory 采 取 延 遲 加 載 ， 第 一 次 getBean 時 才 會 初 始 化 Bean, ApplicationContext 是會在加載配置文件時初始化 Bean 。
② ApplicationContext 是對 BeanFactory 擴展，它可以進行國際化處理、事件傳遞和 bean
自動裝配以及各種不同應用層的 Context 實現
開發中基本都在使用 ApplicationContext, web 項目使用 WebApplicationContext ，很少用到 BeanFactory
SpringMVC
1. 簡單的談一下 SpringMVC 的工作流程？
流程
1 、用戶發送請求至前端控制器 DispatcherServlet
2 、 DispatcherServlet 收到請求調用 HandlerMapping 處理器映射器。
3 、處理器映射器找到具體的處理器，生成處理器對象及處理器攔截器 ( 如果有則生成 ) 一并返回給 DispatcherServlet 。
4 、 DispatcherServlet 調用 HandlerAdapter 處理器適配器
5 、 HandlerAdapter 經過適配調用具體的處理器 (Controller ，也叫后端控制器 ) 。 6 、 Controller 執行完成返回 ModelAndView
7 、 HandlerAdapter 將 controller 執行結果 ModelAndView 返回給 DispatcherServlet
8 、 DispatcherServlet 將 ModelAndView 傳給 ViewReslover 視圖解析器 9 、 ViewReslover 解析后返回具體 View
10 、 DispatcherServlet 根據 View 進行渲染視圖（即將模型數據填充至視圖中）。 11 、 DispatcherServlet 響應用戶
2. 如何解決 POST 請求中文亂碼問題， GET 的又如何處理呢？
在 web.xml 中加入：
.? ? <filter>
.? ?? ???<filter-name> CharacterEncodingFilter </filter-name> .? ?? ???<filter-
class> org.springframework.web.filter.CharacterEncodingFilter </ filter-class>
.? ?? ???<init-param>
.? ?? ?? ?? ?<param-name> encoding </param-name> .? ?? ?? ?? ?<param-value> utf-8 </param-value> .? ?? ???</init-param> .? ? </filter>
.? ? <filter-mapping>
.? ?? ???<filter-name> CharacterEncodingFilter </filter-name> .? ?? ???<url-pattern> /* </url-pattern> .? ? </filter-mapping>
以上可以解決 post 請求亂碼問題。對于 get 請求中文參數出現亂碼解決方法有兩 個：
修改 tomcat 配置文件添加編碼與工程編碼一致，如下：
.? ? < Connector URIEncoding = "utf-8" connectionTimeout = "20000"
port = "8080" protocol = "HTTP/1.1" redirectPort = "8443" />
另外一種方法對參數進行重新編碼：
.? ? String? ?? ?? ?? ?? ? userName =? ?? ?? ?? ?? ? new
String ( request . getParamter ( "userName" ). getBytes ( "ISO8859- 1" ), "utf-8" )
ISO8859-1 是 tomcat 默認編碼，需要將 tomcat 編碼后的內容按 utf-8 編碼
3. 問題： springmvc 常用注解有哪些？
@RequestMapping ：是一個用來處理請求地址映射的注解，可用于類或方法上。用于類上， 表示類中的所有響應請求的方法都是以該地址作為父路徑。
@PathVariable ：用于將請求 URL 中的模板變量映射到功能處理方法的參數上，即取出 uri 模 板中的變量作為參數。
@requestParam ： 主 要 用 于 在 SpringMVC 后 臺 控 制 層 獲 取 參 數 ， 類 似 一 種 是 request.getParameter("name") ，它有三個常用參數： defaultValue = "0", required = false, value = "isApp" ； defaultValue 表示設置默認值， required 銅過 boolean 設置是否是必須要傳入的 參數， value 值表示接受的傳入的參數類型。
@ResponseBody ： 該 注 解 用 于 將 Controller 的 方 法 返 回 的 對 象 ， 通 過 適 當 的 HttpMessageConverter 轉換為指定格式后，寫入到 Response 對象的 body 數據區。使用時 機：返回的數據不是 html 標簽的頁面，而是其他某種格式的數據時（如 json 、 xml 等）使用 @RequestBody ： 該 注 解 常 用 來 處 理 Content-Type: 不 是 application/x-www-form- urlencoded 編碼的內容，例如 application/json, application/xml 等；
@RequestHeader ：可以把 Request 請求 header 部分的值綁定到方法的參數上。 @CookieValue ：可以把 Request header 中關于 cookie 的值綁定到方法的參數上。
4. 問 題 ： 一 個 bean 配 置 在 springmvc 的 配 置 文 件 如 springmvc-servlet.xml 跟 配 置 在 spring 全 局 配 置 文 件 applicationContext 中有什么區別。
答：配置在 springmvc 配置文件中的 bean 屬于子容器中內容。配置在全局配置文件中的 bean 屬于父容器。子容器可以獲取父容器中的內容，而父容器不可以獲得子容器中的內容。
Mybatis
1.mybatis 比 IBatis 比較大的幾個改進是什么？
a. 有接口綁定 , 包括注解綁定 sql 和 xml 綁定 Sql , b. 動態 sql 由原來的節點配置變成 OGNL 表達式 ,
c. 在一對一 , 一對多的時候引進了 association, 在一對多的時候引入了 collection 節點 , 不過都 是在 resultMap 里面配置
2. 接口綁定有幾種實現方式 , 分別是怎么實現的 ?
a. 一種是通過注解綁定 , 就是在接口的方法上面加上 @ Select @ Update 等注解里面包含 Sql 語
句來綁定 ,
b, 另外一種就是通過 xml 里面寫 SQL 來綁定 , 在這種情況下 , 要指定 xml 映射文件里面的 namespace 必須為接口的全路徑名 .
3. 什么情況下用注解綁定 , 什么情況下用 xml 綁定
當 Sql 語句比較簡單時候 , 用注解綁定 ,
當 SQL 語句比較復雜時候 , 用 xml 綁定 , 一般用 xml 綁定的比較多
4.myBatis 實現一對一有幾種方式 ? 具體怎么操作的
有聯合查詢和嵌套查詢
聯合查詢是幾個表聯合查詢 , 只查詢一次 , 通過在 resultMap 里面配置 association 節點配置一 對一的類就可以完成 ;
嵌套查詢是先查一個表 , 根據這個表里面的結果的外鍵 id, 去再另外一個表里面查詢數據 , 也是 通過 association 配置 , 但另外一個表的查詢通過 select 屬性配置
5.myBatis 實現一對多有幾種方式 , 怎么操作的
有聯合查詢和嵌套查詢
聯合查詢是幾個表聯合查詢 , 只查詢一次 , 通過在 resultMap 里面配置 collection 節點配置一對 多的類就可以完成 ;
嵌套查詢是先查一個表 , 根據這個表里面的結果的外鍵 id, 去再另外一個表里面查詢數據 , 也是 通過配置 collection, 但另外一個表的查詢通過 select 節點配置
6.myBatis 里面的動態 Sql 是怎么設定的 ? 用什么語法 ?
MyBatis 里面的動態 Sql 一般是通過 if 節點來實現 , 通過 OGNL 語法來實現 , 但是如果要寫的 完整 , 必須配合 where ,trim 節點 , where 節點是判斷包含節點有內容就插入 where , 否則不插 入 ,trim 節點是用來判斷如果動態語句是以 and 或 or 開始 , 那么會自動把這個 and 或者 or 取 掉
7. 講下 myBatis 的緩存
MyBatis 的緩存分為一級緩存和二級緩存 ,
一級緩存放在 session 里面 , 默認就有 , 二級緩存放在它的命名空間里 , 默認是打開的 ,
二級緩存屬性類需要實現 Serializable 序列化接口 ( 可用來保存對象的狀態 ), 可在它的映射文 件中配置 <cache/>
8.myBatis(IBatis) 的好處是什么
ibatis 把 sql 語句從 Java 源程序中獨立出來，放在單獨的 XML 文件中編寫，給程序的維護帶 來了很大便利。
ibatis 封裝了底層 JDBC API 的調用細節，并能自動將結果集轉換成 Java Bean 對象，大大簡 化了 Java 數據庫編程的重復工作。
因為 Ibatis 需要程序員自己去編寫 sql 語句，程序員可以結合數據庫自身的特點靈活控制 sql 語句，因此能夠實現比 hibernate 等全自動 orm 框架更高的查詢效率，能夠完成復雜查詢。 .
Struts2 和 SpringMVC 對比
1. 機制： spring mvc 的入口是 servlet ，而 struts2 是 filter （這里要指出， filter 和 servlet 是不同的。以前認為 filter 是 servlet 的一種特殊），這樣就導致了二者的 機制不同，這里就牽涉到 servlet 和 filter 的區別了。
2. 性能： spring 會稍微比 struts 快。 spring mvc 是基于方法的設計，而 sturts 是基于 類，每次發一次請求都會實例一個 action ，每個 action 都會被注入屬性，而 spring 基于方法，粒度更細，但要小心把握像在 servlet 控制數據一樣。 spring3 mvc 是方 法級別的攔截，攔截到方法后根據參數上的注解，把 request 數據注入進去，在 spring3 mvc 中，一個方法對應一個 request 上下文。而 struts2 框架是類級別的攔 截，每次來了請求就創建一個 Action ，然后調用 setter getter 方法把 request 中的 數據注入； struts2 實際上是通過 setter getter 方法與 request 打交道的； struts2 中，一個 Action 對象對應一個 request 上下文。
3. 參數傳遞： struts 是在接受參數的時候，可以用屬性來接受參數，這就說明參數是
讓多個方法共享的。
4. 設計思想上： struts 更加符合 oop 的編程思想， spring 就比較謹慎，在 servlet 上
擴展。
Hibernate 和 Mybatis 對比
1. 開發對比開發速度
Hibernate 的真正掌握要比 Mybatis 來得難些。 Mybatis 框架相對簡單很容易上手，但也相對 簡陋些。個人覺得要用好 Mybatis 還是首先要先理解好 Hibernate 。 開發社區
Hibernate 與 Mybatis 都是流行的持久層開發框架，但 Hibernate 開發社區相對多熱鬧些， 支持的工具也多，更新也快，當前最高版本 4.1.8 。而 Mybatis 相對平靜，工具較少，當前最 高版本 3.2 。 開發工作量
Hibernate 和 MyBatis 都有相應的代碼生成工具。可以生成簡單基本的 DAO 層方法。 針對高級查詢， Mybatis 需要手動編寫 SQL 語句，以及 ResultMap 。而 Hibernate 有良好的 映射機制，開發者無需關心 SQL 的生成與結果映射，可以更專注于業務流程。
2 對象管理與抓取策略對象管理
Hibernate 是完整的對象 / 關系映射解決方案，它提供了對象狀態管理（ state management ） 的功能，使開發者不再需要理會底層數據庫系統的細節。也就是說，相對于常見的 JDBC/SQL 持 久 層方 案 中需 要管 理 SQL 語 句， Hibernate 采 用了 更 自然 的 面向 對象 的 視角 來 持久化 Java 應用中的數據。
換句話說，使用 Hibernate 的開發者應該總是關注對象的狀態（ state ），不必考慮 SQL 語 句的執行。這部分細節已經由 Hibernate 掌管妥當，只有開發者在進行系統性能調優的時候 才需要進行了解。
而 MyBatis 在這一塊沒有文檔說明，用戶需要對對象自己進行詳細的管理。 抓取策略
Hibernate 對實體關聯對象的抓取有著良好的機制。對于每一個關聯關系都可以詳細地設置 是否延遲加載，并且提供關聯抓取、查詢抓取、子查詢抓取、批量抓取四種模式。 它是詳 細配置和處理的。
而 Mybatis 的延遲加載是全局配置的。
3 緩存機制對比 Hibernate 緩存
Hibernate 一級緩存是 Session 緩存，利用好一級緩存就需要對 Session 的生命周期進行管理 好。建議在一個 Action 操作中使用一個 Session 。一級緩存需要對 Session 進行嚴格管理。 Hibernate 二級緩存是 SessionFactory 級的緩存。 SessionFactory 的緩存分為內置緩存和外 置緩存。內置緩存中存放的是 SessionFactory 對象的一些集合屬性包含的數據 ( 映射元素據 及預定 SQL 語句等 ), 對于應用程序來說 , 它是只讀的。外置緩存中存放的是數據庫數據的副 本 , 其 作用 和一 級緩 存類 似 . 二 級 緩存 除了 以內 存作 為存 儲 介質 外 , 還 可以 選用 硬盤 等 外部 存 儲設備。二級緩存稱為進程級緩存或 SessionFactory 級緩存，它可以被所有 session 共享， 它的生命周期伴隨著 SessionFactory 的生命周期存在和消亡。
4 優勢對比
Mybatis 優勢
MyBatis 可以進行更為細致的 SQL 優化，可以減少查詢字段。 MyBatis 容易掌握，而 Hibernate 門檻較高。 Hibernate 優勢
Hibernate 的 DAO 層開發比 MyBatis 簡單， Mybatis 需要維護 SQL 和結果映射。 Hibernate 對對象的維護和緩存要比 MyBatis 好，對增刪改查的對象的維護要方便。 Hibernate 數據庫移植性很好， MyBatis 的數據庫移植性不好，不同的數據庫需要寫不同 SQL 。 Hibernate 有更好的二級緩存機制，可以使用第三方緩存。 MyBatis 本身提供的緩存機制不
佳。
面試題數據庫 ( 附件 )
1. 用一條 SQL 語句查詢出每門課都大于 80 分的學生姓名
準備數據的 sql 代碼：
create table score(id int primary key auto_increment,namevarchar(20),subject varchar(20),score int); insert into score values (null,' 張三 ',' 語文 ',81), (null,' 張三 ',' 數學 ',75), (null,' 李四 ',' 語文 ',76), (null,' 李四 ',' 數學 ',90), (null,' 王五 ',' 語文 ',81),
(null,' 王五 ',' 數學 ',100), (null,' 王五 ',' 英語 ',90);
提示：當百思不得其解時，請理想思維，把小變成大做，把大變成小做，
答案： A: select distinct name from score where name not in (selectdistinct name from score where score<=80)
B:select distince name t1 from score where 80< all (selectscore from score where name=t1);
2. 所有部門之間的比賽組合
一個叫 department 的表，里面只有一個字段 name, 一共有 4
條紀錄，分別是 a,b,c,d, 對應四個球對，現在四個球對進行比賽，用一
條 sql 語句顯示所有可能的比賽組合 .
答 ： select a.name,b.name from team a, team b where a.name <
b.name
3. 顯示文章標題，發帖人、最后回復時間
表： id,title,postuser,postdate,parentid
準備 sql 語句：
drop table if exists articles;
create table articles(id int auto_increment primary key,titlevarchar(50), postuser varchar(10), postdate datetime,parentid int referencesarticles(id));
insert into articles values
(null,' 第一條 ',' 張三 ','1998-10-10 12:32:32',null), (null,' 第二條 ',' 張三 ','1998-10-10 12:34:32',null), (null,' 第一條回復 1',' 李四 ','1998-10-10 12:35:32',1), (null,' 第二條回復 1',' 李四 ','1998-10-10 12:36:32',2), (null,' 第一條回復 2',' 王五 ','1998-10-10 12:37:32',1),
(null,' 第一條回復 3',' 李四 ','1998-10-10 12:38:32',1), (null,' 第二條回復 2',' 李四 ','1998-10-10 12:39:32',2), (null,' 第一條回復 4',' 王五 ','1998-10-10 12:39:40',1);
答案：
select a.title,a.postuser,
(selectmax(postdate) from articles where parentid=a.id) reply from articles a where a.parentid is null;
注釋：子查詢可以用在選擇列中，也可用于 where 的比較條件中，還可以用于 from 從句 中。
4. 刪除除了 id 號不同 , 其他都相同的學生冗余信息
學生表如下 :
實驗：
create table student2(id int auto_increment primary key,codevarchar(20),name varchar(20));
insert into student2 values(null,'2005001',' 張三 '),(null,'2005002',' 李四 '),(null,'2005001',' 張 三 ');
// 如下語句， mysql 報告錯誤，可能刪除依賴后面統計語句，而刪除又導致統計語句結果不 一致。
delete from student2 where id not in(select min(id) fromstudent2 group by name); // 但是，如下語句沒有問題：
select * from student2where id not in(select min(id) from student2 group by name); // 于是，我想先把分組的結果做成虛表，然后從虛表中選出結果，最后再將結果作為刪除的 條件數據。
delete from student2 where id not in(select mid from (selectmin(id) mid from student2 group by name) as t); 或者：
delete from student2 where id not in(select min(id) from (select* from s tudent2) as t group by t.name);
5. 航空網的幾個航班查詢題：
1 、查詢起飛城市是北京的所有航班，按到達城市的名字排序
參與運算的列是我起碼能夠顯示出來的那些列，但最終我不一定把它們顯示出來。各個表 組合出來的中間結果字段中必須包含所有運算的字段。
select * from flight f,city c
where f.endcityid =c.cityid and startcityid =
(select c1.cityidfrom city c1 where c1.cityname = " 北京 ")
order by c.citynameasc;
select flight.flightid,' 北京 ' startcity, e.cityname from
flight,city e
where flight.endcityid=e.cityid and flight.startcityid=(
selectcityid from city where cityname=' 北京 ');
select flight.flightid,s.cityname,e.cityname fromflight,city s,city e wh
ere flight.startcityid=s.cityid and s.cityname=' 北京 ' andflight.endCityId=e.cit yID order by e.cityName desc;
2 、查詢北京到上海的所有航班紀錄（起飛城市，到達城市，起飛時間，航班號）
select c1.CityName,c2.CityName,f.StartTime,f.flightID from city c1,city c2,flight f
where f.StartCityID=c1.cityID and f.endCityID=c2.cityID and c1.cityName=' 北京 ' and c2.cityName=' 上海 '
3 、查詢具體某一天（ 2005-5-8 ）的北京到上海的的航班次數
select count(*) from
(select c1.CityName,c2.CityName,f.StartTime,f.flightID from city c1,city c2,flight f
where f.StartCityID=c1.cityID and f.endCityID=c2.cityID and c1.cityName=' 北京 ' and c2.cityName=' 上海 '
and 查幫助獲得的某個日期處理函數 (startTime) like '2005-5-8%' mysql 中提取日期部分進行比較的示例代碼如下：
select * from flight wheredate_format(starttime,'%Y-%m-%d')='1998-01-02'
總結
以上是生活随笔為你收集整理的Java面试宝典4.0版的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 前端学习（495）：嵌入代码与外部文件和
- 下一篇： 第一百期:Java架构师：高并发下的流量