java面試170道精講：留着慢慢看

1、面向對象的特徵有哪些方面？
答：面向對象的特徵主要有以下幾個方面：
- 抽象：抽象是將一類對象的共同特徵總結出來構造類的過程，包括數據抽象和行爲抽象兩方面。抽象只關注對象有哪些屬性和行爲，並不關注這些行爲的細節是什麼。
- 繼承：繼承是從已有類得到繼承信息創建新類的過程。提供繼承信息的類被稱爲父類（超類、基類）；得到繼承信息的類被稱爲子類（派生類）。繼承讓變化中的軟件系統有了一定的延續性，同時繼承也是封裝程序中可變因素的重要手段（如果不能理解請閱讀閻宏博士的《Java與模式》或《設計模式精解》中關於橋樑模式的部分）。
- 封裝：通常認爲封裝是把數據和操作數據的方法綁定起來，對數據的訪問只能通過已定義的接口。面向對象的本質就是將現實世界描繪成一系列完全自治、封閉的對象。我們在類中編寫的方法就是對實現細節的一種封裝；我們編寫一個類就是對數據和數據操作的封裝。可以說，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的編程接口（可以想想普通洗衣機和全自動洗衣機的差別，明顯全自動洗衣機封裝更好因此操作起來更簡單；我們現在使用的智能手機也是封裝得足夠好的，因爲幾個按鍵就搞定了所有的事情）。
- 多態性：多態性是指允許不同子類型的對象對同一消息作出不同的響應。簡單的說就是用同樣的對象引用調用同樣的方法但是做了不同的事情。多態性分爲編譯時的多態性和運行時的多態性。如果將對象的方法視爲對象向外界提供的服務，那麼運行時的多態性可以解釋爲：當A系統訪問B系統提供的服務時，B系統有多種提供服務的方式，但一切對A系統來說都是透明的（就像電動剃鬚刀是A系統，它的供電系統是B系統，B系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統只會通過B類對象調用供電的方法，但並不知道供電系統的底層實現是什麼，究竟通過何種方式獲得了動力）。方法重載（overload）實現的是編譯時的多態性（也稱爲前綁定），而方法重寫（override）實現的是運行時的多態性（也稱爲後綁定）。運行時的多態是面向對象最精髓的東西，要實現多態需要做兩件事：1). 方法重寫（子類繼承父類並重寫父類中已有的或抽象的方法）；2). 對象造型（用父類型引用引用子類型對象，這樣同樣的引用調用同樣的方法就會根據子類對象的不同而表現出不同的行爲）。

2、訪問修飾符public,private,protected,以及不寫（默認）時的區別？
答：

修飾符	當前類	同包	子類	其他包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

類的成員不寫訪問修飾時默認爲default。默認對於同一個包中的其他類相當於公開（public），對於不是同一個包中的其他類相當於私有（private）。受保護（protected）對子類相當於公開，對不是同一包中的沒有父子關係的類相當於私有。Java中，外部類的修飾符只能是public或默認，類的成員（包括內部類）的修飾符可以是以上四種。

3、String 是最基本的數據類型嗎？
答：不是。Java中的基本數據類型只有8個：byte、short、int、long、float、double、char、boolean；除了基本類型（primitive type），剩下的都是引用類型（reference type），Java 5以後引入的枚舉類型也算是一種比較特殊的引用類型。

4、float f=3.4;是否正確？
答:不正確。3.4是雙精度數，將雙精度型（double）賦值給浮點型（float）屬於下轉型（down-casting，也稱爲窄化）會造成精度損失，因此需要強制類型轉換float f =(float)3.4; 或者寫成float f =3.4F;。

5、short s1 = 1; s1 = s1 + 1;有錯嗎?short s1 = 1; s1 += 1;有錯嗎？
答：對於short s1 = 1; s1 = s1 + 1;由於1是int類型，因此s1+1運算結果也是int 型，需要強制轉換類型才能賦值給short型。而short s1 = 1; s1 += 1;可以正確編譯，因爲s1+= 1;相當於s1 = (short)(s1 + 1);其中有隱含的強制類型轉換。

6、Java有沒有goto？
答：goto 是Java中的保留字，在目前版本的Java中沒有使用。（根據James Gosling（Java之父）編寫的《The Java Programming Language》一書的附錄中給出了一個Java關鍵字列表，其中有goto和const，但是這兩個是目前無法使用的關鍵字，因此有些地方將其稱之爲保留字，其實保留字這個詞應該有更廣泛的意義，因爲熟悉C語言的程序員都知道，在系統類庫中使用過的有特殊意義的單詞或單詞的組合都被視爲保留字）

7、int和Integer有什麼區別？
答：Java是一個近乎純潔的面向對象編程語言，但是爲了編程的方便還是引入了基本數據類型，但是爲了能夠將這些基本數據類型當成對象操作，Java爲每一個基本數據類型都引入了對應的包裝類型（wrapper class），int的包裝類就是Integer，從Java 5開始引入了自動裝箱/拆箱機制，使得二者可以相互轉換。
Java 爲每個原始類型提供了包裝類型：
- 原始類型: boolean，char，byte，short，int，long，float，double
- 包裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

class AutoUnboxingTest {

    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 將3自動裝箱成Integer類型
        int c = 3;
        System.out.println(a == b);     // false 兩個引用沒有引用同一對象
        System.out.println(a == c);     // true a自動拆箱成int類型再和c比較
    }
}

最近還遇到一個面試題，也是和自動裝箱和拆箱有點關係的，代碼如下所示：

public class Test03 {

    public static void main(String[] args) {
        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;

        System.out.println(f1 == f2);
        System.out.println(f3 == f4);
    }
}

如果不明就裏很容易認爲兩個輸出要麼都是true要麼都是false。首先需要注意的是f1、f2、f3、f4四個變量都是Integer對象引用，所以下面的==運算比較的不是值而是引用。裝箱的本質是什麼呢？當我們給一個Integer對象賦一個int值的時候，會調用Integer類的靜態方法valueOf，如果看看valueOf的源代碼就知道發生了什麼。

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache是Integer的內部類，其代碼如下所示：

/**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

簡單的說，如果整型字面量的值在-128到127之間，那麼不會new新的Integer對象，而是直接引用常量池中的Integer對象，所以上面的面試題中f1==f2的結果是true，而f3==f4的結果是false。

提醒：越是貌似簡單的面試題其中的玄機就越多，需要面試者有相當深厚的功力。

8、&和&&的區別？
答：&運算符有兩種用法：(1)按位與；(2)邏輯與。&&運算符是短路與運算。邏輯與跟短路與的差別是非常巨大的，雖然二者都要求運算符左右兩端的布爾值都是true整個表達式的值纔是true。&&之所以稱爲短路運算是因爲，如果&&左邊的表達式的值是false，右邊的表達式會被直接短路掉，不會進行運算。很多時候我們可能都需要用&&而不是&，例如在驗證用戶登錄時判定用戶名不是null而且不是空字符串，應當寫爲：username != null &&!username.equals("")，二者的順序不能交換，更不能用&運算符，因爲第一個條件如果不成立，根本不能進行字符串的equals比較，否則會產生NullPointerException異常。注意：邏輯或運算符（|）和短路或運算符（||）的差別也是如此。

補充：如果你熟悉JavaScript，那你可能更能感受到短路運算的強大，想成爲JavaScript的高手就先從玩轉短路運算開始吧。

9、解釋內存中的棧(stack)、堆(heap)和方法區(method area)的用法。
答：通常我們定義一個基本數據類型的變量，一個對象的引用，還有就是函數調用的現場保存都使用JVM中的棧空間；而通過new關鍵字和構造器創建的對象則放在堆空間，堆是垃圾收集器管理的主要區域，由於現在的垃圾收集器都採用分代收集算法，所以堆空間還可以細分爲新生代和老生代，再具體一點可以分爲Eden、Survivor（又可分爲From Survivor和To Survivor）、Tenured；方法區和堆都是各個線程共享的內存區域，用於存儲已經被JVM加載的類信息、常量、靜態變量、JIT編譯器編譯後的代碼等數據；程序中的字面量（literal）如直接書寫的100、"hello"和常量都是放在常量池中，常量池是方法區的一部分，。棧空間操作起來最快但是棧很小，通常大量的對象都是放在堆空間，棧和堆的大小都可以通過JVM的啓動參數來進行調整，棧空間用光了會引發StackOverflowError，而堆和常量池空間不足則會引發OutOfMemoryError。

String str = new String("hello");

上面的語句中變量str放在棧上，用new創建出來的字符串對象放在堆上，而"hello"這個字面量是放在方法區的。

補充1：較新版本的Java（從Java 6的某個更新開始）中，由於JIT編譯器的發展和"逃逸分析"技術的逐漸成熟，棧上分配、標量替換等優化技術使得對象一定分配在堆上這件事情已經變得不那麼絕對了。
補充2：運行時常量池相當於Class文件常量池具有動態性，Java語言並不要求常量一定只有編譯期間才能產生，運行期間也可以將新的常量放入池中，String類的intern()方法就是這樣的。

看看下面代碼的執行結果是什麼並且比較一下Java 7以前和以後的運行結果是否一致。

String s1 = new StringBuilder("go")
    .append("od").toString();
System.out.println(s1.intern() == s1);
String s2 = new StringBuilder("ja")
    .append("va").toString();
System.out.println(s2.intern() == s2);

10、Math.round(11.5) 等於多少？Math.round(-11.5)等於多少？
答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四捨五入的原理是在參數上加0.5然後進行下取整。

11、switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上？
答：在Java 5以前，switch(expr)中，expr只能是byte、short、char、int。從Java 5開始，Java中引入了枚舉類型，expr也可以是enum類型，從Java 7開始，expr還可以是字符串（String），但是長整型（long）在目前所有的版本中都是不可以的。

12、用最有效率的方法計算2乘以8？
答： 2 << 3（左移3位相當於乘以2的3次方，右移3位相當於除以2的3次方）。

補充：我們爲編寫的類重寫hashCode方法時，可能會看到如下所示的代碼，其實我們不太理解爲什麼要使用這樣的乘法運算來產生哈希碼（散列碼），而且爲什麼這個數是個素數，爲什麼通常選擇31這個數？前兩個問題的答案你可以自己百度一下，選擇31是因爲可以用移位和減法運算來代替乘法，從而得到更好的性能。說到這裏你可能已經想到了：31 * num 等價於(num << 5) - num，左移5位相當於乘以2的5次方再減去自身就相當於乘以31，現在的VM都能自動完成這個優化。

public class PhoneNumber {
    private int areaCode;
    private String prefix;
    private String lineNumber;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + areaCode;
        result = prime * result
                + ((lineNumber == null) ? 0 : lineNumber.hashCode());
        result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PhoneNumber other = (PhoneNumber) obj;
        if (areaCode != other.areaCode)
            return false;
        if (lineNumber == null) {
            if (other.lineNumber != null)
                return false;
        } else if (!lineNumber.equals(other.lineNumber))
            return false;
        if (prefix == null) {
            if (other.prefix != null)
                return false;
        } else if (!prefix.equals(other.prefix))
            return false;
        return true;
    }

}

13、數組有沒有length()方法？String有沒有length()方法？
答：數組沒有length()方法，有length 的屬性。String 有length()方法。JavaScript中，獲得字符串的長度是通過length屬性得到的，這一點容易和Java混淆。

14、在Java中，如何跳出當前的多重嵌套循環？
答：在最外層循環前加一個標記如A，然後用break A;可以跳出多重循環。（Java中支持帶標籤的break和continue語句，作用有點類似於C和C++中的goto語句，但是就像要避免使用goto一樣，應該避免使用帶標籤的break和continue，因爲它不會讓你的程序變得更優雅，很多時候甚至有相反的作用，所以這種語法其實不知道更好）

15、構造器（constructor）是否可被重寫（override）？
答：構造器不能被繼承，因此不能被重寫，但可以被重載。

16、兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對？
答：不對，如果兩個對象x和y滿足x.equals(y) == true，它們的哈希碼（hash code）應當相同。Java對於eqauls方法和hashCode方法是這樣規定的：(1)如果兩個對象相同（equals方法返回true），那麼它們的hashCode值一定要相同；(2)如果兩個對象的hashCode相同，它們並不一定相同。當然，你未必要按照要求去做，但是如果你違背了上述原則就會發現在使用容器時，相同的對象可以出現在Set集合中，同時增加新元素的效率會大大下降（對於使用哈希存儲的系統，如果哈希碼頻繁的衝突將會造成存取性能急劇下降）。

補充：關於equals和hashCode方法，很多Java程序都知道，但很多人也就是僅僅知道而已，在Joshua Bloch的大作《Effective Java》（很多軟件公司，《Effective Java》、《Java編程思想》以及《重構：改善既有代碼質量》是Java程序員必看書籍，如果你還沒看過，那就趕緊去亞馬遜買一本吧）中是這樣介紹equals方法的：首先equals方法必須滿足自反性（x.equals(x)必須返回true）、對稱性（x.equals(y)返回true時，y.equals(x)也必須返回true）、傳遞性（x.equals(y)和y.equals(z)都返回true時，x.equals(z)也必須返回true）和一致性（當x和y引用的對象信息沒有被修改時，多次調用x.equals(y)應該得到同樣的返回值），而且對於任何非null值的引用x，x.equals(null)必須返回false。實現高質量的equals方法的訣竅包括：1. 使用==操作符檢查"參數是否爲這個對象的引用"；2. 使用instanceof操作符檢查"參數是否爲正確的類型"；3. 對於類中的關鍵屬性，檢查參數傳入對象的屬性是否與之相匹配；4. 編寫完equals方法後，問自己它是否滿足對稱性、傳遞性、一致性；5. 重寫equals時總是要重寫hashCode；6. 不要將equals方法參數中的Object對象替換爲其他的類型，在重寫時不要忘掉@Override註解。

17、是否可以繼承String類？
答：String 類是final類，不可以被繼承。

補充：繼承String本身就是一個錯誤的行爲，對String類型最好的重用方式是關聯關係（Has-A）和依賴關係（Use-A）而不是繼承關係（Is-A）。

18、當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏到底是值傳遞還是引用傳遞？
答：是值傳遞。Java語言的方法調用只支持參數的值傳遞。當一個對象實例作爲一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變，但對對象引用的改變是不會影響到調用者的。C++和C#中可以通過傳引用或傳輸出參數來改變傳入的參數的值。在C#中可以編寫如下所示的代碼，但是在Java中卻做不到。

using System;

namespace CS01 {

    class Program {
        public static void swap(ref int x, ref int y) {
            int temp = x;
            x = y;
            y = temp;
        }

        public static void Main (string[] args) {
            int a = 5, b = 10;
            swap (ref a, ref b);
            // a = 10, b = 5;
            Console.WriteLine ("a = {0}, b = {1}", a, b);
        }
    }
}

說明：Java中沒有傳引用實在是非常的不方便，這一點在Java 8中仍然沒有得到改進，正是如此在Java編寫的代碼中才會出現大量的Wrapper類（將需要通過方法調用修改的引用置於一個Wrapper類中，再將Wrapper對象傳入方法），這樣的做法只會讓代碼變得臃腫，尤其是讓從C和C++轉型爲Java程序員的開發者無法容忍。

19、String和StringBuilder、StringBuffer的區別？
答：Java平臺提供了兩種類型的字符串：String和StringBuffer/StringBuilder，它們可以儲存和操作字符串。其中String是隻讀字符串，也就意味着String引用的字符串內容是不能被改變的。而StringBuffer/StringBuilder類表示的字符串對象可以直接進行修改。StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，區別在於它是在單線程環境下使用的，因爲它的所有方面都沒有被synchronized修飾，因此它的效率也比StringBuffer要高。

面試題1 - 什麼情況下用+運算符進行字符串連接比調用StringBuffer/StringBuilder對象的append方法連接字符串性能更好？
面試題2 - 請說出下面程序的輸出。

class StringEqualTest {

    public static void main(String[] args) {
        String s1 = "Programming";
        String s2 = new String("Programming");
        String s3 = "Program";
        String s4 = "ming";
        String s5 = "Program" + "ming";
        String s6 = s3 + s4;
        System.out.println(s1 == s2);
        System.out.println(s1 == s5);
        System.out.println(s1 == s6);
        System.out.println(s1 == s6.intern());
        System.out.println(s2 == s2.intern());
    }
}

補充：解答上面的面試題需要清除兩點：1. String對象的intern方法會得到字符串對象在常量池中對應的版本的引用（如果常量池中有一個字符串與String對象的equals結果是true），如果常量池中沒有對應的字符串，則該字符串將被添加到常量池中，然後返回常量池中字符串的引用；2. 字符串的+操作其本質是創建了StringBuilder對象進行append操作，然後將拼接後的StringBuilder對象用toString方法處理成String對象，這一點可以用javap -c StringEqualTest.class命令獲得class文件對應的JVM字節碼指令就可以看出來。

20、重載（Overload）和重寫（Override）的區別。重載的方法能否根據返回類型進行區分？
答：方法的重載和重寫都是實現多態的方式，區別在於前者實現的是編譯時的多態性，而後者實現的是運行時的多態性。重載發生在一個類中，同名的方法如果有不同的參數列表（參數類型不同、參數個數不同或者二者都不同）則視爲重載；重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常（里氏代換原則）。重載對返回類型沒有特殊的要求。

面試題：華爲的面試題中曾經問過這樣一個問題 - "爲什麼不能根據返回類型來區分重載"，快說出你的答案吧！

21、描述一下JVM加載class文件的原理機制？
答：JVM中類的裝載是由類加載器（ClassLoader）和它的子類來實現的，Java中的類加載器是一個重要的Java運行時系統組件，它負責在運行時查找和裝入類文件中的類。
由於Java的跨平臺性，經過編譯的Java源程序並不是一個可執行程序，而是一個或多個類文件。當Java程序需要使用某個類時，JVM會確保這個類已經被加載、連接（驗證、準備和解析）和初始化。類的加載是指把類的.class文件中的數據讀入到內存中，通常是創建一個字節數組讀入.class文件，然後產生與所加載類對應的Class對象。加載完成後，Class對象還不完整，所以此時的類還不可用。當類被加載後就進入連接階段，這一階段包括驗證、準備（爲靜態變量分配內存並設置默認的初始值）和解析（將符號引用替換爲直接引用）三個步驟。最後JVM對類進行初始化，包括：1)如果類存在直接的父類並且這個類還沒有被初始化，那麼就先初始化父類；2)如果類中存在初始化語句，就依次執行這些初始化語句。
類的加載是由類加載器完成的，類加載器包括：根加載器（BootStrap）、擴展加載器（Extension）、系統加載器（System）和用戶自定義類加載器（java.lang.ClassLoader的子類）。從Java 2（JDK 1.2）開始，類加載過程採取了父親委託機制（PDM）。PDM更好的保證了Java平臺的安全性，在該機制中，JVM自帶的Bootstrap是根加載器，其他的加載器都有且僅有一個父類加載器。類的加載首先請求父類加載器加載，父類加載器無能爲力時才由其子類加載器自行加載。JVM不會向Java程序提供對Bootstrap的引用。下面是關於幾個類加載器的說明：

Bootstrap：一般用本地代碼實現，負責加載JVM基礎核心類庫（rt.jar）；
Extension：從java.ext.dirs系統屬性所指定的目錄中加載類庫，它的父加載器是Bootstrap；
System：又叫應用類加載器，其父類是Extension。它是應用最廣泛的類加載器。它從環境變量classpath或者系統屬性java.class.path所指定的目錄中記載類，是用戶自定義加載器的默認父加載器。

22、char 型變量中能不能存貯一箇中文漢字，爲什麼？
答：char類型可以存儲一箇中文漢字，因爲Java中使用的編碼是Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法），一個char類型佔2個字節（16比特），所以放一箇中文是沒問題的。

補充：使用Unicode意味着字符在JVM內部和外部有不同的表現形式，在JVM內部都是Unicode，當這個字符被從JVM內部轉移到外部時（例如存入文件系統中），需要進行編碼轉換。所以Java中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如InputStreamReader和OutputStreamReader，這兩個類是字節流和字符流之間的適配器類，承擔了編碼轉換的任務；對於C程序員來說，要完成這樣的編碼轉換恐怕要依賴於union（聯合體/共用體）共享內存的特徵來實現了。

23、抽象類（abstract class）和接口（interface）有什麼異同？
答：抽象類和接口都不能夠實例化，但可以定義抽象類和接口類型的引用。一個類如果繼承了某個抽象類或者實現了某個接口都需要對其中的抽象方法全部進行實現，否則該類仍然需要被聲明爲抽象類。接口比抽象類更加抽象，因爲抽象類中可以定義構造器，可以有抽象方法和具體方法，而接口中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、默認、protected、public的，而接口中的成員全都是public的。抽象類中可以定義成員變量，而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明爲抽象類，而抽象類未必要有抽象方法。

24、靜態嵌套類(Static Nested Class)和內部類（Inner Class）的不同？
答：Static Nested Class是被聲明爲靜態（static）的內部類，它可以不依賴於外部類實例被實例化。而通常的內部類需要在外部類實例化後才能實例化，其語法看起來挺詭異的，如下所示。

/**
 * 撲克類（一副撲克）
 * @author 駱昊
 *
 */
public class Poker {
    private static String[] suites = {"黑桃", "紅桃", "草花", "方塊"};
    private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

    private Card[] cards;

    /**
     * 構造器
     * 
     */
    public Poker() {
        cards = new Card[52];
        for(int i = 0; i < suites.length; i++) {
            for(int j = 0; j < faces.length; j++) {
                cards[i * 13 + j] = new Card(suites[i], faces[j]);
            }
        }
    }

    /**
     * 洗牌 （隨機亂序）
     * 
     */
    public void shuffle() {
        for(int i = 0, len = cards.length; i < len; i++) {
            int index = (int) (Math.random() * len);
            Card temp = cards[index];
            cards[index] = cards[i];
            cards[i] = temp;
        }
    }

    /**
     * 發牌
     * @param index 發牌的位置
     * 
     */
    public Card deal(int index) {
        return cards[index];
    }

    /**
     * 卡片類（一張撲克）
     * [內部類]
     * @author 駱昊
     *
     */
    public class Card {
        private String suite;   // 花色
        private int face;       // 點數

        public Card(String suite, int face) {
            this.suite = suite;
            this.face = face;
        }

        @Override
        public String toString() {
            String faceStr = "";
            switch(face) {
            case 1: faceStr = "A"; break;
            case 11: faceStr = "J"; break;
            case 12: faceStr = "Q"; break;
            case 13: faceStr = "K"; break;
            default: faceStr = String.valueOf(face);
            }
            return suite + faceStr;
        }
    }
}

測試代碼：

class PokerTest {

    public static void main(String[] args) {
        Poker poker = new Poker();
        poker.shuffle();                // 洗牌
        Poker.Card c1 = poker.deal(0);  // 發第一張牌
        // 對於非靜態內部類Card
        // 只有通過其外部類Poker對象才能創建Card對象
        Poker.Card c2 = poker.new Card("紅心", 1);    // 自己創建一張牌

        System.out.println(c1);     // 洗牌後的第一張
        System.out.println(c2);     // 打印: 紅心A
    }
}

面試題 - 下面的代碼哪些地方會產生編譯錯誤？

class Outer {

    class Inner {}

    public static void foo() { new Inner(); }

    public void bar() { new Inner(); }

    public static void main(String[] args) {
        new Inner();
    }
}

注意：Java中非靜態內部類對象的創建要依賴其外部類對象，上面的面試題中foo和main方法都是靜態方法，靜態方法中沒有this，也就是說沒有所謂的外部類對象，因此無法創建內部類對象，如果要在靜態方法中創建內部類對象，可以這樣做：

    new Outer().new Inner();

25、Java 中會存在內存泄漏嗎，請簡單描述。
答：理論上Java因爲有垃圾回收機制（GC）不會存在內存泄露問題（這也是Java被廣泛使用於服務器端編程的一個重要原因）；然而在實際開發中，可能會存在無用但可達的對象，這些對象不能被GC回收，因此也會導致內存泄露的發生。例如Hibernate的Session（一級緩存）中的對象屬於持久態，垃圾回收器是不會回收這些對象的，然而這些對象中可能存在無用的垃圾對象，如果不及時關閉（close）或清空（flush）一級緩存就可能導致內存泄露。下面例子中的代碼也會導致內存泄露。

import java.util.Arrays;
import java.util.EmptyStackException;

public class MyStack<T> {
    private T[] elements;
    private int size = 0;

    private static final int INIT_CAPACITY = 16;

    public MyStack() {
        elements = (T[]) new Object[INIT_CAPACITY];
    }

    public void push(T elem) {
        ensureCapacity();
        elements[size++] = elem;
    }

    public T pop() {
        if(size == 0) 
            throw new EmptyStackException();
        return elements[--size];
    }

    private void ensureCapacity() {
        if(elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

上面的代碼實現了一個棧（先進後出（FILO））結構，乍看之下似乎沒有什麼明顯的問題，它甚至可以通過你編寫的各種單元測試。然而其中的pop方法卻存在內存泄露的問題，當我們用pop方法彈出棧中的對象時，該對象不會被當作垃圾回收，即使使用棧的程序不再引用這些對象，因爲棧內部維護着對這些對象的過期引用（obsolete reference）。在支持垃圾回收的語言中，內存泄露是很隱蔽的，這種內存泄露其實就是無意識的對象保持。如果一個對象引用被無意識的保留起來了，那麼垃圾回收器不會處理這個對象，也不會處理該對象引用的其他對象，即使這樣的對象只有少數幾個，也可能會導致很多的對象被排除在垃圾回收之外，從而對性能造成重大影響，極端情況下會引發Disk Paging（物理內存與硬盤的虛擬內存交換數據），甚至造成OutOfMemoryError。

26、抽象的（abstract）方法是否可同時是靜態的（static）,是否可同時是本地方法（native），是否可同時被synchronized修飾？
答：都不能。抽象方法需要子類重寫，而靜態的方法是無法被重寫的，因此二者是矛盾的。本地方法是由本地代碼（如C代碼）實現的方法，而抽象方法是沒有實現的，也是矛盾的。synchronized和方法的實現細節有關，抽象方法不涉及實現細節，因此也是相互矛盾的。

27、闡述靜態變量和實例變量的區別。
答：靜態變量是被static修飾符修飾的變量，也稱爲類變量，它屬於類，不屬於類的任何一個對象，一個類不管創建多少個對象，靜態變量在內存中有且僅有一個拷貝；實例變量必須依存於某一實例，需要先創建對象然後通過對象才能訪問到它。靜態變量可以實現讓多個對象共享內存。

補充：在Java開發中，上下文類和工具類中通常會有大量的靜態成員。

28、是否可以從一個靜態（static）方法內部發出對非靜態（non-static）方法的調用？
答：不可以，靜態方法只能訪問靜態成員，因爲非靜態方法的調用要先創建對象，在調用靜態方法時可能對象並沒有被初始化。

29、如何實現對象克隆？
答：有兩種方式：
1). 實現Cloneable接口並重寫Object類中的clone()方法；
2). 實現Serializable接口，通過對象的序列化和反序列化實現克隆，可以實現真正的深度克隆，代碼如下。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class MyUtil {

    private MyUtil() {
        throw new AssertionError();
    }

    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T obj) throws Exception {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bout);
        oos.writeObject(obj);

        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject();

        // 說明：調用ByteArrayInputStream或ByteArrayOutputStream對象的close方法沒有任何意義
        // 這兩個基於內存的流只要垃圾回收器清理對象就能夠釋放資源，這一點不同於對外部資源（如文件流）的釋放
    }
}

下面是測試代碼：

import java.io.Serializable;

/**
 * 人類
 * @author 駱昊
 *
 */
class Person implements Serializable {
    private static final long serialVersionUID = -9102017020286042305L;

    private String name;    // 姓名
    private int age;        // 年齡
    private Car car;        // 座駕

    public Person(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
    }

}

/**
 * 小汽車類
 * @author 駱昊
 *
 */
class Car implements Serializable {
    private static final long serialVersionUID = -5713945027627603702L;

    private String brand;       // 品牌
    private int maxSpeed;       // 最高時速

    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
    }

}

class CloneTest {

    public static void main(String[] args) {
        try {
            Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
            Person p2 = MyUtil.clone(p1);   // 深度克隆
            p2.getCar().setBrand("BYD");
            // 修改克隆的Person對象p2關聯的汽車對象的品牌屬性
            // 原來的Person對象p1關聯的汽車不會受到任何影響
            // 因爲在克隆Person對象時其關聯的汽車對象也被克隆了
            System.out.println(p1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：基於序列化和反序列化實現的克隆不僅僅是深度克隆，更重要的是通過泛型限定，可以檢查出要克隆的對象是否支持序列化，這項檢查是編譯器完成的，不是在運行時拋出異常，這種是方案明顯優於使用Object類的clone方法克隆對象。讓問題在編譯的時候暴露出來總是好過把問題留到運行時。

30、GC是什麼？爲什麼要有GC？
答：GC是垃圾收集的意思，內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會導致程序或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測對象是否超過作用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操作方法。Java程序員不用擔心內存管理，因爲垃圾收集器會自動進行管理。要請求垃圾收集，可以調用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以屏蔽掉顯示的垃圾回收調用。
垃圾回收可以有效的防止內存泄露，有效的使用可以使用的內存。垃圾回收器通常是作爲一個單獨的低優先級的線程運行，不可預知的情況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清除和回收，程序員不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。在Java誕生初期，垃圾回收是Java最大的亮點之一，因爲服務器端的編程需要有效的防止內存泄露問題，然而時過境遷，如今Java的垃圾回收機制已經成爲被詬病的東西。移動智能終端用戶通常覺得iOS的系統比Android系統有更好的用戶體驗，其中一個深層次的原因就在於Android系統中垃圾回收的不可預知性。

補充：垃圾回收機制有很多種，包括：分代複製垃圾回收、標記垃圾回收、增量垃圾回收等方式。標準的Java進程既有棧又有堆。棧保存了原始型局部變量，堆保存了要創建的對象。Java平臺對堆內存回收和再利用的基本算法被稱爲標記和清除，但是Java對其進行了改進，採用“分代式垃圾收集”。這種方法會跟Java對象的生命週期將堆內存劃分爲不同的區域，在垃圾收集過程中，可能會將對象移動到不同區域：
- 伊甸園（Eden）：這是對象最初誕生的區域，並且對大多數對象來說，這裏是它們唯一存在過的區域。
- 倖存者樂園（Survivor）：從伊甸園倖存下來的對象會被挪到這裏。
- 終身頤養園（Tenured）：這是足夠老的倖存對象的歸宿。年輕代收集（Minor-GC）過程是不會觸及這個地方的。當年輕代收集不能把對象放進終身頤養園時，就會觸發一次完全收集（Major-GC），這裏可能還會牽扯到壓縮，以便爲大對象騰出足夠的空間。

與垃圾回收相關的JVM參數：

-Xms / -Xmx — 堆的初始大小 / 堆的最大大小
-Xmn — 堆中年輕代的大小
-XX:-DisableExplicitGC — 讓System.gc()不產生任何作用
-XX:+PrintGCDetails — 打印GC的細節
-XX:+PrintGCDateStamps — 打印GC操作的時間戳
-XX:NewSize / XX:MaxNewSize — 設置新生代大小/新生代最大大小
-XX:NewRatio — 可以設置老生代和新生代的比例
-XX:PrintTenuringDistribution — 設置每次新生代GC後輸出倖存者樂園中對象年齡的分佈
-XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：設置老年代閥值的初始值和最大值
-XX:TargetSurvivorRatio：設置倖存區的目標使用率

31、String s = new String("xyz");創建了幾個字符串對象？
答：兩個對象，一個是靜態區的"xyz"，一個是用new創建在堆上的對象。

32、接口是否可繼承（extends）接口？抽象類是否可實現（implements）接口？抽象類是否可繼承具體類（concrete class）？
答：接口可以繼承接口，而且支持多重繼承。抽象類可以實現(implements)接口，抽象類可繼承具體類也可以繼承抽象類。

33、一個".java"源文件中是否可以包含多個類（不是內部類）？有什麼限制？
答：可以，但一個源文件中最多隻能有一個公開類（public class）而且文件名必須和公開類的類名完全保持一致。

34、Anonymous Inner Class(匿名內部類)是否可以繼承其它類？是否可以實現接口？
答：可以繼承其他類或實現其他接口，在Swing編程和Android開發中常用此方式來實現事件監聽和回調。

35、內部類可以引用它的包含類（外部類）的成員嗎？有沒有什麼限制？
答：一個內部類對象可以訪問創建它的外部類對象的成員，包括私有成員。

36、Java 中的final關鍵字有哪些用法？
答：(1)修飾類：表示該類不能被繼承；(2)修飾方法：表示方法不能被重寫；(3)修飾變量：表示變量只能一次賦值以後值不能被修改（常量）。

37、指出下面程序的運行結果。

class A {

    static {
        System.out.print("1");
    }

    public A() {
        System.out.print("2");
    }
}

class B extends A{

    static {
        System.out.print("a");
    }

    public B() {
        System.out.print("b");
    }
}

public class Hello {

    public static void main(String[] args) {
        A ab = new B();
        ab = new B();
    }

}

答：執行結果：1a2b2b。創建對象時構造器的調用順序是：先初始化靜態成員，然後調用父類構造器，再初始化非靜態成員，最後調用自身構造器。

提示：如果不能給出此題的正確答案，說明之前第21題Java類加載機制還沒有完全理解，趕緊再看看吧。

38、數據類型之間的轉換：
- 如何將字符串轉換爲基本數據類型？
- 如何將基本數據類型轉換爲字符串？
答：
- 調用基本數據類型對應的包裝類中的方法parseXXX(String)或valueOf(String)即可返回相應基本類型；
- 一種方法是將基本數據類型與空字符串（""）連接（+）即可獲得其所對應的字符串；另一種方法是調用String 類中的valueOf()方法返回相應字符串

39、如何實現字符串的反轉及替換？
答：方法很多，可以自己寫實現也可以使用String或StringBuffer/StringBuilder中的方法。有一道很常見的面試題是用遞歸實現字符串反轉，代碼如下所示：

    public static String reverse(String originStr) {
        if(originStr == null || originStr.length() <= 1) 
            return originStr;
        return reverse(originStr.substring(1)) + originStr.charAt(0);
    }

40、怎樣將GB2312編碼的字符串轉換爲ISO-8859-1編碼的字符串？
答：代碼如下所示：

String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

41、日期和時間：
- 如何取得年月日、小時分鐘秒？
- 如何取得從1970年1月1日0時0分0秒到現在的毫秒數？
- 如何取得某月的最後一天？
- 如何格式化日期？
答：
問題1：創建java.util.Calendar 實例，調用其get()方法傳入不同的參數即可獲得參數所對應的值。Java 8中可以使用java.time.LocalDateTimel來獲取，代碼如下所示。

public class DateTimeTest {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));    // 0 - 11
        System.out.println(cal.get(Calendar.DATE));
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));

        // Java 8
        LocalDateTime dt = LocalDateTime.now();
        System.out.println(dt.getYear());
        System.out.println(dt.getMonthValue());     // 1 - 12
        System.out.println(dt.getDayOfMonth());
        System.out.println(dt.getHour());
        System.out.println(dt.getMinute());
        System.out.println(dt.getSecond());
    }
}

問題2：以下方法均可獲得該毫秒數。

Calendar.getInstance().getTimeInMillis();
System.currentTimeMillis();
Clock.systemDefaultZone().millis(); // Java 8

問題3：代碼如下所示。

Calendar time = Calendar.getInstance();
time.getActualMaximum(Calendar.DAY_OF_MONTH);

問題4：利用java.text.DataFormat 的子類（如SimpleDateFormat類）中的format(Date)方法可將日期格式化。Java 8中可以用java.time.format.DateTimeFormatter來格式化時間日期，代碼如下所示。

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;

class DateFormatTest {

    public static void main(String[] args) {
        SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
        Date date1 = new Date();
        System.out.println(oldFormatter.format(date1));

        // Java 8
        DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
        LocalDate date2 = LocalDate.now();
        System.out.println(date2.format(newFormatter));
    }
}

補充：Java的時間日期API一直以來都是被詬病的東西，爲了解決這一問題，Java 8中引入了新的時間日期API，其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等類，這些的類的設計都使用了不變模式，因此是線程安全的設計。如果不理解這些內容，可以參考我的另一篇文章《關於Java併發編程的總結和思考》。

42、打印昨天的當前時刻。
答：

import java.util.Calendar;

class YesterdayCurrent {
    public static void main(String[] args){
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -1);
        System.out.println(cal.getTime());
    }
}

在Java 8中，可以用下面的代碼實現相同的功能。

import java.time.LocalDateTime;

class YesterdayCurrent {

    public static void main(String[] args) {
        LocalDateTime today = LocalDateTime.now();
        LocalDateTime yesterday = today.minusDays(1);

        System.out.println(yesterday);
    }
}

43、比較一下Java和JavaSciprt。
答：JavaScript 與Java是兩個公司開發的不同的兩個產品。Java 是原Sun Microsystems公司推出的面向對象的程序設計語言，特別適合於互聯網應用程序開發；而JavaScript是Netscape公司的產品，爲了擴展Netscape瀏覽器的功能而開發的一種可以嵌入Web頁面中運行的基於對象和事件驅動的解釋性語言。JavaScript的前身是LiveScript；而Java的前身是Oak語言。
下面對兩種語言間的異同作如下比較：
- 基於對象和麪向對象：Java是一種真正的面向對象的語言，即使是開發簡單的程序，必須設計對象；JavaScript是種腳本語言，它可以用來製作與網絡無關的，與用戶交互作用的複雜軟件。它是一種基於對象（Object-Based）和事件驅動（Event-Driven）的編程語言，因而它本身提供了非常豐富的內部對象供設計人員使用。
- 解釋和編譯：Java的源代碼在執行之前，必須經過編譯。JavaScript是一種解釋性編程語言，其源代碼不需經過編譯，由瀏覽器解釋執行。（目前的瀏覽器幾乎都使用了JIT（即時編譯）技術來提升JavaScript的運行效率）
- 強類型變量和類型弱變量：Java採用強類型變量檢查，即所有變量在編譯之前必須作聲明；JavaScript中變量是弱類型的，甚至在使用變量前可以不作聲明，JavaScript的解釋器在運行時檢查推斷其數據類型。
- 代碼格式不一樣。

補充：上面列出的四點是網上流傳的所謂的標準答案。其實Java和JavaScript最重要的區別是一個是靜態語言，一個是動態語言。目前的編程語言的發展趨勢是函數式語言和動態語言。在Java中類（class）是一等公民，而JavaScript中函數（function）是一等公民，因此JavaScript支持函數式編程，可以使用Lambda函數和閉包（closure），當然Java 8也開始支持函數式編程，提供了對Lambda表達式以及函數式接口的支持。對於這類問題，在面試的時候最好還是用自己的語言回答會更加靠譜，不要背網上所謂的標準答案。

44、什麼時候用斷言（assert）？
答：斷言在軟件開發中是一種常用的調試方式，很多開發語言中都支持這種機制。一般來說，斷言用於保證程序最基本、關鍵的正確性。斷言檢查通常在開發和測試時開啓。爲了保證程序的執行效率，在軟件發佈後斷言檢查通常是關閉的。斷言是一個包含布爾表達式的語句，在執行這個語句時假定該表達式爲true；如果表達式的值爲false，那麼系統會報告一個AssertionError。斷言的使用如下面的代碼所示：

assert(a > 0); // throws an AssertionError if a <= 0

斷言可以有兩種形式：
assert Expression1;
assert Expression1 : Expression2 ;
Expression1 應該總是產生一個布爾值。
Expression2 可以是得出一個值的任意表達式；這個值用於生成顯示更多調試信息的字符串消息。

要在運行時啓用斷言，可以在啓動JVM時使用-enableassertions或者-ea標記。要在運行時選擇禁用斷言，可以在啓動JVM時使用-da或者-disableassertions標記。要在系統類中啓用或禁用斷言，可使用-esa或-dsa標記。還可以在包的基礎上啓用或者禁用斷言。

注意：斷言不應該以任何方式改變程序的狀態。簡單的說，如果希望在不滿足某些條件時阻止代碼的執行，就可以考慮用斷言來阻止它。

45、Error和Exception有什麼區別？
答：Error表示系統級的錯誤和程序不必處理的異常，是恢復不是不可能但很困難的情況下的一種嚴重問題；比如內存溢出，不可能指望程序能處理這樣的情況；Exception表示需要捕捉或者需要程序進行處理的異常，是一種設計或實現問題；也就是說，它表示如果程序運行正常，從不會發生的情況。

面試題：2005年摩托羅拉的面試中曾經問過這麼一個問題“If a process reports a stack overflow run-time error, what’s the most possible cause?”，給了四個選項a. lack of memory; b. write on an invalid memory space; c. recursive function calling; d. array index out of boundary. Java程序在運行時也可能會遭遇StackOverflowError，這是一個無法恢復的錯誤，只能重新修改代碼了，這個面試題的答案是c。如果寫了不能迅速收斂的遞歸，則很有可能引發棧溢出的錯誤，如下所示：

class StackOverflowErrorTest {

    public static void main(String[] args) {
        main(null);
    }
}

提示：用遞歸編寫程序時一定要牢記兩點：1. 遞歸公式；2. 收斂條件（什麼時候就不再繼續遞歸）。

46、try{}裏有一個return語句，那麼緊跟在這個try後的finally{}裏的代碼會不會被執行，什麼時候被執行，在return前還是後?
答：會執行，在方法返回調用者前執行。

注意：在finally中改變返回值的做法是不好的，因爲如果存在finally代碼塊，try中的return語句不會立馬返回調用者，而是記錄下返回值待finally代碼塊執行完畢之後再向調用者返回其值，然後如果在finally中修改了返回值，就會返回修改後的值。顯然，在finally中返回或者修改返回值會對程序造成很大的困擾，C#中直接用編譯錯誤的方式來阻止程序員幹這種齷齪的事情，Java中也可以通過提升編譯器的語法檢查級別來產生警告或錯誤，Eclipse中可以在如圖所示的地方進行設置，強烈建議將此項設置爲編譯錯誤。

47、Java語言如何進行異常處理，關鍵字：throws、throw、try、catch、finally分別如何使用？
答：Java通過面向對象的方法進行異常處理，把各種不同的異常進行分類，並提供了良好的接口。在Java中，每個異常都是一個對象，它是Throwable類或其子類的實例。當一個方法出現異常後便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法可以捕獲到這個異常並可以對其進行處理。Java的異常處理是通過5個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程序，如果系統會拋出（throw）一個異常對象，可以通過它的類型來捕獲（catch）它，或通過總是執行代碼塊（finally）來處理；try用來指定一塊預防所有異常的程序；catch子句緊跟在try塊後面，用來指定你想要捕獲的異常的類型；throw語句用來明確地拋出一個異常；throws用來聲明一個方法可能拋出的各種異常（當然聲明異常時允許無病呻吟）；finally爲確保一段代碼不管發生什麼異常狀況都要被執行；try語句可以嵌套，每當遇到一個try語句，異常的結構就會被放入異常棧中，直到所有的try語句都完成。如果下一級的try語句沒有對某種異常進行處理，異常棧就會執行出棧操作，直到遇到有處理這種異常的try語句或者最終將異常拋給JVM。

48、運行時異常與受檢異常有何異同？
答：異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤，只要程序設計得沒有問題通常就不會發生。受檢異常跟程序運行的上下文環境有關，即使程序設計無誤，仍然可能因使用的問題而引發。Java編譯器要求方法必須聲明拋出可能發生的受檢異常，但是並不要求必須聲明拋出未被捕獲的運行時異常。異常和繼承一樣，是面向對象程序設計中經常被濫用的東西，在Effective Java中對異常的使用給出了以下指導原則：
- 不要將異常處理用於正常的控制流（設計良好的API不應該強迫它的調用者爲了正常的控制流而使用異常）
- 對可以恢復的情況使用受檢異常，對編程錯誤使用運行時異常
- 避免不必要的使用受檢異常（可以通過一些狀態檢測手段來避免異常的發生）
- 優先使用標準的異常
- 每個方法拋出的異常都要有文檔
- 保持異常的原子性
- 不要在catch中忽略掉捕獲到的異常

49、列出一些你常見的運行時異常？
答：
- ArithmeticException（算術異常）
- ClassCastException （類轉換異常）
- IllegalArgumentException （非法參數異常）
- IndexOutOfBoundsException （下標越界異常）
- NullPointerException （空指針異常）
- SecurityException （安全異常）

50、闡述final、finally、finalize的區別。
答：
- final：修飾符（關鍵字）有三種用法：如果一個類被聲明爲final，意味着它不能再派生出新的子類，即不能被繼承，因此它和abstract是反義詞。將變量聲明爲final，可以保證它們在使用中不被改變，被聲明爲final的變量必須在聲明時給定初值，而在以後的引用中只能讀取不可修改。被聲明爲final的方法也同樣只能使用，不能在子類中被重寫。
- finally：通常放在try…catch…的後面構造總是執行代碼塊，這就意味着程序無論正常執行還是發生異常，這裏的代碼只要JVM不關閉都能執行，可以將釋放外部資源的代碼寫在finally塊中。
- finalize：Object類中定義的方法，Java中允許使用finalize()方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在銷燬對象時調用的，通過重寫finalize()方法可以整理系統資源或者執行其他清理工作。

51、類ExampleA繼承Exception，類ExampleB繼承ExampleA。
有如下代碼片斷：

try {
    throw new ExampleB("b")
} catch（ExampleA e）{
    System.out.println("ExampleA");
} catch（Exception e）{
    System.out.println("Exception");
}

請問執行此段代碼的輸出是什麼？
答：輸出：ExampleA。（根據里氏代換原則[能使用父類型的地方一定能使用子類型]，抓取ExampleA類型異常的catch塊能夠抓住try塊中拋出的ExampleB類型的異常）

面試題 - 說出下面代碼的運行結果。（此題的出處是《Java編程思想》一書）

class Annoyance extends Exception {}
class Sneeze extends Annoyance {}

class Human {

    public static void main(String[] args) 
        throws Exception {
        try {
            try {
                throw new Sneeze();
            } 
            catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        } 
        catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
            return ;
        }
        finally {
            System.out.println("Hello World!");
        }
    }
}

52、List、Set、Map是否繼承自Collection接口？
答：List、Set 是，Map 不是。Map是鍵值對映射容器，與List和Set有明顯的區別，而Set存儲的零散的元素且不允許有重複元素（數學中的集合也是如此），List是線性結構的容器，適用於按數值索引訪問元素的情形。

53、闡述ArrayList、Vector、LinkedList的存儲性能和特性。
答：ArrayList 和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector中的方法由於添加了synchronized修飾，因此Vector是線程安全的容器，但性能上較ArrayList差，因此已經是Java中的遺留容器。LinkedList使用雙向鏈表實現存儲（將內存中零散的內存單元通過附加的引用關聯起來，形成一個可以按序號索引的線性結構，這種鏈式存儲方式與數組的連續存儲方式相比，內存的利用率更高），按序號索引數據需要進行前向或後向遍歷，但是插入數據時只需要記錄本項的前後項即可，所以插入速度較快。Vector屬於遺留容器（Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遺留容器），已經不推薦使用，但是由於ArrayList和LinkedListed都是非線程安全的，如果遇到多個線程操作同一個容器的場景，則可以通過工具類Collections中的synchronizedList方法將其轉換成線程安全的容器後再使用（這是對裝潢模式的應用，將已有對象傳入另一個類的構造器中創建新的對象來增強實現）。

補充：遺留容器中的Properties類和Stack類在設計上有嚴重的問題，Properties是一個鍵和值都是字符串的特殊的鍵值對映射，在設計上應該是關聯一個Hashtable並將其兩個泛型參數設置爲String類型，但是Java API中的Properties直接繼承了Hashtable，這很明顯是對繼承的濫用。這裏複用代碼的方式應該是Has-A關係而不是Is-A關係，另一方面容器都屬於工具類，繼承工具類本身就是一個錯誤的做法，使用工具類最好的方式是Has-A關係（關聯）或Use-A關係（依賴）。同理，Stack類繼承Vector也是不正確的。Sun公司的工程師們也會犯這種低級錯誤，讓人唏噓不已。

54、Collection和Collections的區別？
答：Collection是一個接口，它是Set、List等容器的父接口；Collections是個一個工具類，提供了一系列的靜態方法來輔助容器操作，這些方法包括對容器的搜索、排序、線程安全化等等。

55、List、Map、Set三個接口存取元素時，各有什麼特點？
答：List以特定索引來存取元素，可以有重複元素。Set不能存放重複元素（用對象的equals()方法來區分元素是否重複）。Map保存鍵值對（key-value pair）映射，映射關係可以是一對一或多對一。Set和Map容器都有基於哈希存儲和排序樹的兩種實現版本，基於哈希存儲的版本理論存取時間複雜度爲O(1)，而基於排序樹版本的實現在插入或刪除元素時會按照元素或元素的鍵（key）構成排序樹從而達到排序和去重的效果。

56、TreeMap和TreeSet在排序時如何比較元素？Collections工具類中的sort()方法如何比較元素？
答：TreeSet要求存放的對象所屬的類必須實現Comparable接口，該接口提供了比較元素的compareTo()方法，當插入元素時會回調該方法比較元素的大小。TreeMap要求存放的鍵值對映射的鍵必須實現Comparable接口從而根據鍵對元素進行排序。Collections工具類的sort方法有兩種重載的形式，第一種要求傳入的待排序容器中存放的對象比較實現Comparable接口以實現元素的比較；第二種不強制性的要求容器中的元素必須可比較，但是要求傳入第二個參數，參數是Comparator接口的子類型（需要重寫compare方法實現元素的比較），相當於一個臨時定義的排序規則，其實就是通過接口注入比較元素大小的算法，也是對回調模式的應用（Java中對函數式編程的支持）。
例子1：


public class Student implements Comparable<Student> {
    private String name;        // 姓名
    private int age;            // 年齡

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Student o) {
        return this.age - o.age; // 比較年齡(年齡的升序)
    }

}

import java.util.Set;
import java.util.TreeSet;

class Test01 {

    public static void main(String[] args) {
        Set<Student> set = new TreeSet<>();     // Java 7的鑽石語法(構造器後面的尖括號中不需要寫類型)
        set.add(new Student("Hao LUO", 33));
        set.add(new Student("XJ WANG", 32));
        set.add(new Student("Bruce LEE", 60));
        set.add(new Student("Bob YANG", 22));

        for(Student stu : set) {
            System.out.println(stu);
        }
//      輸出結果: 
//      Student [name=Bob YANG, age=22]
//      Student [name=XJ WANG, age=32]
//      Student [name=Hao LUO, age=33]
//      Student [name=Bruce LEE, age=60]
    }
}

例子2：

public class Student {
    private String name;    // 姓名
    private int age;        // 年齡

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 獲取學生姓名
     */
    public String getName() {
        return name;
    }

    /**
     * 獲取學生年齡
     */
    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Test02 {

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();     // Java 7的鑽石語法(構造器後面的尖括號中不需要寫類型)
        list.add(new Student("Hao LUO", 33));
        list.add(new Student("XJ WANG", 32));
        list.add(new Student("Bruce LEE", 60));
        list.add(new Student("Bob YANG", 22));

        // 通過sort方法的第二個參數傳入一個Comparator接口對象
        // 相當於是傳入一個比較對象大小的算法到sort方法中
        // 由於Java中沒有函數指針、仿函數、委託這樣的概念
        // 因此要將一個算法傳入一個方法中唯一的選擇就是通過接口回調
        Collections.sort(list, new Comparator<Student> () {

            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());    // 比較學生姓名
            }
        });

        for(Student stu : list) {
            System.out.println(stu);
        }
//      輸出結果: 
//      Student [name=Bob YANG, age=22]
//      Student [name=Bruce LEE, age=60]
//      Student [name=Hao LUO, age=33]
//      Student [name=XJ WANG, age=32]
    }
}

57、Thread類的sleep()方法和對象的wait()方法都可以讓線程暫停執行，它們有什麼區別?
答：sleep()方法（休眠）是線程類（Thread）的靜態方法，調用此方法會讓當前線程暫停執行指定的時間，將執行機會（CPU）讓給其他線程，但是對象的鎖依然保持，因此休眠時間結束後會自動恢復（線程回到就緒狀態，請參考第66題中的線程狀態轉換圖）。wait()是Object類的方法，調用對象的wait()方法導致當前線程放棄對象的鎖（線程暫停執行），進入對象的等待池（wait pool），只有調用對象的notify()方法（或notifyAll()方法）時才能喚醒等待池中的線程進入等鎖池（lock pool），如果線程重新獲得對象的鎖就可以進入就緒狀態。

補充：可能不少人對什麼是進程，什麼是線程還比較模糊，對於爲什麼需要多線程編程也不是特別理解。簡單的說：進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動，是操作系統進行資源分配和調度的一個獨立單位；線程是進程的一個實體，是CPU調度和分派的基本單位，是比進程更小的能獨立運行的基本單位。線程的劃分尺度小於進程，這使得多線程程序的併發性高；進程在執行時通常擁有獨立的內存單元，而線程之間可以共享內存。使用多線程的編程通常能夠帶來更好的性能和用戶體驗，但是多線程的程序對於其他程序是不友好的，因爲它可能佔用了更多的CPU資源。當然，也不是線程越多，程序的性能就越好，因爲線程之間的調度和切換也會浪費CPU時間。時下很時髦的Node.js就採用了單線程異步I/O的工作模式。

58、線程的sleep()方法和yield()方法有什麼區別？
答：
① sleep()方法給其他線程運行機會時不考慮線程的優先級，因此會給低優先級的線程以運行的機會；yield()方法只會給相同優先級或更高優先級的線程以運行的機會；
② 線程執行sleep()方法後轉入阻塞（blocked）狀態，而執行yield()方法後轉入就緒（ready）狀態；
③ sleep()方法聲明拋出InterruptedException，而yield()方法沒有聲明任何異常；
④ sleep()方法比yield()方法（跟操作系統CPU調度相關）具有更好的可移植性。

59、當一個線程進入一個對象的synchronized方法A之後，其它線程是否可進入此對象的synchronized方法B？
答：不能。其它線程只能訪問該對象的非同步方法，同步方法則不能進入。因爲非靜態方法上的synchronized修飾符要求執行方法時要獲得對象的鎖，如果已經進入A方法說明對象鎖已經被取走，那麼試圖進入B方法的線程就只能在等鎖池（注意不是等待池哦）中等待對象的鎖。

60、請說出與線程同步以及線程調度相關的方法。
答：
- wait()：使一個線程處於等待（阻塞）狀態，並且釋放所持有的對象的鎖；
- sleep()：使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要處理InterruptedException異常；
- notify()：喚醒一個處於等待狀態的線程，當然在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且與優先級無關；
- notityAll()：喚醒所有處於等待狀態的線程，該方法並不是將對象的鎖給所有線程，而是讓它們競爭，只有獲得鎖的線程才能進入就緒狀態；

提示：關於Java多線程和併發編程的問題，建議大家看我的另一篇文章《關於Java併發編程的總結和思考》。
補充：Java 5通過Lock接口提供了顯式的鎖機制（explicit lock），增強了靈活性以及對線程的協調。Lock接口中定義了加鎖（lock()）和解鎖（unlock()）的方法，同時還提供了newCondition()方法來產生用於線程之間通信的Condition對象；此外，Java 5還提供了信號量機制（semaphore），信號量可以用來限制對某個共享資源進行訪問的線程的數量。在對資源進行訪問之前，線程必須得到信號量的許可（調用Semaphore對象的acquire()方法）；在完成對資源的訪問後，線程必須向信號量歸還許可（調用Semaphore對象的release()方法）。

下面的例子演示了100個線程同時向一個銀行賬戶中存入1元錢，在沒有使用同步機制和使用同步機制情況下的執行情況。

銀行賬戶類：

/**
 * 銀行賬戶
 * @author 駱昊
 *
 */
public class Account {
    private double balance;     // 賬戶餘額

    /**
     * 存款
     * @param money 存入金額
     */
    public void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 模擬此業務需要一段處理時間
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }

    /**
     * 獲得賬戶餘額
     */
    public double getBalance() {
        return balance;
    }
}

存錢線程類：

/**
 * 存錢線程
 * @author 駱昊
 *
 */
public class AddMoneyThread implements Runnable {
    private Account account;    // 存入賬戶
    private double money;       // 存入金額

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }

    @Override
    public void run() {
        account.deposit(money);
    }

}

測試類：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test01 {

    public static void main(String[] args) {
        Account account = new Account();
        ExecutorService service = Executors.newFixedThreadPool(100);

        for(int i = 1; i <= 100; i++) {
            service.execute(new AddMoneyThread(account, 1));
        }

        service.shutdown();

        while(!service.isTerminated()) {}

        System.out.println("賬戶餘額: " + account.getBalance());
    }
}

在沒有同步的情況下，執行結果通常是顯示賬戶餘額在10元以下，出現這種狀況的原因是，當一個線程A試圖存入1元的時候，另外一個線程B也能夠進入存款的方法中，線程B讀取到的賬戶餘額仍然是線程A存入1元錢之前的賬戶餘額，因此也是在原來的餘額0上面做了加1元的操作，同理線程C也會做類似的事情，所以最後100個線程執行結束時，本來期望賬戶餘額爲100元，但實際得到的通常在10元以下（很可能是1元哦）。解決這個問題的辦法就是同步，當一個線程對銀行賬戶存錢時，需要將此賬戶鎖定，待其操作完成後才允許其他的線程進行操作，代碼有如下幾種調整方案：

在銀行賬戶的存款（deposit）方法上同步（synchronized）關鍵字

/**
 * 銀行賬戶
 * @author 駱昊
 *
 */
public class Account {
    private double balance;     // 賬戶餘額

    /**
     * 存款
     * @param money 存入金額
     */
    public synchronized void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 模擬此業務需要一段處理時間
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }

    /**
     * 獲得賬戶餘額
     */
    public double getBalance() {
        return balance;
    }
}

在線程調用存款方法時對銀行賬戶進行同步

/**
 * 存錢線程
 * @author 駱昊
 *
 */
public class AddMoneyThread implements Runnable {
    private Account account;    // 存入賬戶
    private double money;       // 存入金額

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }

    @Override
    public void run() {
        synchronized (account) {
            account.deposit(money); 
        }
    }

}

通過Java 5顯示的鎖機制，爲每個銀行賬戶創建一個鎖對象，在存款操作進行加鎖和解鎖的操作

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 銀行賬戶
 * 
 * @author 駱昊
 *
 */
public class Account {
    private Lock accountLock = new ReentrantLock();
    private double balance; // 賬戶餘額

    /**
     * 存款
     * 
     * @param money
     *            存入金額
     */
    public void deposit(double money) {
        accountLock.lock();
        try {
            double newBalance = balance + money;
            try {
                Thread.sleep(10); // 模擬此業務需要一段處理時間
            }
            catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            balance = newBalance;
        }
        finally {
            accountLock.unlock();
        }
    }

    /**
     * 獲得賬戶餘額
     */
    public double getBalance() {
        return balance;
    }
}

按照上述三種方式對代碼進行修改後，重寫執行測試代碼Test01，將看到最終的賬戶餘額爲100元。當然也可以使用Semaphore或CountdownLatch來實現同步。

61、編寫多線程程序有幾種實現方式？
答：Java 5以前實現多線程有兩種實現方法：一種是繼承Thread類；另一種是實現Runnable接口。兩種方式都要通過重寫run()方法來定義線程的行爲，推薦使用後者，因爲Java中的繼承是單繼承，一個類有一個父類，如果繼承了Thread類就無法再繼承其他類了，顯然使用Runnable接口更爲靈活。

補充：Java 5以後創建線程還有第三種方式：實現Callable接口，該接口中的call方法可以在線程執行結束時產生一個返回值，代碼如下所示：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


class MyTask implements Callable<Integer> {
    private int upperBounds;

    public MyTask(int upperBounds) {
        this.upperBounds = upperBounds;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0; 
        for(int i = 1; i <= upperBounds; i++) {
            sum += i;
        }
        return sum;
    }

}

class Test {

    public static void main(String[] args) throws Exception {
        List<Future<Integer>> list = new ArrayList<>();
        ExecutorService service = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 10; i++) {
            list.add(service.submit(new MyTask((int) (Math.random() * 100))));
        }

        int sum = 0;
        for(Future<Integer> future : list) {
            // while(!future.isDone()) ;
            sum += future.get();
        }

        System.out.println(sum);
    }
}

62、synchronized關鍵字的用法？
答：synchronized關鍵字可以將對象或者方法標記爲同步，以實現對對象和方法的互斥訪問，可以用synchronized(對象) { … }定義同步代碼塊，或者在聲明方法時將synchronized作爲方法的修飾符。在第60題的例子中已經展示了synchronized關鍵字的用法。

63、舉例說明同步和異步。
答：如果系統中存在臨界資源（資源數量少於競爭資源的線程數量的資源），例如正在寫的數據以後可能被另一個線程讀到，或者正在讀的數據可能已經被另一個線程寫過了，那麼這些數據就必須進行同步存取（數據庫操作中的排他鎖就是最好的例子）。當應用程序在對象上調用了一個需要花費很長時間來執行的方法，並且不希望讓程序等待方法的返回時，就應該使用異步編程，在很多情況下采用異步途徑往往更有效率。事實上，所謂的同步就是指阻塞式操作，而異步就是非阻塞式操作。

64、啓動一個線程是調用run()還是start()方法？
答：啓動一個線程是調用start()方法，使線程所代表的虛擬處理機處於可運行狀態，這意味着它可以由JVM 調度並執行，這並不意味着線程就會立即運行。run()方法是線程啓動後要進行回調（callback）的方法。

65、什麼是線程池（thread pool）？
答：在面向對象編程中，創建和銷燬對象是很費時間的，因爲創建一個對象要獲取內存資源或者其它更多資源。在Java中更是如此，虛擬機將試圖跟蹤每一個對象，以便能夠在對象銷燬後進行垃圾回收。所以提高服務程序效率的一個手段就是儘可能減少創建和銷燬對象的次數，特別是一些很耗資源的對象創建和銷燬，這就是”池化資源”技術產生的原因。線程池顧名思義就是事先創建若干個可執行的線程放入一個池（容器）中，需要的時候從池中獲取線程不用自行創建，使用完畢不需要銷燬線程而是放回池中，從而減少創建和銷燬線程對象的開銷。
Java 5+中的Executor接口定義一個執行線程的工具。它的子類型即線程池接口是ExecutorService。要配置一個線程池是比較複雜的，尤其是對於線程池的原理不是很清楚的情況下，因此在工具類Executors面提供了一些靜態工廠方法，生成一些常用的線程池，如下所示：
- newSingleThreadExecutor：創建一個單線程的線程池。這個線程池只有一個線程在工作，也就是相當於單線程串行執行所有任務。如果這個唯一的線程因爲異常結束，那麼會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。
- newFixedThreadPool：創建固定大小的線程池。每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因爲執行異常而結束，那麼線程池會補充一個新線程。
- newCachedThreadPool：創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程，那麼就會回收部分空閒（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴於操作系統（或者說JVM）能夠創建的最大線程大小。
- newScheduledThreadPool：創建一個大小無限的線程池。此線程池支持定時以及週期性執行任務的需求。
- newSingleThreadExecutor：創建一個單線程的線程池。此線程池支持定時以及週期性執行任務的需求。

第60題的例子中演示了通過Executors工具類創建線程池並使用線程池執行線程的代碼。如果希望在服務器上使用線程池，強烈建議使用newFixedThreadPool方法來創建線程池，這樣能獲得更好的性能。

66、線程的基本狀態以及狀態之間的關係？
答：

說明：其中Running表示運行狀態，Runnable表示就緒狀態（萬事俱備，只欠CPU），Blocked表示阻塞狀態，阻塞狀態又有多種情況，可能是因爲調用wait()方法進入等待池，也可能是執行同步方法或同步代碼塊進入等鎖池，或者是調用了sleep()方法或join()方法等待休眠或其他線程結束，或是因爲發生了I/O中斷。

67、簡述synchronized 和java.util.concurrent.locks.Lock的異同？
答：Lock是Java 5以後引入的新的API，和關鍵字synchronized相比主要相同點：Lock 能完成synchronized所實現的所有功能；主要不同點：Lock有比synchronized更精確的線程語義和更好的性能，而且不強制性的要求一定要獲得鎖。synchronized會自動釋放鎖，而Lock一定要求程序員手工釋放，並且最好在finally 塊中釋放（這是釋放外部資源的最好的地方）。

68、Java中如何實現序列化，有什麼意義？
答：序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決對象流讀寫操作時可能引發的問題（如果不進行序列化可能會存在數據亂序的問題）。
要實現序列化，需要讓一個類實現Serializable接口，該接口是一個標識性接口，標註該類對象是可被序列化的，然後使用一個輸出流來構造一個對象輸出流並通過writeObject(Object)方法就可以將實現對象寫出（即保存其狀態）；如果需要反序列化則可以用一個輸入流建立對象輸入流，然後通過readObject方法從流中讀取對象。序列化除了能夠實現對象的持久化之外，還能夠用於對象的深度克隆（可以參考第29題）。

69、Java中有幾種類型的流？
答：字節流和字符流。字節流繼承於InputStream、OutputStream，字符流繼承於Reader、Writer。在java.io 包中還有許多其他的流，主要是爲了提高性能和使用方便。關於Java的I/O需要注意的有兩點：一是兩種對稱性（輸入和輸出的對稱性，字節和字符的對稱性）；二是兩種設計模式（適配器模式和裝潢模式）。另外Java中的流不同於C#的是它只有一個維度一個方向。

面試題 - 編程實現文件拷貝。（這個題目在筆試的時候經常出現，下面的代碼給出了兩種實現方案）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public final class MyUtil {

    private MyUtil() {
        throw new AssertionError();
    }

    public static void fileCopy(String source, String target) throws IOException {
        try (InputStream in = new FileInputStream(source)) {
            try (OutputStream out = new FileOutputStream(target)) {
                byte[] buffer = new byte[4096];
                int bytesToRead;
                while((bytesToRead = in.read(buffer)) != -1) {
                    out.write(buffer, 0, bytesToRead);
                }
            }
        }
    }

    public static void fileCopyNIO(String source, String target) throws IOException {
        try (FileInputStream in = new FileInputStream(source)) {
            try (FileOutputStream out = new FileOutputStream(target)) {
                FileChannel inChannel = in.getChannel();
                FileChannel outChannel = out.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(4096);
                while(inChannel.read(buffer) != -1) {
                    buffer.flip();
                    outChannel.write(buffer);
                    buffer.clear();
                }
            }
        }
    }
}

注意：上面用到Java 7的TWR，使用TWR後可以不用在finally中釋放外部資源，從而讓代碼更加優雅。

70、寫一個方法，輸入一個文件名和一個字符串，統計這個字符串在這個文件中出現的次數。
答：代碼如下：

import java.io.BufferedReader;
import java.io.FileReader;

public final class MyUtil {

    // 工具類中的方法都是靜態方式訪問的因此將構造器私有不允許創建對象(絕對好習慣)
    private MyUtil() {
        throw new AssertionError();
    }

    /**
     * 統計給定文件中給定字符串的出現次數
     * 
     * @param filename  文件名
     * @param word 字符串
     * @return 字符串在文件中出現的次數
     */
    public static int countWordInFile(String filename, String word) {
        int counter = 0;
        try (FileReader fr = new FileReader(filename)) {
            try (BufferedReader br = new BufferedReader(fr)) {
                String line = null;
                while ((line = br.readLine()) != null) {
                    int index = -1;
                    while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {
                        counter++;
                        line = line.substring(index + word.length());
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return counter;
    }

}

71、如何用Java代碼列出一個目錄下所有的文件？
答：
如果只要求列出當前文件夾下的文件，代碼如下所示：

import java.io.File;

class Test12 {

    public static void main(String[] args) {
        File f = new File("/Users/Hao/Downloads");
        for(File temp : f.listFiles()) {
            if(temp.isFile()) {
                System.out.println(temp.getName());
            }
        }
    }
}

如果需要對文件夾繼續展開，代碼如下所示：

import java.io.File;

class Test12 {

    public static void main(String[] args) {
        showDirectory(new File("/Users/Hao/Downloads"));
    }

    public static void showDirectory(File f) {
        _walkDirectory(f, 0);
    }

    private static void _walkDirectory(File f, int level) {
        if(f.isDirectory()) {
            for(File temp : f.listFiles()) {
                _walkDirectory(temp, level + 1);
            }
        }
        else {
            for(int i = 0; i < level - 1; i++) {
                System.out.print("\t");
            }
            System.out.println(f.getName());
        }
    }
}

在Java 7中可以使用NIO.2的API來做同樣的事情，代碼如下所示：

class ShowFileTest {

    public static void main(String[] args) throws IOException {
        Path initPath = Paths.get("/Users/Hao/Downloads");
        Files.walkFileTree(initPath, new SimpleFileVisitor<Path>() {

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) 
                    throws IOException {
                System.out.println(file.getFileName().toString());
                return FileVisitResult.CONTINUE;
            }

        });
    }
}

72、用Java的套接字編程實現一個多線程的回顯（echo）服務器。
答：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class EchoServer {

    private static final int ECHO_SERVER_PORT = 6789;

    public static void main(String[] args) {        
        try(ServerSocket server = new ServerSocket(ECHO_SERVER_PORT)) {
            System.out.println("服務器已經啓動...");
            while(true) {
                Socket client = server.accept();
                new Thread(new ClientHandler(client)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private Socket client;

        public ClientHandler(Socket client) {
            this.client = client;
        }

        @Override
        public void run() {
            try(BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
                    PrintWriter pw = new PrintWriter(client.getOutputStream())) {
                String msg = br.readLine();
                System.out.println("收到" + client.getInetAddress() + "發送的: " + msg);
                pw.println(msg);
                pw.flush();
            } catch(Exception ex) {
                ex.printStackTrace();
            } finally {
                try {
                    client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

注意：上面的代碼使用了Java 7的TWR語法，由於很多外部資源類都間接的實現了AutoCloseable接口（單方法回調接口），因此可以利用TWR語法在try結束的時候通過回調的方式自動調用外部資源類的close()方法，避免書寫冗長的finally代碼塊。此外，上面的代碼用一個靜態內部類實現線程的功能，使用多線程可以避免一個用戶I/O操作所產生的中斷影響其他用戶對服務器的訪問，簡單的說就是一個用戶的輸入操作不會造成其他用戶的阻塞。當然，上面的代碼使用線程池可以獲得更好的性能，因爲頻繁的創建和銷燬線程所造成的開銷也是不可忽視的。

下面是一段回顯客戶端測試代碼：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class EchoClient {

    public static void main(String[] args) throws Exception {
        Socket client = new Socket("localhost", 6789);
        Scanner sc = new Scanner(System.in);
        System.out.print("請輸入內容: ");
        String msg = sc.nextLine();
        sc.close();
        PrintWriter pw = new PrintWriter(client.getOutputStream());
        pw.println(msg);
        pw.flush();
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
        System.out.println(br.readLine());
        client.close();
    }
}

如果希望用NIO的多路複用套接字實現服務器，代碼如下所示。NIO的操作雖然帶來了更好的性能，但是有些操作是比較底層的，對於初學者來說還是有些難於理解。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class EchoServerNIO {

    private static final int ECHO_SERVER_PORT = 6789;
    private static final int ECHO_SERVER_TIMEOUT = 5000;
    private static final int BUFFER_SIZE = 1024;

    private static ServerSocketChannel serverChannel = null;
    private static Selector selector = null;    // 多路複用選擇器
    private static ByteBuffer buffer = null;    // 緩衝區

    public static void main(String[] args) {
        init();
        listen();
    }

    private static void init() {
        try {
            serverChannel = ServerSocketChannel.open();
            buffer = ByteBuffer.allocate(BUFFER_SIZE);
            serverChannel.socket().bind(new InetSocketAddress(ECHO_SERVER_PORT));
            serverChannel.configureBlocking(false);
            selector = Selector.open();
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static void listen() {
        while (true) {
            try {
                if (selector.select(ECHO_SERVER_TIMEOUT) != 0) {
                    Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                    while (it.hasNext()) {
                        SelectionKey key = it.next();
                        it.remove();
                        handleKey(key);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void handleKey(SelectionKey key) throws IOException {
        SocketChannel channel = null;

        try {
            if (key.isAcceptable()) {
                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                channel = serverChannel.accept();
                channel.configureBlocking(false);
                channel.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
                channel = (SocketChannel) key.channel();
                buffer.clear();
                if (channel.read(buffer) > 0) {
                    buffer.flip();
                    CharBuffer charBuffer = CharsetHelper.decode(buffer);
                    String msg = charBuffer.toString();
                    System.out.println("收到" + channel.getRemoteAddress() + "的消息：" + msg);
                    channel.write(CharsetHelper.encode(CharBuffer.wrap(msg)));
                } else {
                    channel.close();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (channel != null) {
                channel.close();
            }
        }
    }

}

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public final class CharsetHelper {
    private static final String UTF_8 = "UTF-8";
    private static CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder();
    private static CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder();

    private CharsetHelper() {
    }

    public static ByteBuffer encode(CharBuffer in) throws CharacterCodingException{
        return encoder.encode(in);
    }

    public static CharBuffer decode(ByteBuffer in) throws CharacterCodingException{
        return decoder.decode(in);
    }
}

73、XML文檔定義有幾種形式？它們之間有何本質區別？解析XML文檔有哪幾種方式？
答：XML文檔定義分爲DTD和Schema兩種形式，二者都是對XML語法的約束，其本質區別在於Schema本身也是一個XML文件，可以被XML解析器解析，而且可以爲XML承載的數據定義類型，約束能力較之DTD更強大。對XML的解析主要有DOM（文檔對象模型，Document Object Model）、SAX（Simple API for XML）和StAX（Java 6中引入的新的解析XML的方式，Streaming API for XML），其中DOM處理大型文件時其性能下降的非常厲害，這個問題是由DOM樹結構佔用的內存較多造成的，而且DOM解析方式必須在解析文件之前把整個文檔裝入內存，適合對XML的隨機訪問（典型的用空間換取時間的策略）；SAX是事件驅動型的XML解析方式，它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶通過事件回調代碼來處理XML文件，適合對XML的順序訪問；顧名思義，StAX把重點放在流上，實際上StAX與其他解析方式的本質區別就在於應用程序能夠把XML作爲一個事件流來處理。將XML作爲一組事件來處理的想法並不新穎（SAX就是這樣做的），但不同之處在於StAX允許應用程序代碼把這些事件逐個拉出來，而不用提供在解析器方便時從解析器中接收事件的處理程序。

74、你在項目中哪些地方用到了XML？
答：XML的主要作用有兩個方面：數據交換和信息配置。在做數據交換時，XML將數據用標籤組裝成起來，然後壓縮打包加密後通過網絡傳送給接收者，接收解密與解壓縮後再從XML文件中還原相關信息進行處理，XML曾經是異構系統間交換數據的事實標準，但此項功能幾乎已經被JSON（JavaScript ObjectNotation）取而代之。當然，目前很多軟件仍然使用XML來存儲配置信息，我們在很多項目中通常也會將作爲配置信息的硬代碼寫在XML文件中，Java的很多框架也是這麼做的，而且這些框架都選擇了dom4j作爲處理XML的工具，因爲Sun公司的官方API實在不怎麼好用。

補充：現在有很多時髦的軟件（如Sublime）已經開始將配置文件書寫成JSON格式，我們已經強烈的感受到XML的另一項功能也將逐漸被業界拋棄。

75、闡述JDBC操作數據庫的步驟。
答：下面的代碼以連接本機的Oracle數據庫爲例，演示JDBC操作數據庫的步驟。

加載驅動。

    Class.forName("oracle.jdbc.driver.OracleDriver");

創建連接。

    Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger")；

創建語句。

    PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");
    ps.setInt(1, 1000);
    ps.setInt(2, 3000);

執行語句。

    ResultSet rs = ps.executeQuery();

處理結果。

    while(rs.next()) {
        System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));
    }

關閉資源。

    finally {
        if(con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

提示：關閉外部資源的順序應該和打開的順序相反，也就是說先關閉ResultSet、再關閉Statement、在關閉Connection。上面的代碼只關閉了Connection（連接），雖然通常情況下在關閉連接時，連接上創建的語句和打開的遊標也會關閉，但不能保證總是如此，因此應該按照剛纔說的順序分別關閉。此外，第一步加載驅動在JDBC 4.0中是可以省略的（自動從類路徑中加載驅動），但是我們建議保留。

76、Statement和PreparedStatement有什麼區別？哪個性能更好？
答：與Statement相比，①PreparedStatement接口代表預編譯的語句，它主要的優勢在於可以減少SQL的編譯錯誤並增加SQL的安全性（減少SQL注射攻擊的可能性）；②PreparedStatement中的SQL語句是可以帶參數的，避免了用字符串連接拼接SQL語句的麻煩和不安全；③當批量處理SQL或頻繁執行相同的查詢時，PreparedStatement有明顯的性能上的優勢，由於數據庫可以將編譯優化後的SQL語句緩存起來，下次執行相同結構的語句時就會很快（不用再次編譯和生成執行計劃）。

補充：爲了提供對存儲過程的調用，JDBC API中還提供了CallableStatement接口。存儲過程（Stored Procedure）是數據庫中一組爲了完成特定功能的SQL語句的集合，經編譯後存儲在數據庫中，用戶通過指定存儲過程的名字並給出參數（如果該存儲過程帶有參數）來執行它。雖然調用存儲過程會在網絡開銷、安全性、性能上獲得很多好處，但是存在如果底層數據庫發生遷移時就會有很多麻煩，因爲每種數據庫的存儲過程在書寫上存在不少的差別。

77、使用JDBC操作數據庫時，如何提升讀取數據的性能？如何提升更新數據的性能？
答：要提升讀取數據的性能，可以指定通過結果集（ResultSet）對象的setFetchSize()方法指定每次抓取的記錄數（典型的空間換時間策略）；要提升更新數據的性能可以使用PreparedStatement語句構建批處理，將若干SQL語句置於一個批處理中執行。

78、在進行數據庫編程時，連接池有什麼作用？
答：由於創建連接和釋放連接都有很大的開銷（尤其是數據庫服務器不在本地時，每次建立連接都需要進行TCP的三次握手，釋放連接需要進行TCP四次握手，造成的開銷是不可忽視的），爲了提升系統訪問數據庫的性能，可以事先創建若干連接置於連接池中，需要時直接從連接池獲取，使用結束時歸還連接池而不必關閉連接，從而避免頻繁創建和釋放連接所造成的開銷，這是典型的用空間換取時間的策略（浪費了空間存儲連接，但節省了創建和釋放連接的時間）。池化技術在Java開發中是很常見的，在使用線程時創建線程池的道理與此相同。基於Java的開源數據庫連接池主要有：C3P0、Proxool、DBCP、BoneCP、Druid等。

補充：在計算機系統中時間和空間是不可調和的矛盾，理解這一點對設計滿足性能要求的算法是至關重要的。大型網站性能優化的一個關鍵就是使用緩存，而緩存跟上面講的連接池道理非常類似，也是使用空間換時間的策略。可以將熱點數據置於緩存中，當用戶查詢這些數據時可以直接從緩存中得到，這無論如何也快過去數據庫中查詢。當然，緩存的置換策略等也會對系統性能產生重要影響，對於這個問題的討論已經超出了這裏要闡述的範圍。

79、什麼是DAO模式？
答：DAO（Data Access Object）顧名思義是一個爲數據庫或其他持久化機制提供了抽象接口的對象，在不暴露底層持久化方案實現細節的前提下提供了各種數據訪問操作。在實際的開發中，應該將所有對數據源的訪問操作進行抽象化後封裝在一個公共API中。用程序設計語言來說，就是建立一個接口，接口中定義了此應用程序中將會用到的所有事務方法。在這個應用程序中，當需要和數據源進行交互的時候則使用這個接口，並且編寫一個單獨的類來實現這個接口，在邏輯上該類對應一個特定的數據存儲。DAO模式實際上包含了兩個模式，一是Data Accessor（數據訪問器），二是Data Object（數據對象），前者要解決如何訪問數據的問題，而後者要解決的是如何用對象封裝數據。

80、事務的ACID是指什麼？
答：
- 原子性(Atomic)：事務中各項操作，要麼全做要麼全不做，任何一項操作的失敗都會導致整個事務的失敗；
- 一致性(Consistent)：事務結束後系統狀態是一致的；
- 隔離性(Isolated)：併發執行的事務彼此無法看到對方的中間狀態；
- 持久性(Durable)：事務完成後所做的改動都會被持久化，即使發生災難性的失敗。通過日誌和同步備份可以在故障發生後重建數據。

補充：關於事務，在面試中被問到的概率是很高的，可以問的問題也是很多的。首先需要知道的是，只有存在併發數據訪問時才需要事務。當多個事務訪問同一數據時，可能會存在5類問題，包括3類數據讀取問題（髒讀、不可重複讀和幻讀）和2類數據更新問題（第1類丟失更新和第2類丟失更新）。

髒讀（Dirty Read）：A事務讀取B事務尚未提交的數據並在此基礎上操作，而B事務執行回滾，那麼A讀取到的數據就是髒數據。

時間	轉賬事務A	取款事務B
T1		開始事務
T2	開始事務
T3		查詢賬戶餘額爲1000元
T4		取出500元餘額修改爲500元
T5	查詢賬戶餘額爲500元（髒讀）
T6		撤銷事務餘額恢復爲1000元
T7	匯入100元把餘額修改爲600元
T8	提交事務

不可重複讀（Unrepeatable Read）：事務A重新讀取前面讀取過的數據，發現該數據已經被另一個已提交的事務B修改過了。

時間	轉賬事務A	取款事務B
T1		開始事務
T2	開始事務
T3		查詢賬戶餘額爲1000元
T4	查詢賬戶餘額爲1000元
T5		取出100元修改餘額爲900元
T6		提交事務
T7	查詢賬戶餘額爲900元（不可重複讀）

幻讀（Phantom Read）：事務A重新執行一個查詢，返回一系列符合查詢條件的行，發現其中插入了被事務B提交的行。

時間	統計金額事務A	轉賬事務B
T1		開始事務
T2	開始事務
T3	統計總存款爲10000元
T4		新增一個存款賬戶存入100元
T5		提交事務
T6	再次統計總存款爲10100元（幻讀）

第1類丟失更新：事務A撤銷時，把已經提交的事務B的更新數據覆蓋了。

時間	取款事務A	轉賬事務B
T1	開始事務
T2		開始事務
T3	查詢賬戶餘額爲1000元
T4		查詢賬戶餘額爲1000元
T5		匯入100元修改餘額爲1100元
T6		提交事務
T7	取出100元將餘額修改爲900元
T8	撤銷事務
T9	餘額恢復爲1000元（丟失更新）

第2類丟失更新：事務A覆蓋事務B已經提交的數據，造成事務B所做的操作丟失。

時間	轉賬事務A	取款事務B
T1		開始事務
T2	開始事務
T3		查詢賬戶餘額爲1000元
T4	查詢賬戶餘額爲1000元
T5		取出100元將餘額修改爲900元
T6		提交事務
T7	匯入100元將餘額修改爲1100元
T8	提交事務
T9	查詢賬戶餘額爲1100元（丟失更新）

數據併發訪問所產生的問題，在有些場景下可能是允許的，但是有些場景下可能就是致命的，數據庫通常會通過鎖機制來解決數據併發訪問問題，按鎖定對象不同可以分爲表級鎖和行級鎖；按併發事務鎖定關係可以分爲共享鎖和獨佔鎖，具體的內容大家可以自行查閱資料進行了解。
直接使用鎖是非常麻煩的，爲此數據庫爲用戶提供了自動鎖機制，只要用戶指定會話的事務隔離級別，數據庫就會通過分析SQL語句然後爲事務訪問的資源加上合適的鎖，此外，數據庫還會維護這些鎖通過各種手段提高系統的性能，這些對用戶來說都是透明的（就是說你不用理解，事實上我確實也不知道）。ANSI/ISO SQL 92標準定義了4個等級的事務隔離級別，如下表所示：

隔離級別	髒讀	不可重複讀	幻讀	第一類丟失更新	第二類丟失更新
READ UNCOMMITED	允許	允許	允許	不允許	允許
READ COMMITTED	不允許	允許	允許	不允許	允許
REPEATABLE READ	不允許	不允許	允許	不允許	不允許
SERIALIZABLE	不允許	不允許	不允許	不允許	不允許

需要說明的是，事務隔離級別和數據訪問的併發性是對立的，事務隔離級別越高併發性就越差。所以要根據具體的應用來確定合適的事務隔離級別，這個地方沒有萬能的原則。

81、JDBC中如何進行事務處理？
答：Connection提供了事務處理的方法，通過調用setAutoCommit(false)可以設置手動提交事務；當事務完成後用commit()顯式提交事務；如果在事務處理過程中發生異常則通過rollback()進行事務回滾。除此之外，從JDBC 3.0中還引入了Savepoint（保存點）的概念，允許通過代碼設置保存點並讓事務回滾到指定的保存點。

82、JDBC能否處理Blob和Clob？
答： Blob是指二進制大對象（Binary Large Object），而Clob是指大字符對象（Character Large Objec），因此其中Blob是爲存儲大的二進制數據而設計的，而Clob是爲存儲大的文本數據而設計的。JDBC的PreparedStatement和ResultSet都提供了相應的方法來支持Blob和Clob操作。下面的代碼展示瞭如何使用JDBC操作LOB：
下面以MySQL數據庫爲例，創建一個張有三個字段的用戶表，包括編號（id）、姓名（name）和照片（photo），建表語句如下：

create table tb_user
(
id int primary key auto_increment,
name varchar(20) unique not null,
photo longblob
);

下面的Java代碼向數據庫中插入一條記錄：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

class JdbcLobTest {

    public static void main(String[] args) {
        Connection con = null;
        try {
            // 1. 加載驅動（Java6以上版本可以省略）
            Class.forName("com.mysql.jdbc.Driver");
            // 2. 建立連接
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            // 3. 創建語句對象
            PreparedStatement ps = con.prepareStatement("insert into tb_user values (default, ?, ?)");
            ps.setString(1, "駱昊");              // 將SQL語句中第一個佔位符換成字符串
            try (InputStream in = new FileInputStream("test.jpg")) {    // Java 7的TWR
                ps.setBinaryStream(2, in);      // 將SQL語句中第二個佔位符換成二進制流
                // 4. 發出SQL語句獲得受影響行數
                System.out.println(ps.executeUpdate() == 1 ? "插入成功" : "插入失敗");
            } catch(IOException e) {
                System.out.println("讀取照片失敗!");
            }
        } catch (ClassNotFoundException | SQLException e) {     // Java 7的多異常捕獲
            e.printStackTrace();
        } finally { // 釋放外部資源的代碼都應當放在finally中保證其能夠得到執行
            try {
                if(con != null && !con.isClosed()) {
                    con.close();    // 5. 釋放數據庫連接 
                    con = null;     // 指示垃圾回收器可以回收該對象
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

83、簡述正則表達式及其用途。
答：在編寫處理字符串的程序時，經常會有查找符合某些複雜規則的字符串的需要。正則表達式就是用於描述這些規則的工具。換句話說，正則表達式就是記錄文本規則的代碼。

說明：計算機誕生初期處理的信息幾乎都是數值，但是時過境遷，今天我們使用計算機處理的信息更多的時候不是數值而是字符串，正則表達式就是在進行字符串匹配和處理的時候最爲強大的工具，絕大多數語言都提供了對正則表達式的支持。

84、Java中是如何支持正則表達式操作的？
答：Java中的String類提供了支持正則表達式操作的方法，包括：matches()、replaceAll()、replaceFirst()、split()。此外，Java中可以用Pattern類表示正則表達式對象，它提供了豐富的API進行各種正則表達式操作，請參考下面面試題的代碼。

面試題： - 如果要從字符串中截取第一個英文左括號之前的字符串，例如：北京市(朝陽區)(西城區)(海淀區)，截取結果爲：北京市，那麼正則表達式怎麼寫？

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class RegExpTest {

    public static void main(String[] args) {
        String str = "北京市(朝陽區)(西城區)(海淀區)";
        Pattern p = Pattern.compile(".*?(?=\\()");
        Matcher m = p.matcher(str);
        if(m.find()) {
            System.out.println(m.group());
        }
    }
}

說明：上面的正則表達式中使用了懶惰匹配和前瞻，如果不清楚這些內容，推薦讀一下網上很有名的《正則表達式30分鐘入門教程》。

85、獲得一個類的類對象有哪些方式？
答：
- 方法1：類型.class，例如：String.class
- 方法2：對象.getClass()，例如："hello".getClass()
- 方法3：Class.forName()，例如：Class.forName("java.lang.String")

86、如何通過反射創建對象？
答：
- 方法1：通過類對象調用newInstance()方法，例如：String.class.newInstance()
- 方法2：通過類對象的getConstructor()或getDeclaredConstructor()方法獲得構造器（Constructor）對象並調用其newInstance()方法創建對象，例如：String.class.getConstructor(String.class).newInstance("Hello");

87、如何通過反射獲取和設置對象私有字段的值？
答：可以通過類對象的getDeclaredField()方法字段（Field）對象，然後再通過字段對象的setAccessible(true)將其設置爲可以訪問，接下來就可以通過get/set方法來獲取/設置字段的值了。下面的代碼實現了一個反射的工具類，其中的兩個靜態方法分別用於獲取和設置私有字段的值，字段可以是基本類型也可以是對象類型且支持多級對象操作，例如ReflectionUtil.get(dog, "owner.car.engine.id");可以獲得dog對象的主人的汽車的引擎的ID號。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

/**
 * 反射工具類
 * @author 駱昊
 *
 */
public class ReflectionUtil {

    private ReflectionUtil() {
        throw new AssertionError();
    }

    /**
     * 通過反射取對象指定字段(屬性)的值
     * @param target 目標對象
     * @param fieldName 字段的名字
     * @throws 如果取不到對象指定字段的值則拋出異常
     * @return 字段的值
     */
    public static Object getValue(Object target, String fieldName) {
        Class<?> clazz = target.getClass();
        String[] fs = fieldName.split("\\.");

        try {
            for(int i = 0; i < fs.length - 1; i++) {
                Field f = clazz.getDeclaredField(fs[i]);
                f.setAccessible(true);
                target = f.get(target);
                clazz = target.getClass();
            }

            Field f = clazz.getDeclaredField(fs[fs.length - 1]);
            f.setAccessible(true);
            return f.get(target);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 通過反射給對象的指定字段賦值
     * @param target 目標對象
     * @param fieldName 字段的名稱
     * @param value 值
     */
    public static void setValue(Object target, String fieldName, Object value) {
        Class<?> clazz = target.getClass();
        String[] fs = fieldName.split("\\.");
        try {
            for(int i = 0; i < fs.length - 1; i++) {
                Field f = clazz.getDeclaredField(fs[i]);
                f.setAccessible(true);
                Object val = f.get(target);
                if(val == null) {
                    Constructor<?> c = f.getType().getDeclaredConstructor();
                    c.setAccessible(true);
                    val = c.newInstance();
                    f.set(target, val);
                }
                target = val;
                clazz = target.getClass();
            }

            Field f = clazz.getDeclaredField(fs[fs.length - 1]);
            f.setAccessible(true);
            f.set(target, value);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

88、如何通過反射調用對象的方法？
答：請看下面的代碼：

import java.lang.reflect.Method;

class MethodInvokeTest {

    public static void main(String[] args) throws Exception {
        String str = "hello";
        Method m = str.getClass().getMethod("toUpperCase");
        System.out.println(m.invoke(str));  // HELLO
    }
}

89、簡述一下面向對象的"六原則一法則"。
答：
- 單一職責原則：一個類只做它該做的事情。（單一職責原則想表達的就是"高內聚"，寫代碼最終極的原則只有六個字"高內聚、低耦合"，就如同葵花寶典或辟邪劍譜的中心思想就八個字"欲練此功必先自宮"，所謂的高內聚就是一個代碼模塊只完成一項功能，在面向對象中，如果只讓一個類完成它該做的事，而不涉及與它無關的領域就是踐行了高內聚的原則，這個類就只有單一職責。我們都知道一句話叫"因爲專注，所以專業"，一個對象如果承擔太多的職責，那麼註定它什麼都做不好。這個世界上任何好的東西都有兩個特徵，一個是功能單一，好的相機絕對不是電視購物裏面賣的那種一個機器有一百多種功能的，它基本上只能照相；另一個是模塊化，好的自行車是組裝車，從減震叉、剎車到變速器，所有的部件都是可以拆卸和重新組裝的，好的乒乓球拍也不是成品拍，一定是底板和膠皮可以拆分和自行組裝的，一個好的軟件系統，它裏面的每個功能模塊也應該是可以輕易的拿到其他系統中使用的，這樣才能實現軟件複用的目標。）
- 開閉原則：軟件實體應當對擴展開放，對修改關閉。（在理想的狀態下，當我們需要爲一個軟件系統增加新功能時，只需要從原來的系統派生出一些新類就可以，不需要修改原來的任何一行代碼。要做到開閉有兩個要點：①抽象是關鍵，一個系統中如果沒有抽象類或接口系統就沒有擴展點；②封裝可變性，將系統中的各種可變因素封裝到一個繼承結構中，如果多個可變因素混雜在一起，系統將變得複雜而換亂，如果不清楚如何封裝可變性，可以參考《設計模式精解》一書中對橋樑模式的講解的章節。）
- 依賴倒轉原則：面向接口編程。（該原則說得直白和具體一些就是聲明方法的參數類型、方法的返回類型、變量的引用類型時，儘可能使用抽象類型而不用具體類型，因爲抽象類型可以被它的任何一個子類型所替代，請參考下面的里氏替換原則。）
里氏替換原則：任何時候都可以用子類型替換掉父類型。（關於里氏替換原則的描述，Barbara Liskov女士的描述比這個要複雜得多，但簡單的說就是能用父類型的地方就一定能使用子類型。里氏替換原則可以檢查繼承關係是否合理，如果一個繼承關係違背了里氏替換原則，那麼這個繼承關係一定是錯誤的，需要對代碼進行重構。例如讓貓繼承狗，或者狗繼承貓，又或者讓正方形繼承長方形都是錯誤的繼承關係，因爲你很容易找到違反里氏替換原則的場景。需要注意的是：子類一定是增加父類的能力而不是減少父類的能力，因爲子類比父類的能力更多，把能力多的對象當成能力少的對象來用當然沒有任何問題。）
- 接口隔離原則：接口要小而專，絕不能大而全。（臃腫的接口是對接口的污染，既然接口表示能力，那麼一個接口只應該描述一種能力，接口也應該是高度內聚的。例如，琴棋書畫就應該分別設計爲四個接口，而不應設計成一個接口中的四個方法，因爲如果設計成一個接口中的四個方法，那麼這個接口很難用，畢竟琴棋書畫四樣都精通的人還是少數，而如果設計成四個接口，會幾項就實現幾個接口，這樣的話每個接口被複用的可能性是很高的。Java中的接口代表能力、代表約定、代表角色，能否正確的使用接口一定是編程水平高低的重要標識。）
- 合成聚合複用原則：優先使用聚合或合成關係複用代碼。（通過繼承來複用代碼是面向對象程序設計中被濫用得最多的東西，因爲所有的教科書都無一例外的對繼承進行了鼓吹從而誤導了初學者，類與類之間簡單的說有三種關係，Is-A關係、Has-A關係、Use-A關係，分別代表繼承、關聯和依賴。其中，關聯關係根據其關聯的強度又可以進一步劃分爲關聯、聚合和合成，但說白了都是Has-A關係，合成聚合複用原則想表達的是優先考慮Has-A關係而不是Is-A關係複用代碼，原因嘛可以自己從百度上找到一萬個理由，需要說明的是，即使在Java的API中也有不少濫用繼承的例子，例如Properties類繼承了Hashtable類，Stack類繼承了Vector類，這些繼承明顯就是錯誤的，更好的做法是在Properties類中放置一個Hashtable類型的成員並且將其鍵和值都設置爲字符串來存儲數據，而Stack類的設計也應該是在Stack類中放一個Vector對象來存儲數據。記住：任何時候都不要繼承工具類，工具是可以擁有並可以使用的，而不是拿來繼承的。）
- 迪米特法則：迪米特法則又叫最少知識原則，一個對象應當對其他對象有儘可能少的瞭解。（迪米特法則簡單的說就是如何做到"低耦合"，門面模式和調停者模式就是對迪米特法則的踐行。對於門面模式可以舉一個簡單的例子，你去一家公司洽談業務，你不需要了解這個公司內部是如何運作的，你甚至可以對這個公司一無所知，去的時候只需要找到公司入口處的前臺美女，告訴她們你要做什麼，她們會找到合適的人跟你接洽，前臺的美女就是公司這個系統的門面。再複雜的系統都可以爲用戶提供一個簡單的門面，Java Web開發中作爲前端控制器的Servlet或Filter不就是一個門面嗎，瀏覽器對服務器的運作方式一無所知，但是通過前端控制器就能夠根據你的請求得到相應的服務。調停者模式也可以舉一個簡單的例子來說明，例如一臺計算機，CPU、內存、硬盤、顯卡、聲卡各種設備需要相互配合才能很好的工作，但是如果這些東西都直接連接到一起，計算機的佈線將異常複雜，在這種情況下，主板作爲一個調停者的身份出現，它將各個設備連接在一起而不需要每個設備之間直接交換數據，這樣就減小了系統的耦合度和複雜度，如下圖所示。迪米特法則用通俗的話來將就是不要和陌生人打交道，如果真的需要，找一個自己的朋友，讓他替你和陌生人打交道。）

90、簡述一下你瞭解的設計模式。
答：所謂設計模式，就是一套被反覆使用的代碼設計經驗的總結（情境中一個問題經過證實的一個解決方案）。使用設計模式是爲了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。設計模式使人們可以更加簡單方便的複用成功的設計和體系結構。將已證實的技術表述成設計模式也會使新系統開發者更加容易理解其設計思路。
在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中給出了三類（創建型[對類的實例化過程的抽象化]、結構型[描述如何將類或對象結合在一起形成更大的結構]、行爲型[對在不同的對象之間劃分責任和算法的抽象化]）共23種設計模式，包括：Abstract Factory（抽象工廠模式），Builder（建造者模式），Factory Method（工廠方法模式），Prototype（原始模型模式），Singleton（單例模式）；Facade（門面模式），Adapter（適配器模式），Bridge（橋樑模式），Composite（合成模式），Decorator（裝飾模式），Flyweight（享元模式），Proxy（代理模式）；Command（命令模式），Interpreter（解釋器模式），Visitor（訪問者模式），Iterator（迭代子模式），Mediator（調停者模式），Memento（備忘錄模式），Observer（觀察者模式），State（狀態模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibility（責任鏈模式）。
面試被問到關於設計模式的知識時，可以揀最常用的作答，例如：
- 工廠模式：工廠類可以根據條件生成不同的子類實例，這些子類有一個公共的抽象父類並且實現了相同的方法，但是這些方法針對不同的數據進行了不同的操作（多態方法）。當得到子類的實例後，開發人員可以調用基類中的方法而不必考慮到底返回的是哪一個子類的實例。
- 代理模式：給一個對象提供一個代理對象，並由代理對象控制原對象的引用。實際開發中，按照使用目的的不同，代理可以分爲：遠程代理、虛擬代理、保護代理、Cache代理、防火牆代理、同步化代理、智能引用代理。
- 適配器模式：把一個類的接口變換成客戶端所期待的另一種接口，從而使原本因接口不匹配而無法在一起使用的類能夠一起工作。
- 模板方法模式：提供一個抽象類，將部分邏輯以具體方法或構造器的形式實現，然後聲明一些抽象方法來迫使子類實現剩餘的邏輯。不同的子類可以以不同的方式實現這些抽象方法（多態實現），從而實現不同的業務邏輯。
除此之外，還可以講講上面提到的門面模式、橋樑模式、單例模式、裝潢模式（Collections工具類和I/O系統中都使用裝潢模式）等，反正基本原則就是揀自己最熟悉的、用得最多的作答，以免言多必失。

91、用Java寫一個單例類。
答：
- 餓漢式單例

public class Singleton {
    private Singleton(){}
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

懶漢式單例

public class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static synchronized Singleton getInstance(){
        if (instance == null) instance ＝ new Singleton();
        return instance;
    }
}

注意：實現一個單例有兩點注意事項，①將構造器私有，不允許外界通過構造器創建對象；②通過公開的靜態方法向外界返回類的唯一實例。這裏有一個問題可以思考：Spring的IoC容器可以爲普通的類創建單例，它是怎麼做到的呢？

92、什麼是UML？
答：UML是統一建模語言（Unified Modeling Language）的縮寫，它發表於1997年，綜合了當時已經存在的面向對象的建模語言、方法和過程，是一個支持模型化和軟件系統開發的圖形化語言，爲軟件開發的所有階段提供模型化和可視化支持。使用UML可以幫助溝通與交流，輔助應用設計和文檔的生成，還能夠闡釋系統的結構和行爲。

93、UML中有哪些常用的圖？
答：UML定義了多種圖形化的符號來描述軟件系統部分或全部的靜態結構和動態結構，包括：用例圖（use case diagram）、類圖（class diagram）、時序圖（sequence diagram）、協作圖（collaboration diagram）、狀態圖（statechart diagram）、活動圖（activity diagram）、構件圖（component diagram）、部署圖（deployment diagram）等。在這些圖形化符號中，有三種圖最爲重要，分別是：用例圖（用來捕獲需求，描述系統的功能，通過該圖可以迅速的瞭解系統的功能模塊及其關係）、類圖（描述類以及類與類之間的關係，通過該圖可以快速瞭解系統）、時序圖（描述執行特定任務時對象之間的交互關係以及執行順序，通過該圖可以瞭解對象能接收的消息也就是說對象能夠向外界提供的服務）。
用例圖：

類圖：

時序圖：

94、用Java寫一個冒泡排序。
答：冒泡排序幾乎是個程序員都寫得出來，但是面試的時候如何寫一個逼格高的冒泡排序卻不是每個人都能做到，下面提供一個參考代碼：

import java.util.Comparator;

/**
 * 排序器接口(策略模式: 將算法封裝到具有共同接口的獨立的類中使得它們可以相互替換)
 * @author駱昊
 *
 */
public interface Sorter {

   /**
    * 排序
    * @param list 待排序的數組
    */
   public <T extends Comparable<T>> void sort(T[] list);

   /**
    * 排序
    * @param list 待排序的數組
    * @param comp 比較兩個對象的比較器
    */
   public <T> void sort(T[] list, Comparator<T> comp);
}

import java.util.Comparator;

/**
 * 冒泡排序
 * 
 * @author駱昊
 *
 */
public class BubbleSorter implements Sorter {

    @Override
    public <T extends Comparable<T>> void sort(T[] list) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (list[j].compareTo(list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }

    @Override
    public <T> void sort(T[] list, Comparator<T> comp) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (comp.compare(list[j], list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
}

95、用Java寫一個折半查找。
答：折半查找，也稱二分查找、二分搜索，是一種在有序數組中查找某一特定元素的搜索算法。搜素過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜素過程結束；如果某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。如果在某一步驟數組已經爲空，則表示找不到指定的元素。這種搜索算法每一次比較都使搜索範圍縮小一半，其時間複雜度是O(logN)。

import java.util.Comparator;

public class MyUtil {

   public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
      return binarySearch(x, 0, x.length- 1, key);
   }

   // 使用循環實現的二分查找
   public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
      int low = 0;
      int high = x.length - 1;
      while (low <= high) {
          int mid = (low + high) >>> 1;
          int cmp = comp.compare(x[mid], key);
          if (cmp < 0) {
            low= mid + 1;
          }
          else if (cmp > 0) {
            high= mid - 1;
          }
          else {
            return mid;
          }
      }
      return -1;
   }

   // 使用遞歸實現的二分查找
   private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
      if(low <= high) {
        int mid = low + ((high -low) >> 1);
        if(key.compareTo(x[mid])== 0) {
           return mid;
        }
        else if(key.compareTo(x[mid])< 0) {
           return binarySearch(x,low, mid - 1, key);
        }
        else {
           return binarySearch(x,mid + 1, high, key);
        }
      }
      return -1;
   }
}

說明：上面的代碼中給出了折半查找的兩個版本，一個用遞歸實現，一個用循環實現。需要注意的是計算中間位置時不應該使用(high+ low) / 2的方式，因爲加法運算可能導致整數越界，這裏應該使用以下三種方式之一：low + (high - low) / 2或low + (high – low) >> 1或(low + high) >>> 1（>>>是邏輯右移，是不帶符號位的右移）

這部分主要是與Java Web和Web Service相關的面試題。

96、闡述Servlet和CGI的區別?
答：Servlet與CGI的區別在於Servlet處於服務器進程中，它通過多線程方式運行其service()方法，一個實例可以服務於多個請求，並且其實例一般不會銷燬，而CGI對每個請求都產生新的進程，服務完成後就銷燬，所以效率上低於Servlet。

補充：Sun Microsystems公司在1996年發佈Servlet技術就是爲了和CGI進行競爭，Servlet是一個特殊的Java程序，一個基於Java的Web應用通常包含一個或多個Servlet類。Servlet不能夠自行創建並執行，它是在Servlet容器中運行的，容器將用戶的請求傳遞給Servlet程序，並將Servlet的響應回傳給用戶。通常一個Servlet會關聯一個或多個JSP頁面。以前CGI經常因爲性能開銷上的問題被詬病，然而Fast CGI早就已經解決了CGI效率上的問題，所以面試的時候大可不必信口開河的詬病CGI，事實上有很多你熟悉的網站都使用了CGI技術。

97、Servlet接口中有哪些方法？
答：Servlet接口定義了5個方法，其中前三個方法與Servlet生命週期相關：
- void init(ServletConfig config) throws ServletException
- void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException
- void destory()
- java.lang.String getServletInfo()
- ServletConfig getServletConfig()

Web容器加載Servlet並將其實例化後，Servlet生命週期開始，容器運行其init()方法進行Servlet的初始化；請求到達時調用Servlet的service()方法，service()方法會根據需要調用與請求對應的doGet或doPost等方法；當服務器關閉或項目被卸載時服務器會將Servlet實例銷燬，此時會調用Servlet的destroy()方法。

98、轉發（forward）和重定向（redirect）的區別？
答：forward是容器中控制權的轉向，是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL 的響應內容讀取過來，然後把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的，所以它的地址欄中還是原來的地址。redirect就是服務器端根據邏輯，發送一個狀態碼，告訴瀏覽器重新去請求那個地址，因此從瀏覽器的地址欄中可以看到跳轉後的鏈接地址，很明顯redirect無法訪問到服務器保護起來資源，但是可以從一個網站redirect到其他網站。forward更加高效，所以在滿足需要時儘量使用forward（通過調用RequestDispatcher對象的forward()方法，該對象可以通過ServletRequest對象的getRequestDispatcher()方法獲得），並且這樣也有助於隱藏實際的鏈接；在有些情況下，比如需要訪問一個其它服務器上的資源，則必須使用重定向（通過HttpServletResponse對象調用其sendRedirect()方法實現）。

99、JSP有哪些內置對象？作用分別是什麼？
答：JSP有9個內置對象：
- request：封裝客戶端的請求，其中包含來自GET或POST請求的參數；
- response：封裝服務器對客戶端的響應；
- pageContext：通過該對象可以獲取其他對象；
- session：封裝用戶會話的對象；
- application：封裝服務器運行環境的對象；
- out：輸出服務器響應的輸出流對象；
- config：Web應用的配置對象；
- page：JSP頁面本身（相當於Java程序中的this）；
- exception：封裝頁面拋出異常的對象。

補充：如果用Servlet來生成網頁中的動態內容無疑是非常繁瑣的工作，另一方面，所有的文本和HTML標籤都是硬編碼，即使做出微小的修改，都需要進行重新編譯。JSP解決了Servlet的這些問題，它是Servlet很好的補充，可以專門用作爲用戶呈現視圖（View），而Servlet作爲控制器（Controller）專門負責處理用戶請求並轉發或重定向到某個頁面。基於Java的Web開發很多都同時使用了Servlet和JSP。JSP頁面其實是一個Servlet，能夠運行Servlet的服務器（Servlet容器）通常也是JSP容器，可以提供JSP頁面的運行環境，Tomcat就是一個Servlet/JSP容器。第一次請求一個JSP頁面時，Servlet/JSP容器首先將JSP頁面轉換成一個JSP頁面的實現類，這是一個實現了JspPage接口或其子接口HttpJspPage的Java類。JspPage接口是Servlet的子接口，因此每個JSP頁面都是一個Servlet。轉換成功後，容器會編譯Servlet類，之後容器加載和實例化Java字節碼，並執行它通常對Servlet所做的生命週期操作。對同一個JSP頁面的後續請求，容器會查看這個JSP頁面是否被修改過，如果修改過就會重新轉換並重新編譯並執行。如果沒有則執行內存中已經存在的Servlet實例。我們可以看一段JSP代碼對應的Java程序就知道一切了，而且9個內置對象的神祕面紗也會被揭開。

JSP頁面：

<%@ page pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>

<!DOCTYPE html>
<html>
  <head>
    <base href="<%=basePath%>">
    <title>首頁</title>
    <style type="text/css">
        * { font-family: "Arial"; }
    </style>
  </head>

  <body>
    <h1>Hello, World!</h1>
    <hr/>
    <h2>Current time is: <%= new java.util.Date().toString() %></h2>
  </body>
</html>

對應的Java代碼：

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/7.0.52
 * Generated at: 2014-10-13 13:28:38 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
        implements org.apache.jasper.runtime.JspSourceDependent {

    private static final javax.servlet.jsp.JspFactory _jspxFactory = javax.servlet.jsp.JspFactory
            .getDefaultFactory();

    private static java.util.Map<java.lang.String, java.lang.Long> _jspx_dependants;

    private javax.el.ExpressionFactory _el_expressionfactory;
    private org.apache.tomcat.InstanceManager _jsp_instancemanager;

    public java.util.Map<java.lang.String, java.lang.Long> getDependants() {
        return _jspx_dependants;
    }

    public void _jspInit() {
        _el_expressionfactory = _jspxFactory.getJspApplicationContext(
                getServletConfig().getServletContext()).getExpressionFactory();
        _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory
                .getInstanceManager(getServletConfig());
    }

    public void _jspDestroy() {
    }

    public void _jspService(
            final javax.servlet.http.HttpServletRequest request,
            final javax.servlet.http.HttpServletResponse response)
            throws java.io.IOException, javax.servlet.ServletException {
        // 內置對象就是在這裏定義的
        final javax.servlet.jsp.PageContext pageContext;
        javax.servlet.http.HttpSession session = null;
        final javax.servlet.ServletContext application;
        final javax.servlet.ServletConfig config;
        javax.servlet.jsp.JspWriter out = null;
        final java.lang.Object page = this;
        javax.servlet.jsp.JspWriter _jspx_out = null;
        javax.servlet.jsp.PageContext _jspx_page_context = null;

        try {
            response.setContentType("text/html;charset=UTF-8");
            pageContext = _jspxFactory.getPageContext(this, request, response,
                    null, true, 8192, true);
            _jspx_page_context = pageContext;
            application = pageContext.getServletContext();
            config = pageContext.getServletConfig();
            session = pageContext.getSession();
            out = pageContext.getOut();
            _jspx_out = out;

            out.write('\r');
            out.write('\n');

            String path = request.getContextPath();
            String basePath = request.getScheme() + "://"
                    + request.getServerName() + ":" + request.getServerPort()
                    + path + "/";
// 以下代碼通過輸出流將HTML標籤輸出到瀏覽器中
            out.write("\r\n");
            out.write("\r\n");
            out.write("<!DOCTYPE html>\r\n");
            out.write("<html>\r\n");
            out.write("  <head>\r\n");
            out.write("    <base href=\"");
            out.print(basePath);
            out.write("\">\r\n");
            out.write("    <title>首頁</title>\r\n");
            out.write("    <style type=\"text/css\">\r\n");
            out.write("    \t* { font-family: \"Arial\"; }\r\n");
            out.write("    </style>\r\n");
            out.write("  </head>\r\n");
            out.write("  \r\n");
            out.write("  <body>\r\n");
            out.write("    <h1>Hello, World!</h1>\r\n");
            out.write("    <hr/>\r\n");
            out.write("    <h2>Current time is: ");
            out.print(new java.util.Date().toString());
            out.write("</h2>\r\n");
            out.write("  </body>\r\n");
            out.write("</html>\r\n");
        } catch (java.lang.Throwable t) {
            if (!(t instanceof javax.servlet.jsp.SkipPageException)) {
                out = _jspx_out;
                if (out != null && out.getBufferSize() != 0)
                    try {
                        out.clearBuffer();
                    } catch (java.io.IOException e) {
                    }
                if (_jspx_page_context != null)
                    _jspx_page_context.handlePageException(t);
                else
                    throw new ServletException(t);
            }
        } finally {
            _jspxFactory.releasePageContext(_jspx_page_context);
        }
    }
}

100、get和post請求的區別？
答：
①get請求用來從服務器上獲得資源，而post是用來向服務器提交數據；
②get將表單中數據按照name=value的形式，添加到action 所指向的URL 後面，並且兩者使用"?"連接，而各個變量之間使用"&"連接；post是將表單中的數據放在HTTP協議的請求頭或消息體中，傳遞到action所指向URL；
③get傳輸的數據要受到URL長度限制（1024字節）；而post可以傳輸大量的數據，上傳文件通常要使用post方式；
④使用get時參數會顯示在地址欄上，如果這些數據不是敏感數據，那麼可以使用get；對於敏感數據還是應用使用post；
⑤get使用MIME類型application/x-www-form-urlencoded的URL編碼（也叫百分號編碼）文本的格式傳遞參數，保證被傳送的參數由遵循規範的文本組成，例如一個空格的編碼是"%20"。

101、常用的Web服務器有哪些？
答：Unix和Linux平臺下使用最廣泛的免費HTTP服務器是Apache服務器，而Windows平臺的服務器通常使用IIS作爲Web服務器。選擇Web服務器應考慮的因素有：性能、安全性、日誌和統計、虛擬主機、代理服務器、緩衝服務和集成應用程序等。下面是對常見服務器的簡介：
- IIS：Microsoft的Web服務器產品，全稱是Internet Information Services。IIS是允許在公共Intranet或Internet上發佈信息的Web服務器。IIS是目前最流行的Web服務器產品之一，很多著名的網站都是建立在IIS的平臺上。IIS提供了一個圖形界面的管理工具，稱爲Internet服務管理器，可用於監視配置和控制Internet服務。IIS是一種Web服務組件，其中包括Web服務器、FTP服務器、NNTP服務器和SMTP服務器，分別用於網頁瀏覽、文件傳輸、新聞服務和郵件發送等方面，它使得在網絡（包括互聯網和局域網）上發佈信息成了一件很容易的事。它提供ISAPI(Intranet Server API）作爲擴展Web服務器功能的編程接口；同時，它還提供一個Internet數據庫連接器，可以實現對數據庫的查詢和更新。
- Kangle：Kangle Web服務器是一款跨平臺、功能強大、安全穩定、易操作的高性能Web服務器和反向代理服務器軟件。此外，Kangle也是一款專爲做虛擬主機研發的Web服務器。實現虛擬主機獨立進程、獨立身份運行。用戶之間安全隔離，一個用戶出問題不影響其他用戶。支持PHP、ASP、ASP.NET、Java、Ruby等多種動態開發語言。
- WebSphere：WebSphere Application Server是功能完善、開放的Web應用程序服務器，是IBM電子商務計劃的核心部分，它是基於Java的應用環境，用於建立、部署和管理Internet和Intranet Web應用程序，適應各種Web應用程序服務器的需要。
- WebLogic：WebLogic Server是一款多功能、基於標準的Web應用服務器，爲企業構建企業應用提供了堅實的基礎。針對各種應用開發、關鍵性任務的部署，各種系統和數據庫的集成、跨Internet協作等Weblogic都提供了相應的支持。由於它具有全面的功能、對開放標準的遵從性、多層架構、支持基於組件的開發等優勢，很多公司的企業級應用都選擇它來作爲開發和部署的環境。WebLogic Server在使應用服務器成爲企業應用架構的基礎方面一直處於領先地位，爲構建集成化的企業級應用提供了穩固的基礎。
- Apache：目前Apache仍然是世界上用得最多的Web服務器，其市場佔有率很長時間都保持在60%以上（目前的市場份額約40%左右）。世界上很多著名的網站都是Apache的產物，它的成功之處主要在於它的源代碼開放、有一支強大的開發團隊、支持跨平臺的應用（可以運行在幾乎所有的Unix、Windows、Linux系統平臺上）以及它的可移植性等方面。
- Tomcat：Tomcat是一個開放源代碼、運行Servlet和JSP的容器。Tomcat實現了Servlet和JSP規範。此外，Tomcat還實現了Apache-Jakarta規範而且比絕大多數商業應用軟件服務器要好，因此目前也有不少的Web服務器都選擇了Tomcat。
- Nginx：讀作"engine x"，是一個高性能的HTTP和反向代理服務器，也是一個IMAP/POP3/SMTP代理服務器。 Nginx是由Igor Sysoev爲俄羅斯訪問量第二的Rambler站點開發的，第一個公開版本0.1.0發佈於2004年10月4日。其將源代碼以類BSD許可證的形式發佈，因它的穩定性、豐富的功能集、示例配置文件和低系統資源的消耗而聞名。在2014年下半年，Nginx的市場份額達到了14%。

102、JSP和Servlet是什麼關係？
答：其實這個問題在上面已經闡述過了，Servlet是一個特殊的Java程序，它運行於服務器的JVM中，能夠依靠服務器的支持向瀏覽器提供顯示內容。JSP本質上是Servlet的一種簡易形式，JSP會被服務器處理成一個類似於Servlet的Java程序，可以簡化頁面內容的生成。Servlet和JSP最主要的不同點在於，Servlet的應用邏輯是在Java文件中，並且完全從表示層中的HTML分離開來。而JSP的情況是Java和HTML可以組合成一個擴展名爲.jsp的文件。有人說，Servlet就是在Java中寫HTML，而JSP就是在HTML中寫Java代碼，當然這個說法是很片面且不夠準確的。JSP側重於視圖，Servlet更側重於控制邏輯，在MVC架構模式中，JSP適合充當視圖（view）而Servlet適合充當控制器（controller）。

103、講解JSP中的四種作用域。
答：JSP中的四種作用域包括page、request、session和application，具體來說：
- page代表與一個頁面相關的對象和屬性。
- request代表與Web客戶機發出的一個請求相關的對象和屬性。一個請求可能跨越多個頁面，涉及多個Web組件；需要在頁面顯示的臨時數據可以置於此作用域。
- session代表與某個用戶與服務器建立的一次會話相關的對象和屬性。跟某個用戶相關的數據應該放在用戶自己的session中。
- application代表與整個Web應用程序相關的對象和屬性，它實質上是跨越整個Web應用程序，包括多個頁面、請求和會話的一個全局作用域。

104、如何實現JSP或Servlet的單線程模式？
答：
對於JSP頁面，可以通過page指令進行設置。

<%@page isThreadSafe=”false”%>

對於Servlet，可以讓自定義的Servlet實現SingleThreadModel標識接口。

說明：如果將JSP或Servlet設置成單線程工作模式，會導致每個請求創建一個Servlet實例，這種實踐將導致嚴重的性能問題（服務器的內存壓力很大，還會導致頻繁的垃圾回收），所以通常情況下並不會這麼做。

105、實現會話跟蹤的技術有哪些？
答：由於HTTP協議本身是無狀態的，服務器爲了區分不同的用戶，就需要對用戶會話進行跟蹤，簡單的說就是爲用戶進行登記，爲用戶分配唯一的ID，下一次用戶在請求中包含此ID，服務器據此判斷到底是哪一個用戶。
①URL 重寫：在URL中添加用戶會話的信息作爲請求的參數，或者將唯一的會話ID添加到URL結尾以標識一個會話。
②設置表單隱藏域：將和會話跟蹤相關的字段添加到隱式表單域中，這些信息不會在瀏覽器中顯示但是提交表單時會提交給服務器。
這兩種方式很難處理跨越多個頁面的信息傳遞，因爲如果每次都要修改URL或在頁面中添加隱式表單域來存儲用戶會話相關信息，事情將變得非常麻煩。
③cookie：cookie有兩種，一種是基於窗口的，瀏覽器窗口關閉後，cookie就沒有了；另一種是將信息存儲在一個臨時文件中，並設置存在的時間。當用戶通過瀏覽器和服務器建立一次會話後，會話ID就會隨響應信息返回存儲在基於窗口的cookie中，那就意味着只要瀏覽器沒有關閉，會話沒有超時，下一次請求時這個會話ID又會提交給服務器讓服務器識別用戶身份。會話中可以爲用戶保存信息。會話對象是在服務器內存中的，而基於窗口的cookie是在客戶端內存中的。如果瀏覽器禁用了cookie，那麼就需要通過下面兩種方式進行會話跟蹤。當然，在使用cookie時要注意幾點：首先不要在cookie中存放敏感信息；其次cookie存儲的數據量有限（4k），不能將過多的內容存儲cookie中；再者瀏覽器通常只允許一個站點最多存放20個cookie。當然，和用戶會話相關的其他信息（除了會話ID）也可以存在cookie方便進行會話跟蹤。
④HttpSession：在所有會話跟蹤技術中，HttpSession對象是最強大也是功能最多的。當一個用戶第一次訪問某個網站時會自動創建HttpSession，每個用戶可以訪問他自己的HttpSession。可以通過HttpServletRequest對象的getSession方法獲得HttpSession，通過HttpSession的setAttribute方法可以將一個值放在HttpSession中，通過調用HttpSession對象的getAttribute方法，同時傳入屬性名就可以獲取保存在HttpSession中的對象。與上面三種方式不同的是，HttpSession放在服務器的內存中，因此不要將過大的對象放在裏面，即使目前的Servlet容器可以在內存將滿時將HttpSession中的對象移到其他存儲設備中，但是這樣勢必影響性能。添加到HttpSession中的值可以是任意Java對象，這個對象最好實現了Serializable接口，這樣Servlet容器在必要的時候可以將其序列化到文件中，否則在序列化時就會出現異常。

**補充：**HTML5中可以使用Web Storage技術通過JavaScript來保存數據，例如可以使用localStorage和sessionStorage來保存用戶會話的信息，也能夠實現會話跟蹤。

106、過濾器有哪些作用和用法？
答： Java Web開發中的過濾器（filter）是從Servlet 2.3規範開始增加的功能，並在Servlet 2.4規範中得到增強。對Web應用來說，過濾器是一個駐留在服務器端的Web組件，它可以截取客戶端和服務器之間的請求與響應信息，並對這些信息進行過濾。當Web容器接受到一個對資源的請求時，它將判斷是否有過濾器與這個資源相關聯。如果有，那麼容器將把請求交給過濾器進行處理。在過濾器中，你可以改變請求的內容，或者重新設置請求的報頭信息，然後再將請求發送給目標資源。當目標資源對請求作出響應時候，容器同樣會將響應先轉發給過濾器，在過濾器中你可以對響應的內容進行轉換，然後再將響應發送到客戶端。

常見的過濾器用途主要包括：對用戶請求進行統一認證、對用戶的訪問請求進行記錄和審覈、對用戶發送的數據進行過濾或替換、轉換圖象格式、對響應內容進行壓縮以減少傳輸量、對請求或響應進行加解密處理、觸發資源訪問事件、對XML的輸出應用XSLT等。

和過濾器相關的接口主要有：Filter、FilterConfig和FilterChain。

編碼過濾器的例子：

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;

@WebFilter(urlPatterns = { "*" }, 
        initParams = {@WebInitParam(name="encoding", value="utf-8")})
public class CodingFilter implements Filter {
    private String defaultEncoding = "utf-8";

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        req.setCharacterEncoding(defaultEncoding);
        resp.setCharacterEncoding(defaultEncoding);
        chain.doFilter(req, resp);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        String encoding = config.getInitParameter("encoding");
        if (encoding != null) {
            defaultEncoding = encoding;
        }
    }
}

下載計數過濾器的例子：

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

@WebFilter(urlPatterns = {"/*"})
public class DownloadCounterFilter implements Filter {

    private ExecutorService executorService = Executors.newSingleThreadExecutor();
    private Properties downloadLog;
    private File logFile;

    @Override
    public void destroy() {
        executorService.shutdown();
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        final String uri = request.getRequestURI();
        executorService.execute(new Runnable() {

            @Override
            public void run() {
                String value = downloadLog.getProperty(uri);
                if(value == null) {
                    downloadLog.setProperty(uri, "1");
                }
                else {
                    int count = Integer.parseInt(value);
                    downloadLog.setProperty(uri, String.valueOf(++count));
                }
                try {
                    downloadLog.store(new FileWriter(logFile), "");
                } 
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        chain.doFilter(req, resp);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        String appPath = config.getServletContext().getRealPath("/");
        logFile = new File(appPath, "downloadLog.txt");
        if(!logFile.exists()) {
            try {
                logFile.createNewFile();
            } 
            catch(IOException e) {
                e.printStackTrace();
            }
        }
        downloadLog = new Properties();
        try {
            downloadLog.load(new FileReader(logFile));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

說明：這裏使用了Servlet 3規範中的註解來部署過濾器，當然也可以在web.xml中使用<filter>和<filter-mapping>標籤部署過濾器，如108題中所示。

107、監聽器有哪些作用和用法？
答：Java Web開發中的監聽器（listener）就是application、session、request三個對象創建、銷燬或者往其中添加修改刪除屬性時自動執行代碼的功能組件，如下所示：
①ServletContextListener：對Servlet上下文的創建和銷燬進行監聽。
②ServletContextAttributeListener：監聽Servlet上下文屬性的添加、刪除和替換。
③HttpSessionListener：對Session的創建和銷燬進行監聽。

補充：session的銷燬有兩種情況：1). session超時（可以在web.xml中通過<session-config>/<session-timeout>標籤配置超時時間）；2). 通過調用session對象的invalidate()方法使session失效。

④HttpSessionAttributeListener：對Session對象中屬性的添加、刪除和替換進行監聽。
⑤ServletRequestListener：對請求對象的初始化和銷燬進行監聽。
⑥ServletRequestAttributeListener：對請求對象屬性的添加、刪除和替換進行監聽。

下面是一個統計網站最多在線人數監聽器的例子。

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**
 上下文監聽器，在服務器啓動時初始化onLineCount和maxOnLineCount兩個變量
 並將其置於服務器上下文（ServletContext）中，其初始值都是0
*/
@WebListener
public class InitListener implements ServletContextListener {

    @Override
    public void contextDestroyed(ServletContextEvent evt) {
    }

    @Override
    public void contextInitialized(ServletContextEvent evt) {
        evt.getServletContext().setAttribute("onLineCount", 0);
        evt.getServletContext().setAttribute("maxOnLineCount", 0);
    }

}

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.ServletContext;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

/**
 會話監聽器，在用戶會話創建和銷燬的時候根據情況
 修改onLineCount和maxOnLineCount的值
*/
@WebListener
public class MaxCountListener implements HttpSessionListener {

    @Override
    public void sessionCreated(HttpSessionEvent event) {
        ServletContext ctx = event.getSession().getServletContext();
        int count = Integer.parseInt(ctx.getAttribute("onLineCount").toString());
        count++;
        ctx.setAttribute("onLineCount", count);
        int maxOnLineCount = Integer.parseInt(ctx.getAttribute("maxOnLineCount").toString());
        if (count > maxOnLineCount) {
            ctx.setAttribute("maxOnLineCount", count);
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            ctx.setAttribute("date", df.format(new Date()));
        }
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        ServletContext app = event.getSession().getServletContext();
        int count = Integer.parseInt(app.getAttribute("onLineCount").toString());
        count--;
        app.setAttribute("onLineCount", count);
    }
}

說明：這裏使用了Servlet 3規範中的@WebListener註解配置監聽器，當然你可以在web.xml文件中用<listener>標籤配置監聽器，如108題中所示。

108、web.xml文件中可以配置哪些內容？
答：web.xml用於配置Web應用的相關信息，如：監聽器（listener）、過濾器（filter）、 Servlet、相關參數、會話超時時間、安全驗證方式、錯誤頁面等，下面是一些開發中常見的配置：

①配置Spring上下文加載監聽器加載Spring配置文件並創建IoC容器：

  <context-param>
     <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

  <listener>
     <listener-class>
       org.springframework.web.context.ContextLoaderListener
     </listener-class>
  </listener>

②配置Spring的OpenSessionInView過濾器來解決延遲加載和Hibernate會話關閉的矛盾：

  <filter>
      <filter-name>openSessionInView</filter-name>
      <filter-class>
         org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
      </filter-class>
  </filter>

  <filter-mapping>
      <filter-name>openSessionInView</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

③配置會話超時時間爲10分鐘：

  <session-config>
      <session-timeout>10</session-timeout>
  </session-config>

④配置404和Exception的錯誤頁面：

  <error-page>
      <error-code>404</error-code>
      <location>/error.jsp</location>
  </error-page>

  <error-page>
      <exception-type>java.lang.Exception</exception-type>
      <location>/error.jsp</location>
  </error-page>⑤配置安全認證方式：

  <security-constraint>
      <web-resource-collection>
          <web-resource-name>ProtectedArea</web-resource-name>
          <url-pattern>/admin/*</url-pattern>
          <http-method>GET</http-method>
          <http-method>POST</http-method>
      </web-resource-collection>
      <auth-constraint>
          <role-name>admin</role-name>
      </auth-constraint>
  </security-constraint>

  <login-config>
      <auth-method>BASIC</auth-method>
  </login-config>

  <security-role>
      <role-name>admin</role-name>
  </security-role>

說明：對Servlet（小服務）、Listener（監聽器）和Filter（過濾器）等Web組件的配置，Servlet 3規範提供了基於註解的配置方式，可以分別使用@WebServlet、@WebListener、@WebFilter註解進行配置。

補充：如果Web提供了有價值的商業信息或者是敏感數據，那麼站點的安全性就是必須考慮的問題。安全認證是實現安全性的重要手段，認證就是要解決“Are you who you say you are?”的問題。認證的方式非常多，簡單說來可以分爲三類：
A. What you know? — 口令
B. What you have? — 數字證書（U盾、密保卡）
C. Who you are? — 指紋識別、虹膜識別
在Tomcat中可以通過建立安全套接字層（Secure Socket Layer, SSL）以及通過基本驗證或表單驗證來實現對安全性的支持。

109、你的項目中使用過哪些JSTL標籤？
答：項目中主要使用了JSTL的核心標籤庫，包括<c:if>、<c:choose>、<c: when>、<c: otherwise>、<c:forEach>等，主要用於構造循環和分支結構以控制顯示邏輯。

說明：雖然JSTL標籤庫提供了core、sql、fmt、xml等標籤庫，但是實際開發中建議只使用核心標籤庫（core），而且最好只使用分支和循環標籤並輔以表達式語言（EL），這樣才能真正做到數據顯示和業務邏輯的分離，這纔是最佳實踐。

110、使用標籤庫有什麼好處？如何自定義JSP標籤？
答：使用標籤庫的好處包括以下幾個方面：
- 分離JSP頁面的內容和邏輯，簡化了Web開發；
- 開發者可以創建自定義標籤來封裝業務邏輯和顯示邏輯；
- 標籤具有很好的可移植性、可維護性和可重用性；
- 避免了對Scriptlet（小腳本）的使用（很多公司的項目開發都不允許在JSP中書寫小腳本）

自定義JSP標籤包括以下幾個步驟：
- 編寫一個Java類實現實現Tag/BodyTag/IterationTag接口（開發中通常不直接實現這些接口而是繼承TagSupport/BodyTagSupport/SimpleTagSupport類，這是對缺省適配模式的應用），重寫doStartTag()、doEndTag()等方法，定義標籤要完成的功能
- 編寫擴展名爲tld的標籤描述文件對自定義標籤進行部署，tld文件通常放在WEB-INF文件夾下或其子目錄中
- 在JSP頁面中使用taglib指令引用該標籤庫

下面是一個自定義標籤庫的例子。

步驟1 - 標籤類源代碼TimeTag.java：

package com.jackfrued.tags;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;

public class TimeTag extends TagSupport {
    private static final long serialVersionUID = 1L;

    private String format = "yyyy-MM-dd hh:mm:ss";
    private String foreColor = "black";
    private String backColor = "white";

    public int doStartTag() throws JspException {
         SimpleDateFormat sdf = new SimpleDateFormat(format);
         JspWriter writer = pageContext.getOut();
         StringBuilder sb = new StringBuilder();
         sb.append(String.format("<span style='color:%s;background-color:%s'>%s</span>",
             foreColor, backColor, sdf.format(new Date())));
         try {
           writer.print(sb.toString());
         } catch(IOException e) {
           e.printStackTrace();
         }
         return SKIP_BODY;
      }

    public void setFormat(String format) {
        this.format = format;
    }

    public void setForeColor(String foreColor) {
        this.foreColor = foreColor;
    }

    public void setBackColor(String backColor) {
        this.backColor = backColor;
    }
}

步驟2 - 編寫標籤庫描述文件my.tld：

<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    version="2.0">

    <description>定義標籤庫</description>
    <tlib-version>1.0</tlib-version>
    <short-name>MyTag</short-name>
    <tag>
        <name>time</name>
        <tag-class>com.jackfrued.tags.TimeTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <name>format</name>
            <required>false</required>
        </attribute>
        <attribute>
            <name>foreColor</name>
        </attribute>
        <attribute>
            <name>backColor</name>
        </attribute>
    </tag>
</taglib>

步驟3 - 在JSP頁面中使用自定義標籤：

<%@ page pageEncoding="UTF-8"%>
<%@ taglib prefix="my" uri="/WEB-INF/tld/my.tld" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>

<!DOCTYPE html>
<html>
  <head>
    <base href="<%=basePath%>">
    <title>首頁</title>
    <style type="text/css">
        * { font-family: "Arial"; font-size:72px; }
    </style>
  </head>

  <body>
    <my:time format="yyyy-MM-dd" backColor="blue" foreColor="yellow"/>
  </body>
</html>

提示：如果要將自定義的標籤庫發佈成JAR文件，需要將標籤庫描述文件（tld文件）放在JAR文件的META-INF目錄下，可以JDK中的jar工具完成JAR文件的生成，如果不清楚如何操作，可以請教谷老師和百老師。

111、說一下表達式語言（EL）的隱式對象及其作用。
答：EL的隱式對象包括：pageContext、initParam（訪問上下文參數）、param（訪問請求參數）、paramValues、header（訪問請求頭）、headerValues、cookie（訪問cookie）、applicationScope（訪問application作用域）、sessionScope（訪問session作用域）、requestScope（訪問request作用域）、pageScope（訪問page作用域）。

用法如下所示：

${pageContext.request.method}
${pageContext["request"]["method"]}
${pageContext.request["method"]}
${pageContext["request"].method}
${initParam.defaultEncoding}
${header["accept-language"]}
${headerValues["accept-language"][0]}
${cookie.jsessionid.value}
${sessionScope.loginUser.username}

補充：表達式語言的.和[]運算作用是一致的，唯一的差別在於如果訪問的屬性名不符合Java標識符命名規則，例如上面的accept-language就不是一個有效的Java標識符，那麼這時候就只能用[]運算符而不能使用.運算符獲取它的值

112、表達式語言（EL）支持哪些運算符？
答：除了.和[]運算符，EL還提供了：
- 算術運算符：+、-、*、/或div、%或mod
- 關係運算符：==或eq、!=或ne、>或gt、>=或ge、<或lt、<=或le
- 邏輯運算符：&&或and、||或or、!或not
- 條件運算符：${statement? A : B}（跟Java的條件運算符類似）
- empty運算符：檢查一個值是否爲null或者空（數組長度爲0或集合中沒有元素也返回true）

113、Java Web開發的Model 1和Model 2分別指的是什麼？
答：Model 1是以頁面爲中心的Java Web開發，使用JSP+JavaBean技術將頁面顯示邏輯和業務邏輯處理分開，JSP實現頁面顯示，JavaBean對象用來保存數據和實現業務邏輯。Model 2是基於MVC（模型-視圖-控制器，Model-View-Controller）架構模式的開發模型，實現了模型和視圖的徹底分離，利於團隊開發和代碼複用，如下圖所示。

114、Servlet 3中的異步處理指的是什麼？
答：在Servlet 3中引入了一項新的技術可以讓Servlet異步處理請求。有人可能會質疑，既然都有多線程了，還需要異步處理請求嗎？答案是肯定的，因爲如果一個任務處理時間相當長，那麼Servlet或Filter會一直佔用着請求處理線程直到任務結束，隨着併發用戶的增加，容器將會遭遇線程超出的風險，這這種情況下很多的請求將會被堆積起來而後續的請求可能會遭遇拒絕服務，直到有資源可以處理請求爲止。異步特性可以幫助應用節省容器中的線程，特別適合執行時間長而且用戶需要得到結果的任務，如果用戶不需要得到結果則直接將一個Runnable對象交給Executor並立即返回即可。（如果不清楚多線程和線程池的相關內容，請查看《Java面試題全集（上）》關於多線程和線程池的部分或閱讀我的另一篇文章《關於Java併發編程的總結和思考》）

補充：多線程在Java誕生初期無疑是一個亮點，而Servlet單實例多線程的工作方式也曾爲其贏得美名，然而技術的發展往往會顛覆我們很多的認知，就如同當年愛因斯坦的相對論顛覆了牛頓的經典力學一般。事實上，異步處理絕不是Serlvet 3首創，如果你瞭解Node.js的話，對Servlet 3的這個重要改進就不以爲奇了。

下面是一個支持異步處理請求的Servlet的例子。

import java.io.IOException;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(urlPatterns = {"/async"}, asyncSupported = true)
public class AsyncServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        // 開啓Tomcat異步Servlet支持
        req.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);

        final AsyncContext ctx = req.startAsync();  // 啓動異步處理的上下文
        // ctx.setTimeout(30000);
        ctx.start(new Runnable() {

            @Override
            public void run() {
                // 在此處添加異步處理的代碼

                ctx.complete();
            }
        });
    }
}

115、如何在基於Java的Web項目中實現文件上傳和下載？
答：在Sevlet 3 以前，Servlet API中沒有支持上傳功能的API，因此要實現上傳功能需要引入第三方工具從POST請求中獲得上傳的附件或者通過自行處理輸入流來獲得上傳的文件，我們推薦使用Apache的commons-fileupload。
從Servlet 3開始，文件上傳變得無比簡單，相信看看下面的例子一切都清楚了。

上傳頁面index.jsp：

<%@ page pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Photo Upload</title>
</head>
<body>
<h1>Select your photo and upload</h1>
<hr/>
<div style="color:red;font-size:14px;">${hint}</div>
<form action="UploadServlet" method="post" enctype="multipart/form-data">
    Photo file: <input type="file" name="photo" />
    <input type="submit" value="Upload" />
</form>
</body>
</html>

支持上傳的Servlet：

package com.jackfrued.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.Part;

@WebServlet("/UploadServlet")
@MultipartConfig
public class UploadServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        // 可以用request.getPart()方法獲得名爲photo的上傳附件
        // 也可以用request.getParts()獲得所有上傳附件（多文件上傳）
        // 然後通過循環分別處理每一個上傳的文件
        Part part = request.getPart("photo");
        if (part != null && part.getSubmittedFileName().length() > 0) {
            // 用ServletContext對象的getRealPath()方法獲得上傳文件夾的絕對路徑
            String savePath = request.getServletContext().getRealPath("/upload");
            // Servlet 3.1規範中可以用Part對象的getSubmittedFileName()方法獲得上傳的文件名
            // 更好的做法是爲上傳的文件進行重命名（避免同名文件的相互覆蓋）
            part.write(savePath + "/" + part.getSubmittedFileName());
            request.setAttribute("hint", "Upload Successfully!");
        } else {
            request.setAttribute("hint", "Upload failed!");
        }
        // 跳轉回到上傳頁面
        request.getRequestDispatcher("index.jsp").forward(request, response);
    }

}

116、服務器收到用戶提交的表單數據，到底是調用Servlet的doGet()還是doPost()方法？
答：HTML的<form>元素有一個method屬性，用來指定提交表單的方式，其值可以是get或post。我們自定義的Servlet一般情況下會重寫doGet()或doPost()兩個方法之一或全部，如果是GET請求就調用doGet()方法，如果是POST請求就調用doPost()方法，那爲什麼爲什麼這樣呢？我們自定義的Servlet通常繼承自HttpServlet，HttpServlet繼承自GenericServlet並重寫了其中的service()方法，這個方法是Servlet接口中定義的。HttpServlet重寫的service()方法會先獲取用戶請求的方法，然後根據請求方法調用doGet()、doPost()、doPut()、doDelete()等方法，如果在自定義Servlet中重寫了這些方法，那麼顯然會調用重寫過的（自定義的）方法，這顯然是對模板方法模式的應用（如果不理解，請參考閻宏博士的《Java與模式》一書的第37章）。當然，自定義Servlet中也可以直接重寫service()方法，那麼不管是哪種方式的請求，都可以通過自己的代碼進行處理，這對於不區分請求方法的場景比較合適。

117、JSP中的靜態包含和動態包含有什麼區別？
答：靜態包含是通過JSP的include指令包含頁面，動態包含是通過JSP標準動作<jsp:forward>包含頁面。靜態包含是編譯時包含，如果包含的頁面不存在則會產生編譯錯誤，而且兩個頁面的"contentType"屬性應保持一致，因爲兩個頁面會合二爲一，只產生一個class文件，因此被包含頁面發生的變動再包含它的頁面更新前不會得到更新。動態包含是運行時包含，可以向被包含的頁面傳遞參數，包含頁面和被包含頁面是獨立的，會編譯出兩個class文件，如果被包含的頁面不存在，不會產生編譯錯誤，也不影響頁面其他部分的執行。代碼如下所示：

<%-- 靜態包含 --%>
<%@ include file="..." %>

<%-- 動態包含 --%>
<jsp:include page="...">
    <jsp:param name="..." value="..." />
</jsp:include>

118、Servlet中如何獲取用戶提交的查詢參數或表單數據？
答：可以通過請求對象（HttpServletRequest）的getParameter()方法通過參數名獲得參數值。如果有包含多個值的參數（例如複選框），可以通過請求對象的getParameterValues()方法獲得。當然也可以通過請求對象的getParameterMap()獲得一個參數名和參數值的映射（Map）。

119、Servlet中如何獲取用戶配置的初始化參數以及服務器上下文參數？
答：可以通過重寫Servlet接口的init(ServletConfig)方法並通過ServletConfig對象的getInitParameter()方法來獲取Servlet的初始化參數。可以通過ServletConfig對象的getServletContext()方法獲取ServletContext對象，並通過該對象的getInitParameter()方法來獲取服務器上下文參數。當然，ServletContext對象也在處理用戶請求的方法（如doGet()方法）中通過請求對象的getServletContext()方法來獲得。

120、如何設置請求的編碼以及響應內容的類型？
答：通過請求對象（ServletRequest）的setCharacterEncoding(String)方法可以設置請求的編碼，其實要徹底解決亂碼問題就應該讓頁面、服務器、請求和響應、Java程序都使用統一的編碼，最好的選擇當然是UTF-8；通過響應對象（ServletResponse）的setContentType(String)方法可以設置響應內容的類型，當然也可以通過HttpServletResponsed對象的setHeader(String, String)方法來設置。

說明：現在如果還有公司在面試的時候問JSP的聲明標記、表達式標記、小腳本標記這些內容的話，這樣的公司也不用去了，其實JSP內置對象、JSP指令這些東西基本上都可以忘卻了，關於Java Web開發的相關知識，可以看一下我的《Servlet&JSP思維導圖》，上面有完整的知識點的羅列。想了解如何實現自定義MVC框架的，可以看一下我的《Java Web自定義MVC框架詳解》。

121、解釋一下網絡應用的模式及其特點。
答：典型的網絡應用模式大致有三類：B/S、C/S、P2P。其中B代表瀏覽器（Browser）、C代表客戶端（Client）、S代表服務器（Server），P2P是對等模式，不區分客戶端和服務器。B/S應用模式中可以視爲特殊的C/S應用模式，只是將C/S應用模式中的特殊的客戶端換成了瀏覽器，因爲幾乎所有的系統上都有瀏覽器，那麼只要打開瀏覽器就可以使用應用，沒有安裝、配置、升級客戶端所帶來的各種開銷。P2P應用模式中，成千上萬臺彼此連接的計算機都處於對等的地位，整個網絡一般來說不依賴專用的集中服務器。網絡中的每一臺計算機既能充當網絡服務的請求者，又對其它計算機的請求作出響應，提供資源和服務。通常這些資源和服務包括：信息的共享和交換、計算資源（如CPU的共享）、存儲共享（如緩存和磁盤空間的使用）等，這種應用模式最大的阻力安全性、版本等問題，目前有很多應用都混合使用了多種應用模型，最常見的網絡視頻應用，它幾乎把三種模式都用上了。

補充：此題要跟"電子商務模式"區分開，因爲有很多人被問到這個問題的時候馬上想到的是B2B（如阿里巴巴）、B2C（如噹噹、亞馬遜、京東）、C2C（如淘寶、拍拍）、C2B（如威客）、O2O（如美團、餓了麼）。對於這類問題，可以去百度上面科普一下。

122、什麼是Web Service（Web服務）？
答：從表面上看，Web Service就是一個應用程序，它向外界暴露出一個能夠通過Web進行調用的API。這就是說，你能夠用編程的方法透明的調用這個應用程序，不需要了解它的任何細節，跟你使用的編程語言也沒有關係。例如可以創建一個提供天氣預報的Web Service，那麼無論你用哪種編程語言開發的應用都可以通過調用它的API並傳入城市信息來獲得該城市的天氣預報。之所以稱之爲Web Service，是因爲它基於HTTP協議傳輸數據，這使得運行在不同機器上的不同應用無須藉助附加的、專門的第三方軟件或硬件，就可相互交換數據或集成。

補充：這裏必須要提及的一個概念是SOA（Service-Oriented Architecture，面向服務的架構），SOA是一種思想，它將應用程序的不同功能單元通過中立的契約聯繫起來，獨立於硬件平臺、操作系統和編程語言，使得各種形式的功能單元能夠更好的集成。顯然，Web Service是SOA的一種較好的解決方案，它更多的是一種標準，而不是一種具體的技術。

123、概念解釋：SOAP、WSDL、UDDI。
答：
- SOAP：簡單對象訪問協議（Simple Object Access Protocol），是Web Service中交換數據的一種協議規範。
- WSDL：Web服務描述語言（Web Service Description Language），它描述了Web服務的公共接口。這是一個基於XML的關於如何與Web服務通訊和使用的服務描述；也就是描述與目錄中列出的Web服務進行交互時需要綁定的協議和信息格式。通常採用抽象語言描述該服務支持的操作和信息，使用的時候再將實際的網絡協議和信息格式綁定給該服務。
- UDDI：統一描述、發現和集成（Universal Description, Discovery and Integration），它是一個基於XML的跨平臺的描述規範，可以使世界範圍內的企業在互聯網上發佈自己所提供的服務。簡單的說，UDDI是訪問各種WSDL的一個門面（可以參考設計模式中的門面模式）。

提示：關於Web Service的相關概念和知識可以在W3CSchool上找到相關的資料。

124、Java規範中和Web Service相關的規範有哪些？
答：Java規範中和Web Service相關的有三個：
- JAX-WS(JSR 224)：這個規範是早期的基於SOAP的Web Service規範JAX-RPC的替代版本，它並不提供向下兼容性，因爲RPC樣式的WSDL以及相關的API已經在Java EE5中被移除了。WS-MetaData是JAX-WS的依賴規範，提供了基於註解配置Web Service和SOAP消息的相關API。
- JAXM(JSR 67)：定義了發送和接收消息所需的API,相當於Web Service的服務器端。
- JAX-RS(JSR 311 & JSR 339 & JSR 370)：是Java針對REST（Representation State Transfer）架構風格制定的一套Web Service規範。REST是一種軟件架構模式，是一種風格，它不像SOAP那樣本身承載着一種消息協議， (兩種風格的Web Service均採用了HTTP做傳輸協議，因爲HTTP協議能穿越防火牆，Java的遠程方法調用（RMI）等是重量級協議，通常不能穿越防火牆），因此可以將REST視爲基於HTTP協議的軟件架構。REST中最重要的兩個概念是資源定位和資源操作，而HTTP協議恰好完整的提供了這兩個點。HTTP協議中的URI可以完成資源定位，而GET、POST、OPTION、DELETE方法可以完成資源操作。因此REST完全依賴HTTP協議就可以完成Web Service，而不像SOAP協議那樣只利用了HTTP的傳輸特性，定位和操作都是由SOAP協議自身完成的，也正是由於SOAP消息的存在使得基於SOAP的Web Service顯得笨重而逐漸被淘汰。

125、介紹一下你瞭解的Java領域的Web Service框架。
答：Java領域的Web Service框架很多，包括Axis2（Axis的升級版本）、Jersey（RESTful的Web Service框架）、CXF（XFire的延續版本）、Hessian、Turmeric、JBoss SOA等，其中絕大多數都是開源框架。

提示：面試被問到這類問題的時候一定選擇自己用過的最熟悉的作答，如果之前沒有了解過就應該在面試前花一些時間瞭解其中的兩個，並比較其優缺點，這樣才能在面試時給出一個漂亮的答案。

這部分主要是開源Java EE框架方面的內容，包括Hibernate、MyBatis、Spring、Spring MVC等，由於Struts 2已經是明日黃花，在這裏就不討論Struts 2的面試題，如果需要了解相關內容，可以參考我的另一篇文章《Java面試題集（86-115）》。此外，這篇文章還對企業應用架構、大型網站架構和應用服務器優化等內容進行了簡單的探討，這些內容相信對面試會很有幫助。

126、什麼是ORM？
答：對象關係映射（Object-Relational Mapping，簡稱ORM）是一種爲了解決程序的面向對象模型與數據庫的關係模型互不匹配問題的技術；簡單的說，ORM是通過使用描述對象和數據庫之間映射的元數據（在Java中可以用XML或者是註解），將程序中的對象自動持久化到關係數據庫中或者將關係數據庫表中的行轉換成Java對象，其本質上就是將數據從一種形式轉換到另外一種形式。

127、持久層設計要考慮的問題有哪些？你用過的持久層框架有哪些？
答：所謂"持久"就是將數據保存到可掉電式存儲設備中以便今後使用，簡單的說，就是將內存中的數據保存到關係型數據庫、文件系統、消息隊列等提供持久化支持的設備中。持久層就是系統中專注於實現數據持久化的相對獨立的層面。

持久層設計的目標包括：
- 數據存儲邏輯的分離，提供抽象化的數據訪問接口。
- 數據訪問底層實現的分離，可以在不修改代碼的情況下切換底層實現。
- 資源管理和調度的分離，在數據訪問層實現統一的資源調度（如緩存機制）。
- 數據抽象，提供更面向對象的數據操作。

持久層框架有：
- Hibernate
- MyBatis
- TopLink
- Guzz
- jOOQ
- Spring Data
- ActiveJDBC

128、Hibernate中SessionFactory是線程安全的嗎？Session是線程安全的嗎（兩個線程能夠共享同一個Session嗎）？
答：SessionFactory對應Hibernate的一個數據存儲的概念，它是線程安全的，可以被多個線程併發訪問。SessionFactory一般只會在啓動的時候構建。對於應用程序，最好將SessionFactory通過單例模式進行封裝以便於訪問。Session是一個輕量級非線程安全的對象（線程間不能共享session），它表示與數據庫進行交互的一個工作單元。Session是由SessionFactory創建的，在任務完成之後它會被關閉。Session是持久層服務對外提供的主要接口。Session會延遲獲取數據庫連接（也就是在需要的時候纔會獲取）。爲了避免創建太多的session，可以使用ThreadLocal將session和當前線程綁定在一起，這樣可以讓同一個線程獲得的總是同一個session。Hibernate 3中SessionFactory的getCurrentSession()方法就可以做到。

129、Hibernate中Session的load和get方法的區別是什麼？
答：主要有以下三項區別：
① 如果沒有找到符合條件的記錄，get方法返回null，load方法拋出異常。
② get方法直接返回實體類對象，load方法返回實體類對象的代理。
③ 在Hibernate 3之前，get方法只在一級緩存中進行數據查找，如果沒有找到對應的數據則越過二級緩存，直接發出SQL語句完成數據讀取；load方法則可以從二級緩存中獲取數據；從Hibernate 3開始，get方法不再是對二級緩存只寫不讀，它也是可以訪問二級緩存的。

說明：對於load()方法Hibernate認爲該數據在數據庫中一定存在可以放心的使用代理來實現延遲加載，如果沒有數據就拋出異常，而通過get()方法獲取的數據可以不存在。

130、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法分別是做什麼的？有什麼區別？
答：Hibernate的對象有三種狀態：瞬時態（transient）、持久態（persistent）和遊離態（detached），如第135題中的圖所示。瞬時態的實例可以通過調用save()、persist()或者saveOrUpdate()方法變成持久態；遊離態的實例可以通過調用 update()、saveOrUpdate()、lock()或者replicate()變成持久態。save()和persist()將會引發SQL的INSERT語句，而update()或merge()會引發UPDATE語句。save()和update()的區別在於一個是將瞬時態對象變成持久態，一個是將遊離態對象變爲持久態。merge()方法可以完成save()和update()方法的功能，它的意圖是將新的狀態合併到已有的持久化對象上或創建新的持久化對象。對於persist()方法，按照官方文檔的說明：① persist()方法把一個瞬時態的實例持久化，但是並不保證標識符被立刻填入到持久化實例中，標識符的填入可能被推遲到flush的時間；② persist()方法保證當它在一個事務外部被調用的時候並不觸發一個INSERT語句，當需要封裝一個長會話流程的時候，persist()方法是很有必要的；③ save()方法不保證第②條，它要返回標識符，所以它會立即執行INSERT語句，不管是在事務內部還是外部。至於lock()方法和update()方法的區別，update()方法是把一個已經更改過的脫管狀態的對象變成持久狀態；lock()方法是把一個沒有更改過的脫管狀態的對象變成持久狀態。

131、闡述Session加載實體對象的過程。
答：Session加載實體對象的步驟是：
① Session在調用數據庫查詢功能之前，首先會在一級緩存中通過實體類型和主鍵進行查找，如果一級緩存查找命中且數據狀態合法，則直接返回；
② 如果一級緩存沒有命中，接下來Session會在當前NonExists記錄（相當於一個查詢黑名單，如果出現重複的無效查詢可以迅速做出判斷，從而提升性能）中進行查找，如果NonExists中存在同樣的查詢條件，則返回null；
③ 如果一級緩存查詢失敗則查詢二級緩存，如果二級緩存命中則直接返回；
④ 如果之前的查詢都未命中，則發出SQL語句，如果查詢未發現對應記錄則將此次查詢添加到Session的NonExists中加以記錄，並返回null；
⑤ 根據映射配置和SQL語句得到ResultSet，並創建對應的實體對象；
⑥ 將對象納入Session（一級緩存）的管理；
⑦ 如果有對應的攔截器，則執行攔截器的onLoad方法；
⑧ 如果開啓並設置了要使用二級緩存，則將數據對象納入二級緩存；
⑨ 返回數據對象。

132、Query接口的list方法和iterate方法有什麼區別？
答：
① list()方法無法利用一級緩存和二級緩存（對緩存只寫不讀），它只能在開啓查詢緩存的前提下使用查詢緩存；iterate()方法可以充分利用緩存，如果目標數據只讀或者讀取頻繁，使用iterate()方法可以減少性能開銷。
② list()方法不會引起N+1查詢問題，而iterate()方法可能引起N+1查詢問題

說明：關於N+1查詢問題，可以參考CSDN上的一篇文章《什麼是N+1查詢》

133、Hibernate如何實現分頁查詢？
答：通過Hibernate實現分頁查詢，開發人員只需要提供HQL語句（調用Session的createQuery()方法）或查詢條件（調用Session的createCriteria()方法）、設置查詢起始行數（調用Query或Criteria接口的setFirstResult()方法）和最大查詢行數（調用Query或Criteria接口的setMaxResults()方法），並調用Query或Criteria接口的list()方法，Hibernate會自動生成分頁查詢的SQL語句。

134、鎖機制有什麼用？簡述Hibernate的悲觀鎖和樂觀鎖機制。
答：有些業務邏輯在執行過程中要求對數據進行排他性的訪問，於是需要通過一些機制保證在此過程中數據被鎖住不會被外界修改，這就是所謂的鎖機制。
Hibernate支持悲觀鎖和樂觀鎖兩種鎖機制。悲觀鎖，顧名思義悲觀的認爲在數據處理過程中極有可能存在修改數據的併發事務（包括本系統的其他事務或來自外部系統的事務），於是將處理的數據設置爲鎖定狀態。悲觀鎖必須依賴數據庫本身的鎖機制才能真正保證數據訪問的排他性，關於數據庫的鎖機制和事務隔離級別在《Java面試題大全（上）》中已經討論過了。樂觀鎖，顧名思義，對併發事務持樂觀態度（認爲對數據的併發操作不會經常性的發生），通過更加寬鬆的鎖機制來解決由於悲觀鎖排他性的數據訪問對系統性能造成的嚴重影響。最常見的樂觀鎖是通過數據版本標識來實現的，讀取數據時獲得數據的版本號，更新數據時將此版本號加1，然後和數據庫表對應記錄的當前版本號進行比較，如果提交的數據版本號大於數據庫中此記錄的當前版本號則更新數據，否則認爲是過期數據無法更新。Hibernate中通過Session的get()和load()方法從數據庫中加載對象時可以通過參數指定使用悲觀鎖；而樂觀鎖可以通過給實體類加整型的版本字段再通過XML或@Version註解進行配置。

提示：使用樂觀鎖會增加了一個版本字段，很明顯這需要額外的空間來存儲這個版本字段，浪費了空間，但是樂觀鎖會讓系統具有更好的併發性，這是對時間的節省。因此樂觀鎖也是典型的空間換時間的策略。

135、闡述實體對象的三種狀態以及轉換關係。
答：最新的Hibernate文檔中爲Hibernate對象定義了四種狀態（原來是三種狀態，面試的時候基本上問的也是三種狀態），分別是：瞬時態（new, or transient）、持久態（managed, or persistent）、遊狀態（detached）和移除態（removed，以前Hibernate文檔中定義的三種狀態中沒有移除態），如下圖所示，就以前的Hibernate文檔中移除態被視爲是瞬時態。

瞬時態：當new一個實體對象後，這個對象處於瞬時態，即這個對象只是一個保存臨時數據的內存區域，如果沒有變量引用這個對象，則會被JVM的垃圾回收機制回收。這個對象所保存的數據與數據庫沒有任何關係，除非通過Session的save()、saveOrUpdate()、persist()、merge()方法把瞬時態對象與數據庫關聯，並把數據插入或者更新到數據庫，這個對象才轉換爲持久態對象。
持久態：持久態對象的實例在數據庫中有對應的記錄，並擁有一個持久化標識（ID）。對持久態對象進行delete操作後，數據庫中對應的記錄將被刪除，那麼持久態對象與數據庫記錄不再存在對應關係，持久態對象變成移除態（可以視爲瞬時態）。持久態對象被修改變更後，不會馬上同步到數據庫，直到數據庫事務提交。
遊離態：當Session進行了close()、clear()、evict()或flush()後，實體對象從持久態變成遊離態，對象雖然擁有持久和與數據庫對應記錄一致的標識值，但是因爲對象已經從會話中清除掉，對象不在持久化管理之內，所以處於遊離態（也叫脫管態）。遊離態的對象與臨時狀態對象是十分相似的，只是它還含有持久化標識。

提示：關於這個問題，在Hibernate的官方文檔中有更爲詳細的解讀。

136、如何理解Hibernate的延遲加載機制？在實際應用中，延遲加載與Session關閉的矛盾是如何處理的？
答：延遲加載就是並不是在讀取的時候就把數據加載進來，而是等到使用時再加載。Hibernate使用了虛擬代理機制實現延遲加載，我們使用Session的load()方法加載數據或者一對多關聯映射在使用延遲加載的情況下從一的一方加載多的一方，得到的都是虛擬代理，簡單的說返回給用戶的並不是實體本身，而是實體對象的代理。代理對象在用戶調用getter方法時纔會去數據庫加載數據。但加載數據就需要數據庫連接。而當我們把會話關閉時，數據庫連接就同時關閉了。

延遲加載與session關閉的矛盾一般可以這樣處理：
① 關閉延遲加載特性。這種方式操作起來比較簡單，因爲Hibernate的延遲加載特性是可以通過映射文件或者註解進行配置的，但這種解決方案存在明顯的缺陷。首先，出現"no session or session was closed"通常說明系統中已經存在主外鍵關聯，如果去掉延遲加載的話，每次查詢的開銷都會變得很大。
② 在session關閉之前先獲取需要查詢的數據，可以使用工具方法Hibernate.isInitialized()判斷對象是否被加載，如果沒有被加載則可以使用Hibernate.initialize()方法加載對象。
③ 使用攔截器或過濾器延長Session的生命週期直到視圖獲得數據。Spring整合Hibernate提供的OpenSessionInViewFilter和OpenSessionInViewInterceptor就是這種做法。

137、舉一個多對多關聯的例子，並說明如何實現多對多關聯映射。
答：例如：商品和訂單、學生和課程都是典型的多對多關係。可以在實體類上通過@ManyToMany註解配置多對多關聯或者通過映射文件中的和標籤配置多對多關聯，但是實際項目開發中，很多時候都是將多對多關聯映射轉換成兩個多對一關聯映射來實現的。

138、談一下你對繼承映射的理解。
答：繼承關係的映射策略有三種：
① 每個繼承結構一張表（table per class hierarchy），不管多少個子類都用一張表。
② 每個子類一張表（table per subclass），公共信息放一張表，特有信息放單獨的表。
③ 每個具體類一張表（table per concrete class），有多少個子類就有多少張表。
第一種方式屬於單表策略，其優點在於查詢子類對象的時候無需表連接，查詢速度快，適合多態查詢；缺點是可能導致表很大。後兩種方式屬於多表策略，其優點在於數據存儲緊湊，其缺點是需要進行連接查詢，不適合多態查詢。

139、簡述Hibernate常見優化策略。
答：這個問題應當挑自己使用過的優化策略回答，常用的有：
① 制定合理的緩存策略（二級緩存、查詢緩存）。
② 採用合理的Session管理機制。
③ 儘量使用延遲加載特性。
④ 設定合理的批處理參數。
⑤ 如果可以，選用UUID作爲主鍵生成器。
⑥ 如果可以，選用基於版本號的樂觀鎖替代悲觀鎖。
⑦ 在開發過程中, 開啓hibernate.show_sql選項查看生成的SQL，從而瞭解底層的狀況；開發完成後關閉此選項。
⑧ 考慮數據庫本身的優化，合理的索引、恰當的數據分區策略等都會對持久層的性能帶來可觀的提升，但這些需要專業的DBA（數據庫管理員）提供支持。

140、談一談Hibernate的一級緩存、二級緩存和查詢緩存。
答：Hibernate的Session提供了一級緩存的功能，默認總是有效的，當應用程序保存持久化實體、修改持久化實體時，Session並不會立即把這種改變提交到數據庫，而是緩存在當前的Session中，除非顯示調用了Session的flush()方法或通過close()方法關閉Session。通過一級緩存，可以減少程序與數據庫的交互，從而提高數據庫訪問性能。
SessionFactory級別的二級緩存是全局性的，所有的Session可以共享這個二級緩存。不過二級緩存默認是關閉的，需要顯示開啓並指定需要使用哪種二級緩存實現類（可以使用第三方提供的實現）。一旦開啓了二級緩存並設置了需要使用二級緩存的實體類，SessionFactory就會緩存訪問過的該實體類的每個對象，除非緩存的數據超出了指定的緩存空間。
一級緩存和二級緩存都是對整個實體進行緩存，不會緩存普通屬性，如果希望對普通屬性進行緩存，可以使用查詢緩存。查詢緩存是將HQL或SQL語句以及它們的查詢結果作爲鍵值對進行緩存，對於同樣的查詢可以直接從緩存中獲取數據。查詢緩存默認也是關閉的，需要顯示開啓。

141、Hibernate中DetachedCriteria類是做什麼的？
答：DetachedCriteria和Criteria的用法基本上是一致的，但Criteria是由Session的createCriteria()方法創建的，也就意味着離開創建它的Session，Criteria就無法使用了。DetachedCriteria不需要Session就可以創建（使用DetachedCriteria.forClass()方法創建），所以通常也稱其爲離線的Criteria，在需要進行查詢操作的時候再和Session綁定（調用其getExecutableCriteria(Session)方法），這也就意味着一個DetachedCriteria可以在需要的時候和不同的Session進行綁定。

142、@OneToMany註解的mappedBy屬性有什麼作用？
答：@OneToMany用來配置一對多關聯映射，但通常情況下，一對多關聯映射都由多的一方來維護關聯關係，例如學生和班級，應該在學生類中添加班級屬性來維持學生和班級的關聯關係（在數據庫中是由學生表中的外鍵班級編號來維護學生表和班級表的多對一關係），如果要使用雙向關聯，在班級類中添加一個容器屬性來存放學生，並使用@OneToMany註解進行映射，此時mappedBy屬性就非常重要。如果使用XML進行配置，可以用<set>標籤的inverse="true"設置來達到同樣的效果。

143、MyBatis中使用#和$書寫佔位符有什麼區別？
答：#將傳入的數據都當成一個字符串，會對傳入的數據自動加上引號；$將傳入的數據直接顯示生成在SQL中。注意：使用$佔位符可能會導致SQL注射攻擊，能用#的地方就不要使用$，寫order by子句的時候應該用$而不是#。

144、解釋一下MyBatis中命名空間（namespace）的作用。
答：在大型項目中，可能存在大量的SQL語句，這時候爲每個SQL語句起一個唯一的標識（ID）就變得並不容易了。爲了解決這個問題，在MyBatis中，可以爲每個映射文件起一個唯一的命名空間，這樣定義在這個映射文件中的每個SQL語句就成了定義在這個命名空間中的一個ID。只要我們能夠保證每個命名空間中這個ID是唯一的，即使在不同映射文件中的語句ID相同，也不會再產生衝突了。

145、MyBatis中的動態SQL是什麼意思？
答：對於一些複雜的查詢，我們可能會指定多個查詢條件，但是這些條件可能存在也可能不存在，例如在58同城上面找房子，我們可能會指定面積、樓層和所在位置來查找房源，也可能會指定面積、價格、戶型和所在位置來查找房源，此時就需要根據用戶指定的條件動態生成SQL語句。如果不使用持久層框架我們可能需要自己拼裝SQL語句，還好MyBatis提供了動態SQL的功能來解決這個問題。MyBatis中用於實現動態SQL的元素主要有：
- if
- choose / when / otherwise
- trim
- where
- set
- foreach

下面是映射文件的片段。

    <select id="foo" parameterType="Blog" resultType="Blog">
        select * from t_blog where 1 = 1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="content != null">
            and content = #{content}
        </if>
        <if test="owner != null">
            and owner = #{owner}
        </if>
   </select>

當然也可以像下面這些書寫。

    <select id="foo" parameterType="Blog" resultType="Blog">
        select * from t_blog where 1 = 1 
        <choose>
            <when test="title != null">
                and title = #{title}
            </when>
            <when test="content != null">
                and content = #{content}
            </when>
            <otherwise>
                and owner = "owner1"
            </otherwise>
        </choose>
    </select>

再看看下面這個例子。

    <select id="bar" resultType="Blog">
        select * from t_blog where id in
        <foreach collection="array" index="index" 
            item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>

146、什麼是IoC和DI？DI是如何實現的？
答：IoC叫控制反轉，是Inversion of Control的縮寫，DI（Dependency Injection）叫依賴注入，是對IoC更簡單的詮釋。控制反轉是把傳統上由程序代碼直接操控的對象的調用權交給容器，通過容器來實現對象組件的裝配和管理。所謂的"控制反轉"就是對組件對象控制權的轉移，從程序代碼本身轉移到了外部容器，由容器來創建對象並管理對象之間的依賴關係。IoC體現了好萊塢原則 - "Don’t call me, we will call you"。依賴注入的基本原則是應用組件不應該負責查找資源或者其他依賴的協作對象。配置對象的工作應該由容器負責，查找資源的邏輯應該從應用組件的代碼中抽取出來，交給容器來完成。DI是對IoC更準確的描述，即組件之間的依賴關係由容器在運行期決定，形象的來說，即由容器動態的將某種依賴關係注入到組件之中。

舉個例子：一個類A需要用到接口B中的方法，那麼就需要爲類A和接口B建立關聯或依賴關係，最原始的方法是在類A中創建一個接口B的實現類C的實例，但這種方法需要開發人員自行維護二者的依賴關係，也就是說當依賴關係發生變動的時候需要修改代碼並重新構建整個系統。如果通過一個容器來管理這些對象以及對象的依賴關係，則只需要在類A中定義好用於關聯接口B的方法（構造器或setter方法），將類A和接口B的實現類C放入容器中，通過對容器的配置來實現二者的關聯。

依賴注入可以通過setter方法注入（設值注入）、構造器注入和接口注入三種方式來實現，Spring支持setter注入和構造器注入，通常使用構造器注入來注入必須的依賴關係，對於可選的依賴關係，則setter注入是更好的選擇，setter注入需要類提供無參構造器或者無參的靜態工廠方法來創建對象。

147、Spring中Bean的作用域有哪些？
答：在Spring的早期版本中，僅有兩個作用域：singleton和prototype，前者表示Bean以單例的方式存在；後者表示每次從容器中調用Bean時，都會返回一個新的實例，prototype通常翻譯爲原型。

補充：設計模式中的創建型模式中也有一個原型模式，原型模式也是一個常用的模式，例如做一個室內設計軟件，所有的素材都在工具箱中，而每次從工具箱中取出的都是素材對象的一個原型，可以通過對象克隆來實現原型模式。

Spring 2.x中針對WebApplicationContext新增了3個作用域，分別是：request（每次HTTP請求都會創建一個新的Bean）、session（同一個HttpSession共享同一個Bean，不同的HttpSession使用不同的Bean）和globalSession（同一個全局Session共享一個Bean）。

說明：單例模式和原型模式都是重要的設計模式。一般情況下，無狀態或狀態不可變的類適合使用單例模式。在傳統開發中，由於DAO持有Connection這個非線程安全對象因而沒有使用單例模式；但在Spring環境下，所有DAO類對可以採用單例模式，因爲Spring利用AOP和Java API中的ThreadLocal對非線程安全的對象進行了特殊處理。

ThreadLocal爲解決多線程程序的併發問題提供了一種新的思路。ThreadLocal，顧名思義是線程的一個本地化對象，當工作於多線程中的對象使用ThreadLocal維護變量時，ThreadLocal爲每個使用該變量的線程分配一個獨立的變量副本，所以每一個線程都可以獨立的改變自己的副本，而不影響其他線程所對應的副本。從線程的角度看，這個變量就像是線程的本地變量。

ThreadLocal類非常簡單好用，只有四個方法，能用上的也就是下面三個方法：
- void set(T value)：設置當前線程的線程局部變量的值。
- T get()：獲得當前線程所對應的線程局部變量的值。
- void remove()：刪除當前線程中線程局部變量的值。

ThreadLocal是如何做到爲每一個線程維護一份獨立的變量副本的呢？在ThreadLocal類中有一個Map，鍵爲線程對象，值是其線程對應的變量的副本，自己要模擬實現一個ThreadLocal類其實並不困難，代碼如下所示：

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class MyThreadLocal<T> {
    private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());

    public void set(T newValue) {
        map.put(Thread.currentThread(), newValue);
    }

    public T get() {
        return map.get(Thread.currentThread());
    }

    public void remove() {
        map.remove(Thread.currentThread());
    }
}

148、解釋一下什麼叫AOP（面向切面編程）？
答：AOP（Aspect-Oriented Programming）指一種程序設計範型，該範型以一種稱爲切面（aspect）的語言構造爲基礎，切面是一種新的模塊化機制，用來描述分散在對象、類或方法中的橫切關注點（crosscutting concern）。

149、你是如何理解"橫切關注"這個概念的？
答："橫切關注"是會影響到整個應用程序的關注功能，它跟正常的業務邏輯是正交的，沒有必然的聯繫，但是幾乎所有的業務邏輯都會涉及到這些關注功能。通常，事務、日誌、安全性等關注就是應用中的橫切關注功能。

150、你如何理解AOP中的連接點（Joinpoint）、切點（Pointcut）、增強（Advice）、引介（Introduction）、織入（Weaving）、切面（Aspect）這些概念？
答：
a. 連接點（Joinpoint）：程序執行的某個特定位置（如：某個方法調用前、調用後，方法拋出異常後）。一個類或一段程序代碼擁有一些具有邊界性質的特定點，這些代碼中的特定點就是連接點。Spring僅支持方法的連接點。
b. 切點（Pointcut）：如果連接點相當於數據中的記錄，那麼切點相當於查詢條件，一個切點可以匹配多個連接點。Spring AOP的規則解析引擎負責解析切點所設定的查詢條件，找到對應的連接點。
c. 增強（Advice）：增強是織入到目標類連接點上的一段程序代碼。Spring提供的增強接口都是帶方位名的，如：BeforeAdvice、AfterReturningAdvice、ThrowsAdvice等。很多資料上將增強譯爲“通知”，這明顯是個詞不達意的翻譯，讓很多程序員困惑了許久。

說明： Advice在國內的很多書面資料中都被翻譯成"通知"，但是很顯然這個翻譯無法表達其本質，有少量的讀物上將這個詞翻譯爲"增強"，這個翻譯是對Advice較爲準確的詮釋，我們通過AOP將橫切關注功能加到原有的業務邏輯上，這就是對原有業務邏輯的一種增強，這種增強可以是前置增強、後置增強、返回後增強、拋異常時增強和包圍型增強。

d. 引介（Introduction）：引介是一種特殊的增強，它爲類添加一些屬性和方法。這樣，即使一個業務類原本沒有實現某個接口，通過引介功能，可以動態的未該業務類添加接口的實現邏輯，讓業務類成爲這個接口的實現類。
e. 織入（Weaving）：織入是將增強添加到目標類具體連接點上的過程，AOP有三種織入方式：①編譯期織入：需要特殊的Java編譯期（例如AspectJ的ajc）；②裝載期織入：要求使用特殊的類加載器，在裝載類的時候對類進行增強；③運行時織入：在運行時爲目標類生成代理實現增強。Spring採用了動態代理的方式實現了運行時織入，而AspectJ採用了編譯期織入和裝載期織入的方式。
f. 切面（Aspect）：切面是由切點和增強（引介）組成的，它包括了對橫切關注功能的定義，也包括了對連接點的定義。

補充：代理模式是GoF提出的23種設計模式中最爲經典的模式之一，代理模式是對象的結構模式，它給某一個對象提供一個代理對象，並由代理對象控制對原對象的引用。簡單的說，代理對象可以完成比原對象更多的職責，當需要爲原對象添加橫切關注功能時，就可以使用原對象的代理對象。我們在打開Office系列的Word文檔時，如果文檔中有插圖，當文檔剛加載時，文檔中的插圖都只是一個虛框佔位符，等用戶真正翻到某頁要查看該圖片時，纔會真正加載這張圖，這其實就是對代理模式的使用，代替真正圖片的虛框就是一個虛擬代理；Hibernate的load方法也是返回一個虛擬代理對象，等用戶真正需要訪問對象的屬性時，才向數據庫發出SQL語句獲得真實對象。

下面用一個找槍手代考的例子演示代理模式的使用：

/**
 * 參考人員接口
 * @author 駱昊
 *
 */
public interface Candidate {

    /**
     * 答題
     */
    public void answerTheQuestions();
}

/**
 * 懶學生
 * @author 駱昊
 *
 */
public class LazyStudent implements Candidate {
    private String name;        // 姓名

    public LazyStudent(String name) {
        this.name = name;
    }

    @Override
    public void answerTheQuestions() {
        // 懶學生只能寫出自己的名字不會答題
        System.out.println("姓名: " + name);
    }

}

/**
 * 槍手
 * @author 駱昊
 *
 */
public class Gunman implements Candidate {
    private Candidate target;   // 被代理對象

    public Gunman(Candidate target) {
        this.target = target;
    }

    @Override
    public void answerTheQuestions() {
        // 槍手要寫上代考的學生的姓名
        target.answerTheQuestions();
        // 槍手要幫助懶學生答題並交卷
        System.out.println("奮筆疾書正確答案");
        System.out.println("交卷");
    }

}

public class ProxyTest1 {

    public static void main(String[] args) {
        Candidate c = new Gunman(new LazyStudent("王小二"));
        c.answerTheQuestions();
    }
}

說明：從JDK 1.3開始，Java提供了動態代理技術，允許開發者在運行時創建接口的代理實例，主要包括Proxy類和InvocationHandler接口。下面的例子使用動態代理爲ArrayList編寫一個代理，在添加和刪除元素時，在控制檯打印添加或刪除的元素以及ArrayList的大小：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.List;

public class ListProxy<T> implements InvocationHandler {
    private List<T> target;

    public ListProxy(List<T> target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object retVal = null;
        System.out.println("[" + method.getName() + ": " + args[0] + "]");
        retVal = method.invoke(target, args);
        System.out.println("[size=" + target.size() + "]");
        return retVal;
    }

}

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public class ProxyTest2 {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        Class<?> clazz = list.getClass();
        ListProxy<String> myProxy = new ListProxy<String>(list);
        List<String> newList = (List<String>) 
                Proxy.newProxyInstance(clazz.getClassLoader(), 
                clazz.getInterfaces(), myProxy);
        newList.add("apple");
        newList.add("banana");
        newList.add("orange");
        newList.remove("banana");
    }
}

說明：使用Java的動態代理有一個侷限性就是代理的類必須要實現接口，雖然面向接口編程是每個優秀的Java程序都知道的規則，但現實往往不盡如人意，對於沒有實現接口的類如何爲其生成代理呢？繼承！繼承是最經典的擴展已有代碼能力的手段，雖然繼承常常被初學者濫用，但繼承也常常被進階的程序員忽視。CGLib採用非常底層的字節碼生成技術，通過爲一個類創建子類來生成代理，它彌補了Java動態代理的不足，因此Spring中動態代理和CGLib都是創建代理的重要手段，對於實現了接口的類就用動態代理爲其生成代理類，而沒有實現接口的類就用CGLib通過繼承的方式爲其創建代理。

151、Spring中自動裝配的方式有哪些？
答：
- no：不進行自動裝配，手動設置Bean的依賴關係。
- byName：根據Bean的名字進行自動裝配。
- byType：根據Bean的類型進行自動裝配。
- constructor：類似於byType，不過是應用於構造器的參數，如果正好有一個Bean與構造器的參數類型相同則可以自動裝配，否則會導致錯誤。
- autodetect：如果有默認的構造器，則通過constructor的方式進行自動裝配，否則使用byType的方式進行自動裝配。

說明：自動裝配沒有自定義裝配方式那麼精確，而且不能自動裝配簡單屬性（基本類型、字符串等），在使用時應注意。

152、Spring中如何使用註解來配置Bean？有哪些相關的註解？
答：首先需要在Spring配置文件中增加如下配置：

<context:component-scan base-package="org.example"/>

然後可以用@Component、@Controller、@Service、@Repository註解來標註需要由Spring IoC容器進行對象託管的類。這幾個註解沒有本質區別，只不過@Controller通常用於控制器，@Service通常用於業務邏輯類，@Repository通常用於倉儲類（例如我們的DAO實現類），普通的類用@Component來標註。

153、Spring支持的事務管理類型有哪些？你在項目中使用哪種方式？
答：Spring支持編程式事務管理和聲明式事務管理。許多Spring框架的用戶選擇聲明式事務管理，因爲這種方式和應用程序的關聯較少，因此更加符合輕量級容器的概念。聲明式事務管理要優於編程式事務管理，儘管在靈活性方面它弱於編程式事務管理，因爲編程式事務允許你通過代碼控制業務。

事務分爲全局事務和局部事務。全局事務由應用服務器管理，需要底層服務器JTA支持（如WebLogic、WildFly等）。局部事務和底層採用的持久化方案有關，例如使用JDBC進行持久化時，需要使用Connetion對象來操作事務；而採用Hibernate進行持久化時，需要使用Session對象來操作事務。

Spring提供瞭如下所示的事務管理器。

事務管理器實現類	目標對象
DataSourceTransactionManager	注入DataSource
HibernateTransactionManager	注入SessionFactory
JdoTransactionManager	管理JDO事務
JtaTransactionManager	使用JTA管理事務
PersistenceBrokerTransactionManager	管理Apache的OJB事務

這些事務的父接口都是PlatformTransactionManager。Spring的事務管理機制是一種典型的策略模式，PlatformTransactionManager代表事務管理接口，該接口定義了三個方法，該接口並不知道底層如何管理事務，但是它的實現類必須提供getTransaction()方法（開啓事務）、commit()方法（提交事務）、rollback()方法（回滾事務）的多態實現，這樣就可以用不同的實現類代表不同的事務管理策略。使用JTA全局事務策略時，需要底層應用服務器支持，而不同的應用服務器所提供的JTA全局事務可能存在細節上的差異，因此實際配置全局事務管理器是可能需要使用JtaTransactionManager的子類，如：WebLogicJtaTransactionManager（Oracle的WebLogic服務器提供）、UowJtaTransactionManager（IBM的WebSphere服務器提供）等。

編程式事務管理如下所示。

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:p="http://www.springframework.org/schema/p"
    xmlns:p="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

     <context:component-scan base-package="com.jackfrued"/>

     <bean id="propertyConfig"
         class="org.springframework.beans.factory.config.
  PropertyPlaceholderConfigurer">
         <property name="location">
             <value>jdbc.properties</value>
         </property>
     </bean>

     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
         <property name="driverClassName">
             <value>${db.driver}</value>
         </property>
         <property name="url">
             <value>${db.url}</value>
         </property>
         <property name="username">
             <value>${db.username}</value>
         </property>
         <property name="password">
             <value>${db.password}</value>
         </property>
     </bean>

     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <property name="dataSource">
             <ref bean="dataSource" />
         </property>
     </bean>

     <!-- JDBC事務管理器 -->
     <bean id="transactionManager"
         class="org.springframework.jdbc.datasource.
       DataSourceTransactionManager"　scope="singleton">
         <property name="dataSource">
             <ref bean="dataSource" />
         </property>
     </bean>

     <!-- 聲明事務模板 -->
     <bean id="transactionTemplate"
         class="org.springframework.transaction.support.
   TransactionTemplate">
         <property name="transactionManager">
             <ref bean="transactionManager" />
         </property>
     </bean>

</beans>

package com.jackfrued.dao.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;

import com.jackfrued.dao.EmpDao;
import com.jackfrued.entity.Emp;

@Repository
public class EmpDaoImpl implements EmpDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public boolean save(Emp emp) {
        String sql = "insert into emp values (?,?,?)";
        return jdbcTemplate.update(sql, emp.getId(), emp.getName(), emp.getBirthday()) == 1;
    }

}

package com.jackfrued.biz.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import com.jackfrued.biz.EmpService;
import com.jackfrued.dao.EmpDao;
import com.jackfrued.entity.Emp;

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private TransactionTemplate txTemplate;
    @Autowired
    private EmpDao empDao;

    @Override
    public void addEmp(final Emp emp) {
        txTemplate.execute(new TransactionCallbackWithoutResult() {

            @Override
            protected void doInTransactionWithoutResult(TransactionStatus txStatus) {
                empDao.save(emp);
            }
        });
    }


}

聲明式事務如下圖所示，以Spring整合Hibernate 3爲例，包括完整的DAO和業務邏輯代碼。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.2.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

    <!-- 配置由Spring IoC容器託管的對象對應的被註解的類所在的包 -->
    <context:component-scan base-package="com.jackfrued" />

    <!-- 配置通過自動生成代理實現AOP功能 -->
    <aop:aspectj-autoproxy />

    <!-- 配置數據庫連接池 (DBCP) -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <!-- 配置驅動程序類 -->
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <!-- 配置連接數據庫的URL -->
        <property name="url" value="jdbc:mysql://localhost:3306/myweb" />
        <!-- 配置訪問數據庫的用戶名 -->
        <property name="username" value="root" />
        <!-- 配置訪問數據庫的口令 -->
        <property name="password" value="123456" />
        <!-- 配置最大連接數 -->
        <property name="maxActive" value="150" />
        <!-- 配置最小空閒連接數 -->
        <property name="minIdle" value="5" />
        <!-- 配置最大空閒連接數 -->
        <property name="maxIdle" value="20" />
        <!-- 配置初始連接數 -->
        <property name="initialSize" value="10" />
        <!-- 配置連接被泄露時是否生成日誌 -->
        <property name="logAbandoned" value="true" />
        <!-- 配置是否刪除超時連接 -->
        <property name="removeAbandoned" value="true" />
        <!-- 配置刪除超時連接的超時門限值(以秒爲單位) -->
        <property name="removeAbandonedTimeout" value="120" />
        <!-- 配置超時等待時間(以毫秒爲單位) -->
        <property name="maxWait" value="5000" />
        <!-- 配置空閒連接回收器線程運行的時間間隔(以毫秒爲單位) -->
        <property name="timeBetweenEvictionRunsMillis" value="300000" />
        <!-- 配置連接空閒多長時間後(以毫秒爲單位)被斷開連接 -->
        <property name="minEvictableIdleTimeMillis" value="60000" />
    </bean>

    <!-- 配置Spring提供的支持註解ORM映射的Hibernate會話工廠 -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <!-- 通過setter注入數據源屬性 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 配置實體類所在的包 -->
        <property name="packagesToScan" value="com.jackfrued.entity" />
        <!-- 配置Hibernate的相關屬性 -->
        <property name="hibernateProperties">
            <!-- 在項目調試完成後要刪除show_sql和format_sql屬性否則對性能有顯著影響 -->
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
            </value>
        </property>
    </bean>

    <!-- 配置Spring提供的Hibernate事務管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <!-- 通過setter注入Hibernate會話工廠 -->
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置基於註解配置聲明式事務 -->
    <tx:annotation-driven />

</beans>

package com.jackfrued.dao;

import java.io.Serializable;
import java.util.List;

import com.jackfrued.comm.QueryBean;
import com.jackfrued.comm.QueryResult;

/**
 * 數據訪問對象接口(以對象爲單位封裝CRUD操作)
 * @author 駱昊
 *
 * @param <E> 實體類型
 * @param <K> 實體標識字段的類型
 */
public interface BaseDao <E, K extends Serializable> {

    /**
     * 新增
     * @param entity 業務實體對象
     * @return 增加成功返回實體對象的標識
     */
    public K save(E entity);

    /**
     * 刪除
     * @param entity 業務實體對象
     */
    public void delete(E entity);

    /**
     * 根據ID刪除
     * @param id 業務實體對象的標識
     * @return 刪除成功返回true否則返回false
     */
    public boolean deleteById(K id);

    /**
     * 修改
     * @param entity 業務實體對象
     * @return 修改成功返回true否則返回false
     */
    public void update(E entity);

    /**
     * 根據ID查找業務實體對象
     * @param id 業務實體對象的標識
     * @return 業務實體對象對象或null
     */
    public E findById(K id);

    /**
     * 根據ID查找業務實體對象
     * @param id 業務實體對象的標識
     * @param lazy 是否使用延遲加載
     * @return 業務實體對象對象
     */
    public E findById(K id, boolean lazy);

    /**
     * 查找所有業務實體對象
     * @return 裝所有業務實體對象的列表容器
     */
    public List<E> findAll();

    /**
     * 分頁查找業務實體對象
     * @param page 頁碼
     * @param size 頁面大小
     * @return 查詢結果對象
     */
    public QueryResult<E> findByPage(int page, int size);

    /**
     * 分頁查找業務實體對象
     * @param queryBean 查詢條件對象
     * @param page 頁碼
     * @param size 頁面大小
     * @return 查詢結果對象
     */
    public QueryResult<E> findByPage(QueryBean queryBean, int page, int size);

}

package com.jackfrued.dao;

import java.io.Serializable;
import java.util.List;

import com.jackfrued.comm.QueryBean;
import com.jackfrued.comm.QueryResult;

/**
 * BaseDao的缺省適配器
 * @author 駱昊
 *
 * @param <E> 實體類型
 * @param <K> 實體標識字段的類型
 */
public abstract class BaseDaoAdapter<E, K extends Serializable> implements
        BaseDao<E, K> {

    @Override
    public K save(E entity) {
        return null;
    }

    @Override
    public void delete(E entity) {
    }

    @Override
    public boolean deleteById(K id) {
        E entity = findById(id);
        if(entity != null) {
            delete(entity);
            return true;
        }
        return false;
    }

    @Override
    public void update(E entity) {
    }

    @Override
    public E findById(K id) {
        return null;
    }

    @Override
    public E findById(K id, boolean lazy) {
        return null;
    }

    @Override
    public List<E> findAll() {
        return null;
    }

    @Override
    public QueryResult<E> findByPage(int page, int size) {
        return null;
    }

    @Override
    public QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {
        return null;
    }

}

package com.jackfrued.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;

import com.jackfrued.comm.HQLQueryBean;
import com.jackfrued.comm.QueryBean;
import com.jackfrued.comm.QueryResult;

/**
 * 基於Hibernate的BaseDao實現類
 * @author 駱昊
 *
 * @param <E> 實體類型
 * @param <K> 主鍵類型
 */
@SuppressWarnings(value = {"unchecked"})
public abstract class BaseDaoHibernateImpl<E, K extends Serializable> extends BaseDaoAdapter<E, K> {
    @Autowired
    protected SessionFactory sessionFactory;

    private Class<?> entityClass;       // 業務實體的類對象
    private String entityName;          // 業務實體的名字

    public BaseDaoHibernateImpl() {
        ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
        entityClass = (Class<?>) pt.getActualTypeArguments()[0];
        entityName = entityClass.getSimpleName();
    }

    @Override
    public K save(E entity) {
        return (K) sessionFactory.getCurrentSession().save(entity);
    }

    @Override
    public void delete(E entity) {
        sessionFactory.getCurrentSession().delete(entity);
    }

    @Override
    public void update(E entity) {
        sessionFactory.getCurrentSession().update(entity);
    }

    @Override
    public E findById(K id) {
        return findById(id, false);
    }

    @Override
    public E findById(K id, boolean lazy) {
        Session session = sessionFactory.getCurrentSession();
        return (E) (lazy? session.load(entityClass, id) : session.get(entityClass, id));
    }

    @Override
    public List<E> findAll() {
        return sessionFactory.getCurrentSession().createCriteria(entityClass).list();
    }

    @Override
    public QueryResult<E> findByPage(int page, int size) {
        return new QueryResult<E>(
            findByHQLAndPage("from " + entityName , page, size),
            getCountByHQL("select count(*) from " + entityName)
        );
    }

    @Override
    public QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {
        if(queryBean instanceof HQLQueryBean) {
            HQLQueryBean hqlQueryBean = (HQLQueryBean) queryBean;
            return new QueryResult<E>(
                findByHQLAndPage(hqlQueryBean.getQueryString(), page, size, hqlQueryBean.getParameters()),
                getCountByHQL(hqlQueryBean.getCountString(), hqlQueryBean.getParameters())
            );
        }
        return null;
    }

    /**
     * 根據HQL和可變參數列表進行查詢
     * @param hql 基於HQL的查詢語句
     * @param params 可變參數列表
     * @return 持有查詢結果的列表容器或空列表容器
     */
    protected List<E> findByHQL(String hql, Object... params) {
        return this.findByHQL(hql, getParamList(params));
    }

    /**
     * 根據HQL和參數列表進行查詢
     * @param hql 基於HQL的查詢語句
     * @param params 查詢參數列表
     * @return 持有查詢結果的列表容器或空列表容器
     */
    protected List<E> findByHQL(String hql, List<Object> params) {
        List<E> list = createQuery(hql, params).list();
        return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;
    }

    /**
     * 根據HQL和參數列表進行分頁查詢
     * @param hql 基於HQL的查詢語句
     * @page 頁碼
     * @size 頁面大小
     * @param params 可變參數列表
     * @return 持有查詢結果的列表容器或空列表容器
     */
    protected List<E> findByHQLAndPage(String hql, int page, int size, Object... params) {
        return this.findByHQLAndPage(hql, page, size, getParamList(params));
    }

    /**
     * 根據HQL和參數列表進行分頁查詢
     * @param hql 基於HQL的查詢語句
     * @page 頁碼
     * @size 頁面大小
     * @param params 查詢參數列表
     * @return 持有查詢結果的列表容器或空列表容器
     */
    protected List<E> findByHQLAndPage(String hql, int page, int size, List<Object> params) {
        List<E> list = createQuery(hql, params)
                .setFirstResult((page - 1) * size)
                .setMaxResults(size)
                .list();
        return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;
    }

    /**
     * 查詢滿足條件的記錄數
     * @param hql 基於HQL的查詢語句
     * @param params 可變參數列表
     * @return 滿足查詢條件的總記錄數
     */
    protected long getCountByHQL(String hql, Object... params) {
        return this.getCountByHQL(hql, getParamList(params));
    }

    /**
     * 查詢滿足條件的記錄數
     * @param hql 基於HQL的查詢語句
     * @param params 參數列表容器
     * @return 滿足查詢條件的總記錄數
     */
    protected long getCountByHQL(String hql, List<Object> params) {
        return (Long) createQuery(hql, params).uniqueResult();
    }

    // 創建Hibernate查詢對象(Query)
    private Query createQuery(String hql, List<Object> params) {
        Query query = sessionFactory.getCurrentSession().createQuery(hql);
        for(int i = 0; i < params.size(); i++) {
            query.setParameter(i, params.get(i));
        }
        return query;
    }

    // 將可變參數列表組裝成列表容器
    private List<Object> getParamList(Object... params) {
        List<Object> paramList = new ArrayList<>();
        if(params != null) {
            for(int i = 0; i < params.length; i++) {
                paramList.add(params[i]);
            }
        }
        return paramList.size() == 0? Collections.EMPTY_LIST : paramList;
    }

}

package com.jackfrued.comm;

import java.util.List;

/**
 * 查詢條件的接口
 * @author 駱昊
 *
 */
public interface QueryBean {

    /**
     * 添加排序字段
     * @param fieldName 用於排序的字段
     * @param asc 升序還是降序
     * @return 查詢條件對象自身(方便級聯編程)
     */
    public QueryBean addOrder(String fieldName, boolean asc);

    /**
     * 添加排序字段
     * @param available 是否添加此排序字段
     * @param fieldName 用於排序的字段
     * @param asc 升序還是降序
     * @return 查詢條件對象自身(方便級聯編程)
     */
    public QueryBean addOrder(boolean available, String fieldName, boolean asc);

    /**
     * 添加查詢條件
     * @param condition 條件
     * @param params 替換掉條件中參數佔位符的參數
     * @return 查詢條件對象自身(方便級聯編程)
     */
    public QueryBean addCondition(String condition, Object... params);

    /**
     * 添加查詢條件
     * @param available 是否需要添加此條件
     * @param condition 條件
     * @param params 替換掉條件中參數佔位符的參數
     * @return 查詢條件對象自身(方便級聯編程)
     */
    public QueryBean addCondition(boolean available, String condition, Object... params);

    /**
     * 獲得查詢語句
     * @return 查詢語句
     */
    public String getQueryString();

    /**
     * 獲取查詢記錄數的查詢語句
     * @return 查詢記錄數的查詢語句
     */
    public String getCountString();

    /**
     * 獲得查詢參數
     * @return 查詢參數的列表容器
     */
    public List<Object> getParameters();
}

package com.jackfrued.comm;

import java.util.List;

/**
 * 查詢結果
 * @author 駱昊
 *
 * @param <T> 泛型參數
 */
public class QueryResult<T> {
    private List<T> result;     // 持有查詢結果的列表容器
    private long totalRecords;  // 查詢到的總記錄數

    /**
     * 構造器
     */
    public QueryResult() {
    }

    /**
     * 構造器
     * @param result 持有查詢結果的列表容器
     * @param totalRecords 查詢到的總記錄數
     */
    public QueryResult(List<T> result, long totalRecords) {
        this.result = result;
        this.totalRecords = totalRecords;
    }

    public List<T> getResult() {
        return result;
    }

    public void setResult(List<T> result) {
        this.result = result;
    }

    public long getTotalRecords() {
        return totalRecords;
    }

    public void setTotalRecords(long totalRecords) {
        this.totalRecords = totalRecords;
    }
}

package com.jackfrued.dao;

import com.jackfrued.comm.QueryResult;
import com.jackfrued.entity.Dept;

/**
 * 部門數據訪問對象接口
 * @author 駱昊
 *
 */
public interface DeptDao extends BaseDao<Dept, Integer> {

    /**
     * 分頁查詢頂級部門
     * @param page 頁碼
     * @param size 頁碼大小
     * @return 查詢結果對象
     */
    public QueryResult<Dept> findTopDeptByPage(int page, int size);

}

package com.jackfrued.dao.impl;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.jackfrued.comm.QueryResult;
import com.jackfrued.dao.BaseDaoHibernateImpl;
import com.jackfrued.dao.DeptDao;
import com.jackfrued.entity.Dept;

@Repository
public class DeptDaoImpl extends BaseDaoHibernateImpl<Dept, Integer> implements DeptDao {
    private static final String HQL_FIND_TOP_DEPT = " from Dept as d where d.superiorDept is null ";

    @Override
    public QueryResult<Dept> findTopDeptByPage(int page, int size) {
        List<Dept> list = findByHQLAndPage(HQL_FIND_TOP_DEPT, page, size);
        long totalRecords = getCountByHQL(" select count(*) " + HQL_FIND_TOP_DEPT);
        return new QueryResult<>(list, totalRecords);
    }

}

package com.jackfrued.comm;

import java.util.List;

/**
 * 分頁器
 * @author 駱昊
 *
 * @param <T> 分頁數據對象的類型
 */
public class PageBean<T> {
    private static final int DEFAUL_INIT_PAGE = 1;
    private static final int DEFAULT_PAGE_SIZE = 10;
    private static final int DEFAULT_PAGE_COUNT = 5;

    private List<T> data;           // 分頁數據
    private PageRange pageRange;    // 頁碼範圍
    private int totalPage;          // 總頁數
    private int size;               // 頁面大小
    private int currentPage;        // 當前頁碼
    private int pageCount;          // 頁碼數量

    /**
     * 構造器
     * @param currentPage 當前頁碼
     * @param size 頁碼大小
     * @param pageCount 頁碼數量
     */
    public PageBean(int currentPage, int size, int pageCount) {
        this.currentPage = currentPage > 0 ? currentPage : 1;
        this.size = size > 0 ? size : DEFAULT_PAGE_SIZE;
        this.pageCount = pageCount > 0 ? size : DEFAULT_PAGE_COUNT;
    }

    /**
     * 構造器
     * @param currentPage 當前頁碼
     * @param size 頁碼大小
     */
    public PageBean(int currentPage, int size) {
        this(currentPage, size, DEFAULT_PAGE_COUNT);
    }

    /**
     * 構造器
     * @param currentPage 當前頁碼
     */
    public PageBean(int currentPage) {
        this(currentPage, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);
    }

    /**
     * 構造器
     */
    public PageBean() {
        this(DEFAUL_INIT_PAGE, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);
    }

    public List<T> getData() {
        return data;
    }

    public int getStartPage() {
        return pageRange != null ? pageRange.getStartPage() : 1;
    }

    public int getEndPage() {
        return pageRange != null ? pageRange.getEndPage() : 1;
    }

    public long getTotalPage() {
        return totalPage;
    }

    public int getSize() {
        return size;
    }

    public int getCurrentPage() {
        return currentPage;
    }

    /**
     * 將查詢結果轉換爲分頁數據
     * @param queryResult 查詢結果對象
     */
    public void transferQueryResult(QueryResult<T> queryResult) {
        long totalRecords = queryResult.getTotalRecords();

        data = queryResult.getResult();
        totalPage = (int) ((totalRecords + size - 1) / size); 
        totalPage = totalPage >= 0 ? totalPage : Integer.MAX_VALUE;
        this.pageRange = new PageRange(pageCount, currentPage, totalPage);
    }

}

package com.jackfrued.comm;

/**
 * 頁碼範圍
 * @author 駱昊
 *
 */
public class PageRange {
    private int startPage;  // 起始頁碼
    private int endPage;    // 終止頁碼

    /**
     * 構造器
     * @param pageCount 總共顯示幾個頁碼
     * @param currentPage 當前頁碼
     * @param totalPage 總頁數
     */
    public PageRange(int pageCount, int currentPage, int totalPage) {
        startPage = currentPage - (pageCount - 1) / 2;
        endPage = currentPage + pageCount / 2;
        if(startPage < 1) {
            startPage = 1;
            endPage = totalPage > pageCount ? pageCount : totalPage;
        }
        if (endPage > totalPage) {
            endPage = totalPage;
            startPage = (endPage - pageCount > 0) ? endPage - pageCount + 1 : 1;
        }
    }

    /**
     * 獲得起始頁頁碼
     * @return 起始頁頁碼
     */
    public int getStartPage() {
        return startPage;
    }

    /**
     * 獲得終止頁頁碼
     * @return 終止頁頁碼
     */
    public int getEndPage() {
        return endPage;
    }

}

package com.jackfrued.biz;

import com.jackfrued.comm.PageBean;
import com.jackfrued.entity.Dept;

/**
 * 部門業務邏輯接口
 * @author 駱昊
 *
 */
public interface DeptService {

    /**
     * 創建新的部門
     * @param department 部門對象
     * @return 創建成功返回true否則返回false
     */
    public boolean createNewDepartment(Dept department);

    /**
     * 刪除指定部門
     * @param id 要刪除的部門的編號
     * @return 刪除成功返回true否則返回false
     */
    public boolean deleteDepartment(Integer id);

    /**
     * 分頁獲取頂級部門
     * @param page 頁碼
     * @param size 頁碼大小
     * @return 部門對象的分頁器對象
     */
    public PageBean<Dept> getTopDeptByPage(int page, int size);

}

package com.jackfrued.biz.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.jackfrued.biz.DeptService;
import com.jackfrued.comm.PageBean;
import com.jackfrued.comm.QueryResult;
import com.jackfrued.dao.DeptDao;
import com.jackfrued.entity.Dept;

@Service
@Transactional  // 聲明式事務的註解
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptDao deptDao;

    @Override
    public boolean createNewDepartment(Dept department) {
        return deptDao.save(department) != null;
    }

    @Override
    public boolean deleteDepartment(Integer id) {
        return deptDao.deleteById(id);
    }

    @Override
    public PageBean<Dept> getTopDeptByPage(int page, int size) {
        QueryResult<Dept> queryResult = deptDao.findTopDeptByPage(page, size);
        PageBean<Dept> pageBean = new PageBean<>(page, size);
        pageBean.transferQueryResult(queryResult);
        return pageBean;
    }

}

154、如何在Web項目中配置Spring的IoC容器？
答：如果需要在Web項目中使用Spring的IoC容器，可以在Web項目配置文件web.xml中做出如下配置：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

155、如何在Web項目中配置Spring MVC？
答：要使用Spring MVC需要在Web項目配置文件中配置其前端控制器DispatcherServlet，如下所示：

<web-app>

    <servlet>
        <servlet-name>example</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>example</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>

</web-app>

說明：上面的配置中使用了*.html的後綴映射，這樣做一方面不能夠通過URL推斷採用了何種服務器端的技術，另一方面可以欺騙搜索引擎，因爲搜索引擎不會搜索動態頁面，這種做法稱爲僞靜態化。

156、Spring MVC的工作原理是怎樣的？
答：Spring MVC的工作原理如下圖所示：

① 客戶端的所有請求都交給前端控制器DispatcherServlet來處理，它會負責調用系統的其他模塊來真正處理用戶的請求。
② DispatcherServlet收到請求後，將根據請求的信息（包括URL、HTTP協議方法、請求頭、請求參數、Cookie等）以及HandlerMapping的配置找到處理該請求的Handler（任何一個對象都可以作爲請求的Handler）。
③在這個地方Spring會通過HandlerAdapter對該處理器進行封裝。
④ HandlerAdapter是一個適配器，它用統一的接口對各種Handler中的方法進行調用。
⑤ Handler完成對用戶請求的處理後，會返回一個ModelAndView對象給DispatcherServlet，ModelAndView顧名思義，包含了數據模型以及相應的視圖的信息。
⑥ ModelAndView的視圖是邏輯視圖，DispatcherServlet還要藉助ViewResolver完成從邏輯視圖到真實視圖對象的解析工作。
⑦ 當得到真正的視圖對象後，DispatcherServlet會利用視圖對象對模型數據進行渲染。
⑧ 客戶端得到響應，可能是一個普通的HTML頁面，也可以是XML或JSON字符串，還可以是一張圖片或者一個PDF文件。

157、如何在Spring IoC容器中配置數據源？
答：
DBCP配置：

<bean id="dataSource"
        class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driverClassName}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<context:property-placeholder location="jdbc.properties"/>

C3P0配置：

<bean id="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
    <property name="driverClass" value="${jdbc.driverClassName}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<context:property-placeholder location="jdbc.properties"/>

提示： DBCP的詳細配置在第153題中已經完整的展示過了。

158、如何配置配置事務增強？
答：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
     http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!-- this is the service object that we want to make transactional -->
  <bean id="fooService" class="x.y.service.DefaultFooService"/>

  <!-- the transactional advice -->
  <tx:advice id="txAdvice" transaction-manager="txManager">
  <!-- the transactional semantics... -->
  <tx:attributes>
    <!-- all methods starting with 'get' are read-only -->
    <tx:method name="get*" read-only="true"/>
    <!-- other methods use the default transaction settings (see below) -->
    <tx:method name="*"/>
  </tx:attributes>
  </tx:advice>

  <!-- ensure that the above transactional advice runs for any execution
    of an operation defined by the FooService interface -->
  <aop:config>
  <aop:pointcut id="fooServiceOperation" 
    expression="execution(* x.y.service.FooService.*(..))"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>
  </aop:config>

  <!-- don't forget the DataSource -->
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
    destroy-method="close">
  <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
  <property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/>
  <property name="username" value="scott"/>
  <property name="password" value="tiger"/>
  </bean>

  <!-- similarly, don't forget the PlatformTransactionManager -->
  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
  </bean>

  <!-- other <bean/> definitions here -->

</beans>

159、選擇使用Spring框架的原因（Spring框架爲企業級開發帶來的好處有哪些）？
答：可以從以下幾個方面作答：
- 非侵入式：支持基於POJO的編程模式，不強制性的要求實現Spring框架中的接口或繼承Spring框架中的類。
- IoC容器：IoC容器幫助應用程序管理對象以及對象之間的依賴關係，對象之間的依賴關係如果發生了改變只需要修改配置文件而不是修改代碼，因爲代碼的修改可能意味着項目的重新構建和完整的迴歸測試。有了IoC容器，程序員再也不需要自己編寫工廠、單例，這一點特別符合Spring的精神"不要重複的發明輪子"。
- AOP（面向切面編程）：將所有的橫切關注功能封裝到切面（aspect）中，通過配置的方式將橫切關注功能動態添加到目標代碼上，進一步實現了業務邏輯和系統服務之間的分離。另一方面，有了AOP程序員可以省去很多自己寫代理類的工作。
- MVC：Spring的MVC框架是非常優秀的，從各個方面都可以甩Struts 2幾條街，爲Web表示層提供了更好的解決方案。
- 事務管理：Spring以寬廣的胸懷接納多種持久層技術，並且爲其提供了聲明式的事務管理，在不需要任何一行代碼的情況下就能夠完成事務管理。
- 其他：選擇Spring框架的原因還遠不止於此，Spring爲Java企業級開發提供了一站式選擇，你可以在需要的時候使用它的部分和全部，更重要的是，你甚至可以在感覺不到Spring存在的情況下，在你的項目中使用Spring提供的各種優秀的功能。

160、Spring IoC容器配置Bean的方式？
答：
- 基於XML文件進行配置。
- 基於註解進行配置。
- 基於Java程序進行配置（Spring 3+）

package com.jackfrued.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Person {
    private String name;
    private int age;
    @Autowired
    private Car car;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
    }

}

package com.jackfrued.bean;

import org.springframework.stereotype.Component;

@Component
public class Car {
    private String brand;
    private int maxSpeed;

    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
    }

}

package com.jackfrued.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.jackfrued.bean.Car;
import com.jackfrued.bean.Person;

@Configuration
public class AppConfig {

    @Bean
    public Car car() {
        return new Car("Benz", 320);
    }

    @Bean
    public Person person() {
        return new Person("駱昊", 34);
    }
}

package com.jackfrued.test;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.jackfrued.bean.Person;
import com.jackfrued.config.AppConfig;

class Test {

    public static void main(String[] args) {
        // TWR (Java 7+)
        try(ConfigurableApplicationContext factory = new AnnotationConfigApplicationContext(AppConfig.class)) {
            Person person = factory.getBean(Person.class);
            System.out.println(person);
        }
    }
}

161、闡述Spring框架中Bean的生命週期？
答：
① Spring IoC容器找到關於Bean的定義並實例化該Bean。
② Spring IoC容器對Bean進行依賴注入。
③ 如果Bean實現了BeanNameAware接口，則將該Bean的id傳給setBeanName方法。
④ 如果Bean實現了BeanFactoryAware接口，則將BeanFactory對象傳給setBeanFactory方法。
⑤ 如果Bean實現了BeanPostProcessor接口，則調用其postProcessBeforeInitialization方法。
⑥ 如果Bean實現了InitializingBean接口，則調用其afterPropertySet方法。
⑦ 如果有和Bean關聯的BeanPostProcessors對象，則這些對象的postProcessAfterInitialization方法被調用。
⑧ 當銷燬Bean實例時，如果Bean實現了DisposableBean接口，則調用其destroy方法。

162、依賴注入時如何注入集合屬性？
答：可以在定義Bean屬性時，通過<list> / <set> / <map> / <props>分別爲其注入列表、集合、映射和鍵值都是字符串的映射屬性。

163、Spring中的自動裝配有哪些限制？
答：
- 如果使用了構造器注入或者setter注入，那麼將覆蓋自動裝配的依賴關係。
- 基本數據類型的值、字符串字面量、類字面量無法使用自動裝配來注入。
- 優先考慮使用顯式的裝配來進行更精確的依賴注入而不是使用自動裝配。

164、在Web項目中如何獲得Spring的IoC容器？
答：

WebApplicationContext ctx = 
WebApplicationContextUtils.getWebApplicationContext(servletContext);

165. 大型網站在架構上應當考慮哪些問題？
答：
- 分層：分層是處理任何複雜系統最常見的手段之一，將系統橫向切分成若干個層面，每個層面只承擔單一的職責，然後通過下層爲上層提供的基礎設施和服務以及上層對下層的調用來形成一個完整的複雜的系統。計算機網絡的開放系統互聯參考模型（OSI/RM）和Internet的TCP/IP模型都是分層結構，大型網站的軟件系統也可以使用分層的理念將其分爲持久層（提供數據存儲和訪問服務）、業務層（處理業務邏輯，系統中最核心的部分）和表示層（系統交互、視圖展示）。需要指出的是：（1）分層是邏輯上的劃分，在物理上可以位於同一設備上也可以在不同的設備上部署不同的功能模塊，這樣可以使用更多的計算資源來應對用戶的併發訪問；（2）層與層之間應當有清晰的邊界，這樣分層纔有意義，才更利於軟件的開發和維護。
- 分割：分割是對軟件的縱向切分。我們可以將大型網站的不同功能和服務分割開，形成高內聚低耦合的功能模塊（單元）。在設計初期可以做一個粗粒度的分割，將網站分割爲若干個功能模塊，後期還可以進一步對每個模塊進行細粒度的分割，這樣一方面有助於軟件的開發和維護，另一方面有助於分佈式的部署，提供網站的併發處理能力和功能的擴展。
- 分佈式：除了上面提到的內容，網站的靜態資源（JavaScript、CSS、圖片等）也可以採用獨立分佈式部署並採用獨立的域名，這樣可以減輕應用服務器的負載壓力，也使得瀏覽器對資源的加載更快。數據的存取也應該是分佈式的，傳統的商業級關係型數據庫產品基本上都支持分佈式部署，而新生的NoSQL產品幾乎都是分佈式的。當然，網站後臺的業務處理也要使用分佈式技術，例如查詢索引的構建、數據分析等，這些業務計算規模龐大，可以使用Hadoop以及MapReduce分佈式計算框架來處理。
- 集羣：集羣使得有更多的服務器提供相同的服務，可以更好的提供對併發的支持。
- 緩存：所謂緩存就是用空間換取時間的技術，將數據儘可能放在距離計算最近的位置。使用緩存是網站優化的第一定律。我們通常說的CDN、反向代理、熱點數據都是對緩存技術的使用。
- 異步：異步是實現軟件實體之間解耦合的又一重要手段。異步架構是典型的生產者消費者模式，二者之間沒有直接的調用關係，只要保持數據結構不變，彼此功能實現可以隨意變化而不互相影響，這對網站的擴展非常有利。使用異步處理還可以提高系統可用性，加快網站的響應速度（用Ajax加載數據就是一種異步技術），同時還可以起到削峯作用（應對瞬時高併發）。&quot；能推遲處理的都要推遲處理"是網站優化的第二定律，而異步是踐行網站優化第二定律的重要手段。
- 冗餘：各種服務器都要提供相應的冗餘服務器以便在某臺或某些服務器宕機時還能保證網站可以正常工作，同時也提供了災難恢復的可能性。冗餘是網站高可用性的重要保證。

166、你用過的網站前端優化的技術有哪些？
答：
① 瀏覽器訪問優化：
- 減少HTTP請求數量：合併CSS、合併JavaScript、合併圖片（CSS Sprite）
- 使用瀏覽器緩存：通過設置HTTP響應頭中的Cache-Control和Expires屬性，將CSS、JavaScript、圖片等在瀏覽器中緩存，當這些靜態資源需要更新時，可以更新HTML文件中的引用來讓瀏覽器重新請求新的資源
- 啓用壓縮
- CSS前置，JavaScript後置
- 減少Cookie傳輸
② CDN加速：CDN（Content Distribute Network）的本質仍然是緩存，將數據緩存在離用戶最近的地方，CDN通常部署在網絡運營商的機房，不僅可以提升響應速度，還可以減少應用服務器的壓力。當然，CDN緩存的通常都是靜態資源。
③ 反向代理：反向代理相當於應用服務器的一個門面，可以保護網站的安全性，也可以實現負載均衡的功能，當然最重要的是它緩存了用戶訪問的熱點資源，可以直接從反向代理將某些內容返回給用戶瀏覽器。

167、你使用過的應用服務器優化技術有哪些？
答：
① 分佈式緩存：緩存的本質就是內存中的哈希表，如果設計一個優質的哈希函數，那麼理論上哈希表讀寫的漸近時間複雜度爲O(1)。緩存主要用來存放那些讀寫比很高、變化很少的數據，這樣應用程序讀取數據時先到緩存中讀取，如果沒有或者數據已經失效再去訪問數據庫或文件系統，並根據擬定的規則將數據寫入緩存。對網站數據的訪問也符合二八定律（Pareto分佈，冪律分佈），即80%的訪問都集中在20%的數據上，如果能夠將這20%的數據緩存起來，那麼系統的性能將得到顯著的改善。當然，使用緩存需要解決以下幾個問題：
- 頻繁修改的數據；
- 數據不一致與髒讀；
- 緩存雪崩（可以採用分佈式緩存服務器集羣加以解決，memcached是廣泛採用的解決方案）；
- 緩存預熱；
- 緩存穿透（惡意持續請求不存在的數據）。
② 異步操作：可以使用消息隊列將調用異步化，通過異步處理將短時間高併發產生的事件消息存儲在消息隊列中，從而起到削峯作用。電商網站在進行促銷活動時，可以將用戶的訂單請求存入消息隊列，這樣可以抵禦大量的併發訂單請求對系統和數據庫的衝擊。目前，絕大多數的電商網站即便不進行促銷活動，訂單系統都採用了消息隊列來處理。
③ 使用集羣。
④ 代碼優化：
- 多線程：基於Java的Web開發基本上都通過多線程的方式響應用戶的併發請求，使用多線程技術在編程上要解決線程安全問題，主要可以考慮以下幾個方面：A. 將對象設計爲無狀態對象（這和麪向對象的編程觀點是矛盾的，在面向對象的世界中被視爲不良設計），這樣就不會存在併發訪問時對象狀態不一致的問題。B. 在方法內部創建對象，這樣對象由進入方法的線程創建，不會出現多個線程訪問同一對象的問題。使用ThreadLocal將對象與線程綁定也是很好的做法，這一點在前面已經探討過了。C. 對資源進行併發訪問時應當使用合理的鎖機制。
- 非阻塞I/O：使用單線程和非阻塞I/O是目前公認的比多線程的方式更能充分發揮服務器性能的應用模式，基於Node.js構建的服務器就採用了這樣的方式。Java在JDK 1.4中就引入了NIO（Non-blocking I/O）,在Servlet 3規範中又引入了異步Servlet的概念，這些都爲在服務器端採用非阻塞I/O提供了必要的基礎。
- 資源複用：資源複用主要有兩種方式，一是單例，二是對象池，我們使用的數據庫連接池、線程池都是對象池化技術，這是典型的用空間換取時間的策略，另一方面也實現對資源的複用，從而避免了不必要的創建和釋放資源所帶來的開銷。

168、什麼是XSS攻擊？什麼是SQL注入攻擊？什麼是CSRF攻擊？
答：
- XSS（Cross Site Script，跨站腳本攻擊）是向網頁中注入惡意腳本在用戶瀏覽網頁時在用戶瀏覽器中執行惡意腳本的攻擊方式。跨站腳本攻擊分有兩種形式：反射型攻擊（誘使用戶點擊一個嵌入惡意腳本的鏈接以達到攻擊的目標，目前有很多攻擊者利用論壇、微博發佈含有惡意腳本的URL就屬於這種方式）和持久型攻擊（將惡意腳本提交到被攻擊網站的數據庫中，用戶瀏覽網頁時，惡意腳本從數據庫中被加載到頁面執行，QQ郵箱的早期版本就曾經被利用作爲持久型跨站腳本攻擊的平臺）。XSS雖然不是什麼新鮮玩意，但是攻擊的手法卻不斷翻新，防範XSS主要有兩方面：消毒（對危險字符進行轉義）和HttpOnly（防範XSS攻擊者竊取Cookie數據）。
- SQL注入攻擊是注入攻擊最常見的形式（此外還有OS注入攻擊（Struts 2的高危漏洞就是通過OGNL實施OS注入攻擊導致的）），當服務器使用請求參數構造SQL語句時，惡意的SQL被嵌入到SQL中交給數據庫執行。SQL注入攻擊需要攻擊者對數據庫結構有所瞭解才能進行，攻擊者想要獲得表結構有多種方式：（1）如果使用開源系統搭建網站，數據庫結構也是公開的（目前有很多現成的系統可以直接搭建論壇，電商網站，雖然方便快捷但是風險是必須要認真評估的）；（2）錯誤回顯（如果將服務器的錯誤信息直接顯示在頁面上，攻擊者可以通過非法參數引發頁面錯誤從而通過錯誤信息瞭解數據庫結構，Web應用應當設置友好的錯誤頁，一方面符合最小驚訝原則，一方面屏蔽掉可能給系統帶來危險的錯誤回顯信息）；（3）盲注。防範SQL注入攻擊也可以採用消毒的方式，通過正則表達式對請求參數進行驗證，此外，參數綁定也是很好的手段，這樣惡意的SQL會被當做SQL的參數而不是命令被執行，JDBC中的PreparedStatement就是支持參數綁定的語句對象，從性能和安全性上都明顯優於Statement。
- CSRF攻擊（Cross Site Request Forgery，跨站請求僞造）是攻擊者通過跨站請求，以合法的用戶身份進行非法操作（如轉賬或發帖等）。CSRF的原理是利用瀏覽器的Cookie或服務器的Session，盜取用戶身份，其原理如下圖所示。防範CSRF的主要手段是識別請求者的身份，主要有以下幾種方式：（1）在表單中添加令牌（token）；（2）驗證碼；（3）檢查請求頭中的Referer（前面提到防圖片盜鏈接也是用的這種方式）。令牌和驗證都具有一次消費性的特徵，因此在原理上一致的，但是驗證碼是一種糟糕的用戶體驗，不是必要的情況下不要輕易使用驗證碼，目前很多網站的做法是如果在短時間內多次提交一個表單未獲得成功後纔要求提供驗證碼，這樣會獲得較好的用戶體驗。

補充：防火牆的架設是Web安全的重要保障，ModSecurity是開源的Web防火牆中的佼佼者。企業級防火牆的架設應當有兩級防火牆，Web服務器和部分應用服務器可以架設在兩級防火牆之間的DMZ，而數據和資源服務器應當架設在第二級防火牆之後。

169. 什麼是領域模型(domain model)？貧血模型(anaemic domain model)和充血模型(rich domain model)有什麼區別？
答：領域模型是領域內的概念類或現實世界中對象的可視化表示，又稱爲概念模型或分析對象模型，它專注於分析問題領域本身，發掘重要的業務領域概念，並建立業務領域概念之間的關係。貧血模型是指使用的領域對象中只有setter和getter方法（POJO），所有的業務邏輯都不包含在領域對象中而是放在業務邏輯層。有人將我們這裏說的貧血模型進一步劃分成失血模型（領域對象完全沒有業務邏輯）和貧血模型（領域對象有少量的業務邏輯），我們這裏就不對此加以區分了。充血模型將大多數業務邏輯和持久化放在領域對象中，業務邏輯（業務門面）只是完成對業務邏輯的封裝、事務和權限等的處理。下面兩張圖分別展示了貧血模型和充血模型的分層架構。

貧血模型

充血模型

貧血模型下組織領域邏輯通常使用事務腳本模式，讓每個過程對應用戶可能要做的一個動作，每個動作由一個過程來驅動。也就是說在設計業務邏輯接口的時候，每個方法對應着用戶的一個操作，這種模式有以下幾個有點：
- 它是一個大多數開發者都能夠理解的簡單過程模型（適合國內的絕大多數開發者）。
- 它能夠與一個使用行數據入口或表數據入口的簡單數據訪問層很好的協作。
- 事務邊界的顯而易見，一個事務開始於腳本的開始，終止於腳本的結束，很容易通過代理（或切面）實現聲明式事務。
然而，事務腳本模式的缺點也是很多的，隨着領域邏輯複雜性的增加，系統的複雜性將迅速增加，程序結構將變得極度混亂。開源中國社區上有一篇很好的譯文《貧血領域模型是如何導致糟糕的軟件產生》對這個問題做了比較細緻的闡述。

170. 談一談測試驅動開發（TDD）的好處以及你的理解。
答：TDD是指在編寫真正的功能實現代碼之前先寫測試代碼，然後根據需要重構實現代碼。在JUnit的作者Kent Beck的大作《測試驅動開發：實戰與模式解析》（Test-Driven Development: by Example）一書中有這麼一段內容：“消除恐懼和不確定性是編寫測試驅動代碼的重要原因”。因爲編寫代碼時的恐懼會讓你小心試探，讓你迴避溝通，讓你羞於得到反饋，讓你變得焦躁不安，而TDD是消除恐懼、讓Java開發者更加自信更加樂於溝通的重要手段。TDD會帶來的好處可能不會馬上呈現，但是你在某個時候一定會發現，這些好處包括：
- 更清晰的代碼 — 只寫需要的代碼
- 更好的設計
- 更出色的靈活性 — 鼓勵程序員面向接口編程
- 更快速的反饋 — 不會到系統上線時才知道bug的存在

補充：敏捷軟件開發的概念已經有很多年了，而且也部分的改變了軟件開發這個行業，TDD也是敏捷開發所倡導的。

TDD可以在多個層級上應用，包括單元測試（測試一個類中的代碼）、集成測試（測試類之間的交互）、系統測試（測試運行的系統）和系統集成測試（測試運行的系統包括使用的第三方組件）。TDD的實施步驟是：紅（失敗測試）- 綠（通過測試） - 重構。關於實施TDD的詳細步驟請參考另一篇文章《測試驅動開發之初窺門徑》。
在使用TDD開發時，經常會遇到需要被測對象需要依賴其他子系統的情況，但是你希望將測試代碼跟依賴項隔離，以保證測試代碼僅僅針對當前被測對象或方法展開，這時候你需要的是測試替身。測試替身可以分爲四類：
- 虛設替身：只傳遞但是不會使用到的對象，一般用於填充方法的參數列表
- 存根替身：總是返回相同的預設響應，其中可能包括一些虛設狀態
- 僞裝替身：可以取代真實版本的可用版本（比真實版本還是會差很多）
- 模擬替身：可以表示一系列期望值的對象，並且可以提供預設響應
Java世界中實現模擬替身的第三方工具非常多，包括EasyMock、Mockito、jMock等。

java面試170道精講：留着慢慢看

釘釘打卡速度慢

Nginx R31 doc 官方文檔-01-nginx 如何安裝

Qt/C++音視頻開發74-合併標籤圖形/生成yolo運算結果圖形/文字和圖形合併成一個/水印濾鏡

挑戰程序設計競賽 2.2章習題 POJ - 3617 Best Cow Line 貪心

字節面試：MySQL什麼時候鎖表？如何防止鎖表？

.NET8連接SQL SERVER 2008 R2 報：證書鏈是由不受信任的頒發機構頒發的

golang開發環境搭建(win10)

python計算機視覺學習筆記——PIL庫的用法

Golang初學：獲取程序內存使用情況，std runtime

分佈式架構簡單入門

緩存服務器---redis與memcached的對比

java NIO入門詳解

java面試170道精講：留着慢慢看

知名互聯網公司校招java開發面試知識點詳解

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結