不錯的java題2

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（文檔對象模型，DocumentObjectModel）、SAX（Simple API for XML）和StAX（Java 6中引入的新的解析XML的方式，StreamingAPI forXML），其中DOM處理大型文件時其性能下降的非常厲害，這個問題是由DOM樹結構佔用的內存較多造成的，而且DOM解析方式必須在解析文件之前把整個文檔裝入內存，適合對XML的隨機訪問（典型的用空間換取時間的策略）；SAX是事件驅動型的XML解析方式，它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶通過事件回調代碼來處理XML文件，適合對XML的順序訪問；顧名思義，StAX把重點放在流上，實際上StAX與其他解析方式的本質區別就在於應用程序能夠把XML作爲一個事件流來處理。將XML作爲一組事件來處理的想法並不新穎（SAX就是這樣做的），但不同之處在於StAX允許應用程序代碼把這些事件逐個拉出來，而不用提供在解析器方便時從解析器中接收事件的處理程序。

74、你在項目中哪些地方用到了XML？
答：XML的主要作用有兩個方面：數據交換和信息配置。在做數據交換時，XML將數據用標籤組裝成起來，然後壓縮打包加密後通過網絡傳送給接收者，接收解密與解壓縮後再從XML文件中還原相關信息進行處理，XML曾經是異構系統間交換數據的事實標準，但此項功能幾乎已經被JSON（JavaScriptObjectNotation）取而代之。當然，目前很多軟件仍然使用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（保存點）的概念，允許通過代碼設置保存點並讓事務回滾到指定的保存點。

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代碼：

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誕生初期無疑是一個亮點，而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，如下所示：

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

    <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>