撩課-Java面試題合輯100-150題

摘要： 101.請解釋下 ORM? 物件關係對映（Object Relational Mapping）模式 是一種為了解決面向物件與關係資料庫 存在的互不匹配的現象的技術。 簡單來說， ORM是通過使用描述物件和資料庫之間對映的元資料， 將程式中的物件自動持久化到關係資料庫中。 傳統如何...

101.請解釋下 ORM?

物件關係對映（Object Relational Mapping）模式
是一種為了解決面向物件與關係資料庫
存在的互不匹配的現象的技術。
簡單來說，
ORM是通過使用描述物件和資料庫之間對映的元資料，
將程式中的物件自動持久化到關係資料庫中。

傳統如何實現持久化：
1、採用硬編碼方式，
為每一種可能的資料庫訪問
操作提供單獨的方法，
2、ORM提供了對資料庫的對映，
不用sql直接編碼，
能夠像操作物件一樣從資料庫獲得資料。

ORM核心原則：

1、簡單：
以最基本的形式建模資料。

2、傳達性：
資料庫結構被任何人都能理解的語言文件化。

3、精確性：
基於資料庫模型建立正確標準化的結構。

ORM技術特點：
1、提高開發效率。
由於可以自動對entity物件與資料庫中的table
進行欄位與屬性的對映，
所以我們實際可能已經不需要一個專用的、
龐大的資料訪問層。

ORM缺點：
使用ORM所生成的程式碼
一般不太可能寫出很高效的演算法，
效能會受影響。

102.Hibernate 與 JPA 區別在哪？

在討論Hibernate與Jpa的關係是，
首先要明確Jpa的用途。
JPA全稱為Java Persistence API ，
Java持久化API是Sun公司在Java EE 5規範中
提出的Java持久化介面。
JPA吸取了目前Java持久化技術的優點，
旨在規範、簡化Java物件的持久化工作。
使用JPA持久化物件，
並不是依賴於某一個ORM框架。
與Jpa相關的就是這個ORM技術，
ORM 是Object-Relation-Mapping，
即物件關係影射技術，
是物件持久化的核心。O
RM是對JDBC的封裝，
從而解決了JDBC的各種存在問題：

知道Jpa是一種規範，
而Hibernate是它的一種實現。
除了Hibernate，
還有EclipseLink(曾經的toplink)，
OpenJPA等可供選擇，
所以使用Jpa的一個好處是，
可以更換實現而不必改動太多程式碼。

103.什麼是懶載入（Lazy Loading）？

1. 懶載入顧名思義就是延遲載入。
即當兩個及以上表
使用Hibernate來管理級聯關係時，
一個表被載入到JVM記憶體中，
而其他表會被暫存在資料庫的快取中，
當需要使用相關表資料的時候
再載入到JVM記憶體中。
因此通過懶載入機制可以
減少記憶體中不必要的開銷，
以提高程式的效能。
2. 問題描述：當使用懶載入時，
如果將session關閉，
則斷開了與資料庫的連線，
這時如果要訪問字表資料，
由於字表資料存放在資料庫快取中，
而連線已經關閉，
則訪問字表資料時會丟擲LazyInitializationException異常。

解決辦法:
1. 不使用懶載入，將字表配置檔案中的lazy屬性改為false
2.使用過濾器，
把close session操作推遲到得到頁面結果後執行，
這裡可以採用Spring中的OpenSessionViewFilter過濾器來實現
3.手動將需要的字表資料
從資料庫快取載入到jvm記憶體中

104.什麼是 N+1 難題？

一般而言說n+1意思是，
無論在一對多還是多對一當查詢出n條資料之後，
每條資料會關聯的查詢1次他的關聯物件，
這就叫做n+1。

本來所有信息可以一次性查詢出來，
也就是簡單的連表查詢，
但是Hibernate會首先查詢1次得到當前物件，
然後當前物件裡面的n個關聯物件
會再次訪問資料庫n次，
這就是1+n問題。

Hibernate給出了3中解決方案，
1.延遲載入，
當需要的時候才查詢，不
需要就不查詢，
但是感覺這種方式治標不治本，
尤其是在那種報表統計查詢的時候更為明顯。

2.fetch="join"，
預設是fetch="select"，
這個其實說白了就是一個做外連線，
允許外來鍵為空的情況之下。

3.二級快取，
第一次查詢之後存在記憶體中，
後面的相同查詢就快了。
但是有2個缺點：
二級快取首先是有點浪費記憶體空間，
如果多了的話浪費還比較嚴重，

105.簡介下 Hibernate Session 與 SessionFactory。

Session介面負責執行
被持久化物件的CRUD操作
CRUD的任務是完成與資料庫的交流，
包含了很多常見的SQL語句。
需要注意的是，
Session物件是非執行緒安全的，
同時，
Hibernate的Session
不同於JSP應用中的HttpSession。
這裡當使用Session這個術語時，
其實指的是Hibernate中的Session，
而以後會將HttpSession物件
稱為使用者Session。

SessionFactory介面負責初始化Hibernate。
它充當資料儲存源的代理，
並負責建立Session物件。
這裡用到了工廠模式。
需要注意的是，
SessionFactory並不是輕量級的，
因為一般情況下，
一個專案通常只需要
一個SessionFactory就夠，
當需要操作多個數據庫時，
可以為每個資料庫指定
一個SessionFactory。

ofollow,noindex">撩課Java+系統架構點選開始學習

106.什麼是Hibernate的併發機制？怎麼去處理併發問題？

a、Hibernate的Session物件是非執行緒安全的,
對於單個請求,單個會話,
單個的工作單元(即單個事務,單個執行緒),
它通常只使用一次, 然後就丟棄。

如果一個Session 例項允許共享的話，
那些支援併發執行的,
例如Http request,session beans
將會導致出現資源爭用。 

如果在Http Session中有hibernate的Session的話,
就可能會出現同步訪問Http Session。
只要使用者足夠快的點選瀏覽器的“重新整理”,
就會導致兩個併發執行的執行緒
使用同一個Session。

b、多個事務併發訪問同一塊資源,
可能會引發第一類丟失
更新，
髒讀，
幻讀，
不可重複讀，
第二類丟失更新一系列的問題。

解決方案：設定事務隔離級別。 
Serializable：序列化。隔離級別最高 
Repeatable Read：可重複讀 
Read Committed：已提交資料讀 
Read Uncommitted：未提交資料讀。隔離級別最差 
設定鎖：樂觀鎖和悲觀鎖。 
樂觀鎖：使用版本號或時間戳來檢測更新丟失,
在的對映中設定 optimistic-lock=”all”
可以在沒有版本或者時間戳屬性
對映的情況下實現 版本檢查，
此時Hibernate將比較一行記錄的每個欄位的狀態 
行級悲觀鎖：Hibernate總是使用資料庫的鎖定機制，
從不在記憶體中鎖定物件！
只要為JDBC連線指定一下隔 離級別，
然後讓資料庫去搞定一切就夠了。
類LockMode 定義了Hibernate所需的不同的鎖定級別：
LockMode.UPGRADE,
LockMode.UPGRADE_NOWAIT,
LockMode.READ;

107.update和saveOrUpdate的區別？

update()和saveOrUpdate()
是用來對跨Session的PO進行狀態管理的。 
update()方法操作的物件必須是持久化了的物件。
也就是說，如果此物件在資料庫中不存在的話，
就不能使用update()方法。 

saveOrUpdate()方法
操作的物件既可以使持久化了的，
也可以使沒有持久化的物件。
如果是持久化了的物件呼叫saveOrUpdate()
則會 更新資料庫中的物件；
如果是未持久化的物件使用此方法,
則save到資料庫中。

108.hibernate的三種狀態之間如何轉換

當物件由瞬時狀態(Transient)一save()時，
就變成了持久化狀態； 
當我們在Session裡儲存物件的時候，
實際是在Session的Map裡存了一份，
 也就是它的快取裡放了一份，
然後，又到資料庫裡存了一份，
在快取裡這一份叫持久物件(Persistent)。
 Session 一 Close()了,
它的快取也都關閉了,
整個Session也就失效了,這個時候，
這個物件變成了遊離狀態(Detached)，
但資料庫中還是存在的。 
當遊離狀態(Detached)update()時，
又變為了持久狀態(Persistent)。 
當持久狀態(Persistent)delete()時，
又變為了瞬時狀態(Transient), 此時，
資料庫中沒有與之對應的記錄。

109.比較hibernate的三種檢索策略優缺點?

1立即檢索； 
優點： 
對應用程式完全透明，
不管物件處於持久化狀態，
還是遊離狀態，
應用程式都可以方便的
從一個物件導航到與它關聯的物件； 
缺點：
 1.select語句太多；
2.可能會載入應用程式
不需要訪問的物件白白浪費許多記憶體空間； 

2延遲檢索： 
優點：
由應用程式決定需要載入哪些物件，
可以避免可執行多餘的select語句，
以及避免載入應用程式不需要訪問的物件。
因此能提高檢索效能，
並且能節省記憶體空間； 

缺點： 
應用程式如果希望訪問遊離狀態代理類例項，
必須保證他在持久化狀態時已經被初始化；
 
3 迫切左外連線檢索 
優點： 1對應用程式完全透明，
不管物件處於持久化狀態，
還是遊離狀態，
應用程式都可以方便地衝
一個物件導航到與它關聯的物件。
2使用了外連線，
select語句數目少； 
缺點：
1 可能會載入應用程式不需要訪問的物件，
白白浪費許多記憶體空間；
2複雜的資料庫表連線也會影響檢索效能；

110.Hibernate工作原理及為什麼要用？

1.讀取並解析配置檔案 
2.讀取並解析對映資訊，建立SessionFactory 
3.開啟Sesssion 
4.建立事務Transation 
5.持久化操作 
6.提交事務 
7.關閉Session 
8.關閉SesstionFactory

為什麼要用： 
1. 對JDBC訪問資料庫的程式碼做了封裝，
大大簡化了資料訪問層繁瑣的重複性程式碼。

Hibernate是一個基於JDBC的主流持久化框架，
是一個優秀的ORM實現。
他很大程度的簡化DAO層的編碼工作

hibernate使用Java反射機制，
而不是位元組碼增強程式來實現透明性。

hibernate的效能非常好，
因為它是個輕量級框架。
對映的靈活性很出色。
它支援各種關係資料庫，
從一對一到多對多的各種複雜關係。

撩課Java+系統架構點選開始學習

111.什麼是樂觀鎖（Optimistic Locking）？

悲觀鎖，正如其名，
它指的是對資料被外界
包括本系統當前的其他事務，
以及來自外部系統的事務處理
修改持保守態度，
因此，在整個資料處理過程中，
將資料處於鎖定狀態。
 悲觀鎖的實現，
往往依靠資料庫提供的鎖機制 
也只有資料庫層提供的鎖機制才能真正保證資料訪問的排他性，
否則，即使在本系統中實現了加鎖機制，
也無法保證外部系統不會修改資料

樂觀鎖（ Optimistic Locking ） 
相對悲觀鎖而言，
樂觀鎖假設認為資料
一般情況下不會造成衝突，
所以在資料進行提交更新的時候，
才會正式對資料的衝突與否進行檢測，
如果發現衝突了，
則讓返回使用者錯誤的資訊，
讓使用者決定如何去做

112.描述下Hibernate當中事務？

一、事務的併發問題 
在實際應用中，
資料庫是要被I多個使用者共同訪問的，
在多個事務同時使用相同的資料時，
可能會發生併發的問題，
具體為：

髒讀：
一個事務讀取到
另一個事務未提交的資料。

不可重複讀：
一個事務對同一行資料
重複讀取兩次，
但是得到了不同的結果。

虛讀：
一個事務連續兩次在資料庫進行同樣條件的查詢，
但是第二次查詢結果包含了
第一次查詢中未出現的資料。
（注意與不可重複讀的區別）

更新丟失：
兩個事物同時更新一行資料，
後提交（或撤銷）的事務將前面事務
提交的資料都覆蓋了。 
第一類丟失更新：
是由於後面事務撤銷將前面事務
修改的資料覆蓋了 
第二類丟失更新：
是由於後面事務更新將前面事務
修改的資料覆蓋了


1、讀未提交（1級，可防止更新丟失）：
當一個事務進行寫（更新）資料，
則另外一個事務不允許同時進行寫（更新）資料，
但允許其他事務進行讀資料，
即使是未提交的 （但這個不能防止髒讀）
更新丟失是因為一個事務開始進行寫事務，
另一個事務也可以進行寫事務導致的。

2、讀已提交（2級，可防止更新丟失、髒讀）：
讀取資料的事務允許其他事務繼續讀取該資料，
但是未提交的寫事務將會禁止其他事務訪問改行。
髒讀是由於讀到未提及的資料

3、可重複讀（4級，可防止不可重複讀、髒讀）：
讀取資料的事務禁止寫事務，
寫事務將禁止其他任何事務。
不可重複讀是一個事務
對一行資料重複讀取兩次，
但是得到不同的結果；
髒讀是讀到未提交的資料

4、序列化（8級，防止一切併發問題）：
提供嚴格的事務隔離。
事務只能一個接著一個執行，
不能併發執行

簡單總結： 
事務併發問題： 
（1）髒讀 
（2）不可重複讀 
（3）虛讀 
（4）更新丟失 
事務隔離級別： 
（1）讀未提交 
（2）讀已提交 
（3）可重複讀 
（4）序列化

在hibernate.cfg.xml的標籤配置： 
使用本地事務還是全域性事務，引數是：
hibernate.current_session_context_class
值：thread（本地事務）、jta（全域性事務）
設定事務隔離級別，引數是：
hibernate.connection.isolation

當多個事務同時訪問資料庫中的相同資料時，
如果沒有采取必要的隔離措施，
那麼可以採用悲觀鎖或者是樂觀鎖對其進行控制。 
悲觀鎖：
悲觀地認為總是會有其他事務回來操作同一資料
因此在這個資料處理過程中，
將會把資料處於鎖定狀態。
比如讀取資料時：
User user = (User)session.get(User.class, "111111", LockMode.UPGRADE)

樂觀鎖：
認為事務同時操作同一個資料的情況很少發生，
所以樂觀鎖不做資料庫層次的鎖定，
而是基於資料版本標識
實現應用程式級別上的鎖定機制。 
原理：資料版本標識，
是指通過為資料表增加一個“version”欄位，
實現在讀取資料時，
將版本號一同獨處，
之後更新次資料時，
將此版本號加一；
在提交資料時，
將現有的版本號
與資料表對應的記錄的版本號進行對比，
如果提交資料的版本號大於資料表中的版本號，
則允許更新資料，
否則禁止更新資料。

113.Hibernate 中的快取分為幾層。

hibernate的快取包括 
Session的快取和SessionFactory的快取，
其中SessionFactory的快取又可以分為兩類：
內建快取和外接快取。
Session的快取是內建的，
不能被解除安裝，
也被稱為Hibernate的第一級快取。
SessionFactory的內建快取
和Session的快取在實現方式上比較相似，
前者是SessionFactory物件的一些集合屬性包含的資料，
後者是指Session的一些集合屬性包含的資料。
SessionFactory的內建快取中存放了
對映元資料和預定義SQL語句，
對映元資料是對映檔案中資料的拷貝，
而預定義SQL語句是
在Hibernate初始化階段根據
對映元資料推匯出來，
SessionFactory的內建快取是隻讀的，
應用程式不能修改快取中的對映元資料
和預定義SQL語句，
因此SessionFactory不需要進行內建快取與對映檔案的同步。
SessionFactory的外接快取是一個可配置的外掛。
在預設情況下，SessionFactory不會啟用這個外掛。
外接快取的資料是資料庫資料的拷貝，
外接快取的介質可以是記憶體或者硬碟。
SessionFactory的外接快取
也被稱為Hibernate的第二級快取

114.Entity Beans 的狀態有哪些

瞬時(transient)：
資料庫中沒有資料與之對應，
超過作用域會被JVM垃圾回收器回收，
一般是new出來且與session沒有關聯的物件。

持久(persistent)：
資料庫中有資料與之對應，
當前與session有關聯，
並且相關聯的session沒有關閉，
 事務沒有提交；
持久物件狀態發生改變，
在事務提交時會影響到資料庫(hibernate能檢測到)。

脫管(detached)：
資料庫中有資料與之對應，
但當前沒有session與之關聯；
託管物件狀態發生改變，
hibernate不能檢測到。

115.談談Hibernate中inverse的作用

Hibernate中的inverse
在表關係對映中經常應用
 inverse的值有兩種，“true”和“false”。

inverse="false"是預設的值 
inverse的作用：
在hibernate中是通過inverse的設定
來決定是有誰來維護表和表之間的關係的。

 我們說inverse設立不當會導致效能低下，
其實是說inverse設立不當，
會產生多餘重複的SQL語句
甚至致使JDBC exception的throw。

這是我們在建立實體類關係時
必須需要關注的地方。

一般來說，inverse＝true是推薦使用，
雙向關聯中雙方都設定 inverse＝false的話，
必會導致雙方都重複更新同一個關係。

但是如果雙方都設立inverse＝true的話，
雙方都不維護關係的更新，
這也是 不行的，
好在一對多中的一端:
many-to-one預設是inverse＝false，
避免了這種錯誤的產生。

但是多對多就沒有這個預設設定了，
所以很 多人經常在多對多的兩端都使用inverse＝true，
結果導致連線表的資料根本沒有記錄，
就是因為他們雙分都沒有責任維護關係。
所以說，雙向關聯中最 好的設定
是一端為inverse＝true，
一端為inverse＝false。

一般inverse＝false會放在多的一端，
那麼有人提問了， many－to－many兩邊都是多的，
inverse到底放在哪兒？
其實hibernate建立多對多關係
也是將他們分離成兩個一對多關係，
中間連線一個連線表。

所以通用存在一對多的關係，
也可以這樣說：
一對多是多對多的基本組成部分。

116.說下Struts的設計模式

MVC模式: 
web應用程式啟動時
就會載入並初始化ActionServler。
使用者提交表單時，
一個配置好的ActionForm物件被建立，
並被填入表單相應的資料，
ActionServler根據Struts-config.xml檔案
配置好的設定決定是否需要表單驗證，
如果需要就呼叫ActionForm的Validate（）
驗證後選擇將請求傳送到哪個Action，
如果Action不存在，
ActionServlet會先建立這個物件，
然後呼叫Action的execute（）方法。
Execute（）從ActionForm物件中獲取資料，
完成業務邏輯，
返回一個ActionForward物件，
ActionServlet再把客戶請求 
轉發給ActionForward物件指定的jsp元件，
ActionForward物件指定的jsp生
成動態的網頁，返回給客戶。

117.攔截器和過濾器的區別?

1、攔截器是基於java反射機制的，
而過濾器是基於函式回撥的。

2、過濾器依賴於servlet容器，
而攔截器不依賴於servlet容器。

3、攔截器只能對Action請求起作用，
而過濾器則可以對幾乎所有請求起作用。

4、攔截器可以訪問Action上下文、
值棧裡的物件，而過濾器不能。

5、在Action的生命週期中，
攔截器可以多次呼叫，
而過濾器只能在容器初始化時被呼叫一次。

118.struts2框架的核心控制器是什麼？它有什麼作用？

1）Struts2框架的核心控制器是
StrutsPrepareAndExecuteFilter。

2）作用：

 負責攔截由<url-pattern>/*</url-pattern>
指定的所有使用者請求，
當用戶請求到達時，
該Filter會過濾使用者的請求。
預設情況下，
如果使用者請求的路徑

不帶字尾或者字尾以.action結尾，
這時請求將被轉入struts2框架處理，
否則struts2框架將略過該請求的處理。

可以通過常量"struts.action.extension"修改action的字尾，
如：
<constant name="struts.action.extension" value="do"/>
如果使用者需要指定多個請求字尾，
則多個字尾之間以英文逗號（,）隔開。
<constant name="struts.action.extension" value="do,go"/>

119.struts2如何訪問HttpServletRequest、HttpSession、ServletContext三個域物件？

方案一：

HttpServletRequest request =
ServletActionContext.getRequest();

HttpServletResponse response =
ServletActionContext.getResponse();

HttpSessionsession=
request.getSession(); 

ServletContext servletContext=
ServletActionContext.getServletContext();



方案二：

類 implements ServletRequestAware,ServletResponseAware，SessionAware，ServletContextAware

注意：框架自動傳入對應的域物件

120.ActionContext、ServletContext、pageContext的區別？

1）ActionContext是當前的Action的上下文環境，
通過ActionContext可以
獲取到request、session、ServletContext等
與Action有關的物件的引用；

2）ServletContext是域物件，
一個web應用中只有一個ServletContext，
生命週期伴隨整個web應用；

3）pageContext是JSP中的最重要的一個內建物件，
可以通過pageContext獲取其他域物件的應用，
同時它是一個域物件，
作用範圍只針對當前頁面，
當前頁面結束時，
pageContext銷燬，

生命週期是JSP四個域物件中最小的。

121.描述Struts2的工作原理

客戶端傳送請求--》
請求經過一系列過濾器->
FilterDispatcher通過
ActionMapper來決定這個Reques
t需要呼叫哪個Action ->
FilterDispatcher把請求的處理交給ActionProxy-> 
通過ConfigurationManager詢問
Struts配置檔案（Struts.xml）
找到需要呼叫的Action類->
ActionProxy建立一個ActionInvocation的例項 ->
呼叫Action->執行完畢，
返回結果

122.result的type屬性中有哪幾種結果型別？

一共10種：

dispatcher

struts預設的結果型別，
把控制權轉發給應用程式裡的
某個資源不能把控制權
轉發給一個外部資源，
若需要把控制權重定向到
一個外部資源, 應該使用

redirect結果型別
redirect
把響應重定向到另一個資源（包括一個外部資源）

redirectAction
把響應重定向到另一個 Action

freemarker、
velocity、
chain、
httpheader、
xslt、
plainText、
stream

123.攔截器的生命週期與工作過程？

1）每個攔截器都是實現了I
nterceptor介面的 Java 類；

2）init(): 該方法將在攔截器被建立後立即被呼叫, 
它在攔截器的生命週期內只被呼叫一次. 
可以在該方法中對相關資源
進行必要的初始化；

3）intercept(ActionInvocation invocation): 
每攔截一個動作請求,
 該方法就會被呼叫一次；

4）destroy: 
該方法將在攔截器被銷燬之前被呼叫, 
它在攔截器的生命週期內也只被呼叫一次；

5）struts2中有內建了18個攔截器。

124.struts2如何完成檔案的上傳？

1、JSP頁面：

1）JSP頁面的上傳檔案的元件：
<s: file name=”upload” />，
如果需要一次上傳多個檔案, 
就必須使用多個 file 標籤, 
但它們的名字必須是相同的，
即：name=“xxx”的值必須一樣；

2）必須把表單的enctype屬性設定為：
multipart/form-data；

 3）表單的方法必須為post，
因為post提交的資料在訊息體中，
而無大小限制。

2、對應的action：

 1）在 Action 中新新增 3 個
和檔案上傳相關的屬性；

2）如果是上傳單個檔案, 
uploadImage屬性的型別就是 
java.io.File, 它代表被上傳的檔案, 
第二個和第三個屬性的型別是 String, 
它們分別代表上傳文 件的檔名和檔案型別，
定義方式是分別是：

jsp頁面file元件的名稱+ContentType,
jsp頁面file元件的名稱+FileName

3）如果上上傳多個檔案, 
可以使用陣列或 List

125.值棧ValueStack的原理與生命週期？

1）ValueStack貫穿整個 Action 的生命週期，
儲存在request域中，
所以ValueStack和request的生命週期一樣。
當Struts2接受一個請求時，
會迅速建立ActionContext，

ValueStack，action。
然後把action存放進ValueStack，
所以action的例項變數可以被OGNL訪問。
 請求來的時候，
action、ValueStack的生命開始，
請求結束，action、ValueStack的生命結束；

2）action是多例的，和Servlet不一樣，
Servelt是單例的；

3）每個action的都有一個對應的值棧，
值棧存放的資料型別是該action的例項，
以及該action中的例項變數，
Action物件預設儲存在棧頂；

4）ValueStack本質上就是一個ArrayList；

5）關於ContextMap，
Struts 會把下面這些對映壓入 ContextMap 中：

parameters:
該 Map 中包含當前請求的請求引數

request:
該 Map 中包含當前 request 物件中的
所有屬性session 
:該 Map 中包含當前 session 物件中的所有屬性

application 
:該 Map 中包含當前 
application 物件中的所有屬性

attr:該 Map 按如下順序來檢索某個屬性: 
request, session, application

6）使用OGNL訪問值棧的內容時，
不需要#號，
而訪問request、session、application、attr時，
需要加#號；

7）注意： Struts2中，
OGNL表示式需要配合Struts標籤才可以使用。
如：<s:property value="name"/>

8）在struts2配置檔案中引用ognl表示式 ,
引用值棧的值 ，此時使用的"$"，而不是#或者%;

126.Struts2中的攔截器有什麼用？列舉框架提供的攔截器名稱？

1）攔截器是struts2核心組成部分，
它提供了一種機制,使得開發者
可以定義一個特定的功能模組,
這個模組會在Action執行之前或者之後執行
也可以在Action執行之前阻止Action執行。 

 2）常用的攔截器有: 

 chain:在不同請求之間將請求引數在不同名字件轉換，
請求內容不變 

 fileUpload:提供檔案上傳。 

 ​i18n：記錄使用者選擇的區域環境 

 logger：輸出Action的名字

 params：將請求中的引數設定到Action中去。

127.Struts2有哪些優點？

1）在軟體設計上Struts2的應用
可以不依賴於Servlet API和struts API。 
Struts2的這種設計屬於無侵入式設計； 

 2）攔截器，
實現如引數攔截注入等功能；

 3）型別轉換器，
可以把特殊的請求引數轉換成需要的型別； 

 4）多種表現層技術，
如：JSP、freeMarker、Velocity等；

 5）Struts2的輸入校驗
可以對指定某個方法進行校驗；

 6）提供了全域性範圍、
包範圍和Action範圍的
國際化資原始檔管理實現 

 7) 實現MVC模式,結構清晰,
使開發者只關注業務邏輯的實現。
有豐富的tag可以用,
大提高了開發效率。(簡要)

128.ActionContext和ValueStack什麼時候建立？是否是執行緒安全的？

明確：
動作類是多例的，
每次動作訪問，
動作類都會例項化。
所以是執行緒安全的。
與Struts1的區別是，
struts1的動作類是單例的。

在每次動作執行前，
核心控制器StrutsPrepareAndExecuteFilter
都會建立一個ActionContext和ValueStack物件。
且每次動作訪問都會建立。

 這兩個物件儲存了整個動作
訪問期間用到的資料。
並且把資料繫結到了執行緒區域性變數
ThreadLocal上了。
所以是執行緒安全的。

129.一個請求在Struts2框架中的處理大概分為幾個步驟？

1） 客戶端初始化一個
指向Servlet容器（例如Tomcat）的請求

2 ）這個請求經過一系列的過濾器Filter
這些過濾器中有一個叫做
ActionContextCleanUp的可選過濾器，
這個過濾器對於Struts2和
其他框架的整合很有幫助，
例如：SiteMesh Plugin）

3 ）接著FilterDispatcher被呼叫，
FilterDispatcher詢問ActionMapper
來決定這個請是否需要呼叫某個Action

4 ）如果ActionMapper決定需要呼叫某個Action，
FilterDispatcher把請求的處理交給ActionProxy

5 ）ActionProxy通過Configuration Manager
詢問框架的配置檔案，
找到需要呼叫的Action類

6 ）ActionProxy建立一個ActionInvocation的例項。

7 ）ActionInvocation例項使用命名模式來呼叫，
在呼叫Action的過程前後，
涉及到相關攔截器（Intercepter）的呼叫。

 8 ）一旦Action執行完畢，
ActionInvocation負責根據struts.xml中的配置
找到對應的返回結果。
返回結果通常是一個需要
被表示的JSP或者FreeMarker的模版。
在表示的過程中可以使用Struts2 框架中
繼承的標籤。
在這個過程中需要涉及到ActionMapper

130.介紹一下Struts的ActionServlet類

ActionServlet繼承自
javax.servlet.http.HttpServlet類，
其在Struts framework中扮演的角色
是中心控制器。
它提供一箇中心位置來處理全部的終端請求。
控制器ActionServlet主要
負責將HTTP的客戶請求資訊組裝後，
根據配置檔案的指定描述，
轉發到適當的處理器。
按照Servelt的標準，
所有得Servlet必須在
web配置檔案（web.xml）宣告。
同樣，ActoinServlet必須在
Web Application配置檔案（web.xml）中描述
當用戶向伺服器端提交請求的時候，
實際上資訊是首先發送到控制器ActionServlet，
一旦控制器獲得了請求，
其就會將請求資訊傳交給一些輔助類（help classes）處理。
這些輔助類知道如何去處理與請求資訊所對應的業務操作。
在Struts中，
這個輔助類就是org.apache.struts.action.Action。
通常開發者需要自己繼承Aciton類，
從而實現自己的Action例項。

131.Spring是什麼?

他解決的是業務邏輯層和其他各層的鬆耦合問題，
因此它將面向介面的程式設計思想
貫穿整個系統應用。

 Spring是一個輕量級的IoC和AOP容器框架。
目的是解決企業應用開發的複雜性，
使用基本的JavaBean來完成
以前只可能由EJB完成的事情，
並提供了更多的企業應用功能，
Spring的用途不僅限於伺服器端的開發，
從簡單性、
可測試性和鬆耦合的角度而言，
任何Java應用都可以從Spring中受益。

132.說說Spring 的優點？

1.spring屬於低侵入式設計，
程式碼的汙染極低；

2.spring的DI機制降低了
業務物件替換的複雜性；

3.容器提供了AOP技術，
利用它很容易實現如許可權攔截，
執行期監控等功能；

4.降低了元件之間的耦合性 ，
實現了軟體各層之間的解耦； 

5.容器提供單例模式支援；

6.可以使用容器提供的眾多服務，
如事務管理，訊息服務等；

7.容器提供了眾多的輔助類，
能加快應用的開發；

8.spring對於主流的應用框架提供了整合支援，
如hibernate，JPA，Struts等 

9.獨立於各種應用伺服器 

10.Spring的高度開放性，
並不強制應用完全依賴於Spring，
開發者可以自由選擇spring的部分或全部。

133.說說你對Spring的IoC與DI的理解

（1）IOC/">IOC就是控制反轉。
就是物件的建立權反轉交給Spring，
由容器控制程式之間的依賴關係，
作用是實現了程式的解耦合，
而非傳統實現中，
由程式程式碼直接操控。
(依賴)控制權由應用程式碼本身轉到了外部容器，
由容器根據配置檔案去建立例項
並管理各個例項之間的依賴關係，
控制權的轉移，
是所謂反轉，
並且由容器動態的將某種依賴關係注入到元件之中。
BeanFactory 是Spring IoC容器的具體實現與核心介面，
提供了一個先進的配置機制，
使得任何型別的物件的配置成為可能，
用來包裝和管理各種bean。

2.最直觀的表達就是，
IOC讓物件的建立不用去new了，
可以由spring自動生產，
這裡用的就是java的反射機制，
通過反射在執行時動態的去建立、
呼叫物件。
spring就是根據配置檔案
在執行時動態的去建立物件，
並呼叫物件的方法的。

3.Spring的IOC有三種注入方式 ： 
第一是根據屬性注入，也叫set方法注入； 
 第二種是根據構造方法進行注入； 
第三種是根據註解進行注入。

詳細的說：
IOC控制反轉：
將物件交給容器管理，
你只需要在spring配置檔案總配置相應的bean，
以及設定相關的屬性，
讓spring容器生成類的例項物件以及管理物件。
在spring容器啟動的時候，
spring會把你在配置檔案中配
置的bean都初始化以及裝配好，
然後在你需要呼叫的時候，
就把它已經初始化好的那些bean
分配給你需要呼叫這些bean的類。
就是將物件的控制權反轉給spring容器管理。

DI機制（Dependency Injection，依賴注入）：
可以說是IoC的其中一個內容，
在容器例項化物件的時候
主動的將被呼叫者（或者說它的依賴物件）
注入給呼叫物件。
比如物件A需要操作資料庫，
以前我們總是要在A中
自己編寫程式碼來獲得一個Connection物件，
有了 spring我們就只需要告訴spring，
A中需要一個Connection，
至於這個Connection怎麼構造，
何時構造，
A不需要知道。
在系統執行時，
spring會在適當的時候製造一個Connection，
然後像打針一樣，注射到A當中，
這樣就完成了對各個物件之間關係的控制。

134.解釋Spring支援的幾種bean的作用域

Spring容器中的bean可以分為5個範圍：
1.singleton：這種bean範圍是預設的，
這種範圍確保不管接受到多少個請求，
每個容器中只有一個bean的例項，
單例的模式由bean factory自身來維護。

2.prototype：原形範圍與單例範圍相反，
為每一個bean請求提供一個例項。

3.request：在請求bean範圍內
會每一個來自客戶端的網路請求建立一個例項，
在請求完成以後，
bean會失效並被垃圾回收器回收。

4.Session：與請求範圍類似，
確保每個session中有一個bean的例項，
在session過期後，
bean會隨之失效。

5.global-session：
global-session和Portlet應用相關。
當你的應用部署在Portlet容器中工作時，
它包含很多portlet。
如果你想要宣告讓所有的portlet
共用全域性的儲存變數的話，
那麼這全域性變數需要儲存在global-session中。
全域性作用域與Servlet中的session
作用域效果相同。

135.BeanFactory 介面和 ApplicationContext 介面有什麼區別 ？

BeanFactory和ApplicationContext
是Spring的兩大核心介面，
而其中ApplicationContext是BeanFactory的子介面。
它們都可以當做Spring的容器，
生成Bean例項的，
並管理容器中的Bean。

1.BeanFactory：
是Spring裡面最底層的介面，
提供了最簡單的容器的功能，
負責讀取bean配置文件，
管理bean的載入與例項化，
維護bean之間的依賴關係，
負責bean的生命週期，
但是無法支援spring的aop功能和web應用。

2.ApplicationContext介面
作為BeanFactory的派生，
因而具有BeanFactory所有的功能。
而且ApplicationContext還在功能上做了擴充套件，
以一種更面向框架的方式工作以及對上下文進行分層和實現繼承，
相較於BeanFactorty，
ApplicationContext還提供了以下的功能： 
①預設初始化所有的Singleton，也可以通過配置取消預初始化。
②繼承MessageSource，因此支援國際化。
③資源訪問，比如訪問URL和檔案。
④事件機制。
⑤同時載入多個配置檔案。
⑥以宣告式方式啟動並建立Spring容器。
⑦載入多個（有繼承關係）上下文 ，
使得每一個上下文
都專注於一個特定的層次，
比如應用的web層。

BeanFactroy採用的是延遲載入形式
來注入Bean的，
即只有在使用到某個Bean時(呼叫getBean())，
才對該Bean進行載入例項化，
這樣，我們就不能發現一些存在的Spring的配置問題。
如果Bean的某一個屬性沒有注入，B
eanFacotry載入後，
直至第一次使用呼叫getBean方法
才會丟擲異常。

而ApplicationContext則相反，
它是在容器啟動時，
一次性建立了所有的Bean。
這樣，在容器啟動時，
我們就可以發現Spring中存在的配置錯誤，
這樣有利於檢查所依賴屬性是否注入。 
ApplicationContext啟動後
預載入所有的單例項Bean，
通過預載入單例項bean ,
確保當你需要的時候，
你就不用等待，
因為它們已經建立好了。

相對於基本的BeanFactory，
ApplicationContext 唯一的不足是
佔用記憶體空間。
當應用程式配置Bean較多時，
程式啟動較慢。

BeanFactory通常以程式設計的方式被建立，
ApplicationContext還能以宣告的方式建立，
如使用ContextLoader。

BeanFactory和ApplicationContext
都支援BeanPostProcessor、
BeanFactoryPostProcessor的使用，

但兩者之間的區別是：
BeanFactory需要手動註冊，
而ApplicationContext則是自動註冊。

136.請解釋Spring Bean的生命週期？

首先說一下Servlet的生命週期：
例項化，
初始init，
接收請求service，
銷燬destroy；

 Spring上下文中的Bean生命週期也類似，
如下：
1.例項化一個Bean
也就是我們常說的new；

2.按照Spring上下文
對例項化的Bean進行配置
也就是IOC注入；

3.如果這個Bean已經實現了BeanNameAware介面，
會呼叫它實現的
setBeanName(String)方法，
此處傳遞的就是Spring配置檔案中Bean的id值；

4.如果這個Bean已經實現了BeanFactoryAware介面，
會呼叫它實現的
setBeanFactory(setBeanFactory(BeanFactory)
傳遞的是Spring工廠自身
可以用這個方式來獲取其它Bean，
只需在Spring配置檔案中
配置一個普通的Bean就可以；

5.如果這個Bean已經實現了
ApplicationContextAware介面，
會呼叫setApplicationContext(ApplicationContext)方法，
傳入Spring上下文
同樣這個方式也可以實現步驟4的內容，
但比4更好，
因為ApplicationContext是BeanFactory的子介面，
有更多的實現方法

6.如果這個Bean關聯了
BeanPostProcessor介面，
將會呼叫
postProcessBeforeInitialization(Object obj, String s)方法，
BeanPostProcessor
經常被用作是Bean內容的更改，
並且由於這個是在Bean初始化結束時
呼叫那個的方法，
也可以被應用於記憶體或快取技術；

7.如果Bean在Spring配置檔案中
配置了init-method屬性
會自動呼叫其配置的初始化方法。

8.如果這個Bean關聯了BeanPostProcessor介面，
將會呼叫
postProcessAfterInitialization(Object obj, String s)方法、；

注：以上工作完成以後就可以應用這個Bean了，
那這個Bean是一個Singleton的，
所以一般情況下
們呼叫同一個id的Bean會是
在內容地址相同的例項，
當然在Spring配置檔案中
也可以配置非Singleton。

9.當Bean不再需要時，
會經過清理階段，
如果Bean實現了DisposableBean這個介面，
會呼叫那個其實現的destroy()方法；

10.最後，
如果這個Bean的Spring配置中
配置了destroy-method屬性，
會自動呼叫其配置的銷燬方法。

 另外我們這裡描述的是應用Spring
上下文Bean的生命週期，
如果應用Spring的工廠
也就是BeanFactory的話去掉第5步就Ok了。

137.介紹下Spring的主要模組?

Spring AOP:
Spring的關鍵元件之一是AOP框架。
AOP在Spring中使用：
提供宣告性的企業服務，
特別是作為EJB宣告式服務的替代品。
最重要的服務是宣告式事務管理，
它建立在Spring的事務抽象之上。
允許使用者實現自定義的切面，
補充他們使用AOP的OOP的使用。

Spring ORM:
ORM包與資料庫訪問有關。
它為流行的物件關係對映api提供整合層，
包括JDO、Hibernate和iBatis。

Spring Web:
web應用程式開發堆疊，
其中包括Spring MVC。

Spring DAO:
Spring的DAO（Data Access Object）
支援主要用於使用JDBC、
Hibernate或JDO等
技術標準化資料訪問工作。

Spring Context:
此包構建在bean包之上，
以增加對訊息源的支援和觀察者的設計模式支援，
以及應用程式物件使用一致的
API獲得資源的能力。

Spring Web MVC:
這是為web應用程式
提供MVC實現的模組。

Spring Core:
核心包是Spring框架中最重要的元件。

該元件提供依賴性注入特性。
BeanFactory提供了一種工廠模式，
它將諸如初始化、
創造和訪問物件
與實際程式邏輯的訪問分離開來。

138.Spring事務的種類和各自的區別?

spring支援
程式設計式事務管理
宣告式事務管理
兩種方式：

1.程式設計式事務管理使用TransactionTemplate
或者直接使用底層的PlatformTransactionManager。
對於程式設計式事務管理，
spring推薦使用TransactionTemplate。

2.宣告式事務管理建立在AOP之上的。
其本質是對方法前後進行攔截，
然後在目標方法開始之前建立或者加入一個事務，
在執行完目標方法之後
根據執行情況提交或者回滾事務。
宣告式事務最大的優點
就是不需要通過程式設計的方式管理事務，
這樣就不需要在業務邏輯程式碼中
摻雜事務管理的程式碼，
只需在配置檔案中
做相關的事務規則宣告
或通過基於@Transactional註解的方式
便可以將事務規則應用到業務邏輯中。

3.顯然宣告式事務管理要優於程式設計式事務管理，
這正是spring倡導的非侵入式的開發方式。
宣告式事務管理使業務程式碼不受汙染，
一個普通的POJO物件，
只要加上註解就可以獲得完全的事務支援。
和程式設計式事務相比，
宣告式事務唯一不足地方是，
後者的最細粒度只能作用到方法級別，
無法做到像程式設計式事務
那樣可以作用到程式碼塊級別。

139.說說spring的事務傳播行為?

spring事務的傳播行為
說的是當一個方法呼叫另一個方法時，
事務該如何操作。
1.PROPAGATION_REQUIRED：
如果當前沒有事務，
就建立一個新事務，
如果當前存在事務，
就加入該事務，
該設定是最常用的設定。

2.PROPAGATION_SUPPORTS：
支援當前事務，
如果當前存在事務，
就加入該事務，
如果當前不存在事務，
就以非事務執行。‘

3.PROPAGATION_MANDATORY：
支援當前事務，
如果當前存在事務，
就加入該事務，
如果當前不存在事務，
就丟擲異常。

4.PROPAGATION_REQUIRES_NEW：
建立新事務，
無論當前存不存在事務，
都建立新事務。

5.PROPAGATION_NOT_SUPPORTED：
以非事務方式執行操作，
如果當前存在事務，
就把當前事務掛起。

6.PROPAGATION_NEVER：
以非事務方式執行，
如果當前存在事務，
則丟擲異常。

7.PROPAGATION_NESTED：
如果當前存在事務，
則在巢狀事務內執行。
如果當前沒有事務，
則執行與PROPAGATION_REQUIRED類似的操作。

140.Spring事務的實現方式和實現原理

1.劃分處理單元——IOC：
由於spring解決的問題是
對單個數據庫進行區域性事務處理的，
具體的實現首相用spring中的IOC
劃分了事務處理單元。
並且將對事務的各種配置
放到了ioc容器中
設定事務管理器，
設定事務的傳播特性及隔離機制。

2.AOP攔截需要進行事務處理的類：

Spring事務處理模組
是通過AOP功能來實現宣告式事務處理的，
具體操作
比如事務實行的配置和讀取，
事務物件的抽象，
用TransactionProxyFactoryBean介面
來使用AOP功能，
生成proxy代理物件，
通過TransactionInterceptor完成
對代理方法的攔截，
將事務處理的功能
編織到攔截的方法中。 

讀取ioc容器事務配置屬性，
轉化為spring事務處理
需要的內部資料結構
TransactionAttributeSourceAdvisor
轉化為TransactionAttribute表示的資料物件。 

3.對事物處理實現
事務的生成、提交、回滾、掛起：

spring委託給具體的事務處理器實現。
實現了一個抽象和適配。
適配的具體事務處理器：
DataSource資料來源支援、
hibernate資料來源事務處理支援、
JDO資料來源事務處理支援，
JPA、JTA資料來源事務處理支援。
這些支援都是通過設計PlatformTransactionManager、
AbstractPlatforTransaction
一系列事務處理的支援。
為常用資料來源支援提供了
一系列的TransactionManager。

結合：
PlatformTransactionManager實現了
TransactionInterception介面，
讓其與TransactionProxyFactoryBean結合起來，
形成一個Spring宣告式事務處理的設計體系。

141.Spring AOP是什麼?

AOP:面向切面程式設計
AOP技術利用一種稱為“橫切”的技術，
解剖封裝的物件內部，
並將那些影響了多個類的公共行為
封裝到一個可重用模組，
這樣就能減少系統的重複程式碼，
降低模組間的耦合度，
並有利於未來的可操作性和可維護性。
AOP把軟體系統分為兩個部分：
核心關注點
和橫切關注點。
業務處理的主要流程是核心關注點，
與之關係不大的部分是橫切關注點。
橫切關注點的一個特點是，
他們經常發生在核心關注點的多處，
而各處都基本相似。
比如許可權認證、日誌、事務處理。

142.說說AOP實現原理

AOP:
這裡的AOP指的是面向切面程式設計思想，
而不是Spring AOP
主要的的實現技術主要有
Spring AOP和AspectJ。
1、AspectJ的底層技術。
 AspectJ的底層技術是靜態代理，
即用一種AspectJ支援的特定語言編寫切面，
通過一個命令來編譯，
生成一個新的代理類，
該代理類增強了業務類，
這是在編譯時增強，
相對於下面說的執行時增強，
編譯時增強的效能更好。

Spring AOP

Spring AOP採用的是動態代理，
在執行期間對業務方法進行增強，
所以不會生成新類，
對於動態代理技術，
Spring AOP提供了對
JDK動態代理的支援以及CGLib的支援。

JDK動態代理只能為介面建立動態代理例項，
而不能對類建立動態代理。
需要獲得被目標類的介面資訊（應用Java的反射技術），
生成一個實現了代理介面的動態代理類（位元組碼），
再通過反射機制獲得動態代理類的建構函式，
利用建構函式生成動態代理類的例項物件，
在呼叫具體方法前呼叫invokeHandler方法來處理。

CGLib動態代理需要依賴asm包，
把被代理物件類的class檔案載入進來，
修改其位元組碼生成子類。

但是Spring AOP基於註解配置的情況下，
需要依賴於AspectJ包的標準註解，
但是不需要額外的編譯以及AspectJ的織入器，
而基於XML配置不需要。

143. 請描述JDK動態代理和CGLI代理的區別？

1.JDK動態代理
此時代理物件和目標物件實現了相同的介面，
目標物件作為代理物件的一個屬性，
具體介面實現中，
可以在呼叫目標物件相應方法前後
加上其他業務處理邏輯。

代理模式在實際使用時
需要指定具體的目標物件，
如果為每個類都新增一個代理類的話，
會導致類很多，
同時如果不知道具體類的話，
怎樣實現代理模式呢？
這就引出動態代理。
JDK動態代理只能
針對實現了介面的類生成代理。

2.CGLIB代理
CGLIB（CODE GENERLIZE LIBRARY）
代理是針對類實現代理，
主要是對指定的類生成一個子類，
覆蓋其中的所有方法，
所以該類或方法不能宣告稱final的。

如果目標物件沒有實現介面，
則預設會採用CGLIB代理；

如果目標物件實現了介面，
可以強制使用CGLIB實現代理
新增CGLIB庫，
並在spring配置中加入
<aop:aspectj-autoproxy proxy-target-class="true"/>）

144.怎樣用註解的方式配置Spring？

Spring在2.5版本以後
開始支援用註解的方式來配置依賴注入。
可以用註解的方式
來替代XML方式的bean描述，
可以將bean描述轉移到元件類的內部，
只需要在相關類上、
方法上或者欄位宣告上使用註解即可。
註解注入將會被容器在XML注入之前被處理，
所以後者會覆蓋掉前者
對於同一個屬性的處理結果。
註解裝配在Spring中是預設關閉的。
所以需要在Spring檔案中
配置一下才能使用基於註解的裝配模式。
如果你想要在你的應用程式中
使用關於註解的方法的話，
參考如下的配置。
<beans>
<context:annotation-config/>
</beans>
在 <context:annotation-config/>
標籤配置完成以後，
就可以用註解的方式在Spring中向屬性、
方法和構造方法中自動裝配變數。

下面是幾種比較重要的註解型別：
@Required：該註解應用於設值方法。

@Autowired：該註解應用於有值設值方法、
非設值方法、
構造方法和變數。
@Qualifier：該註解和@Autowired註解搭配使用，
用於消除特定bean自動裝配的歧義。
JSR-250 Annotations：
Spring支援基於JSR-250 
註解的以下註解，
@Resource、
@PostConstruct 
和 @PreDestroy。

145.如何在Spring中注入一個Java Collection？

•<list> :
該標籤用來裝配可重複的list值。
 <!-- java.util.List -->
<property name="customList">
<list>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>UK</value>
</list>
</property>

•<set> :
 該標籤用來裝配沒有重複的set值。
<!-- java.util.Set -->
<property name="customSet">
<set>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>UK</value>
</set>
</property>


•<map>:
 該標籤可用來注入鍵和值可以為任何型別的鍵值對。
<!-- java.util.Map -->
<property name="customMap">
<map>
<entry key="1" value="INDIA"/>
<entry key="2" value="Pakistan"/>
<entry key="3" value="USA"/>
<entry key="4" value="UK"/>
</map>
</property>


•<props> : 
該標籤支援注入鍵和值都是字串型別的鍵值對。
<!-- java.util.Properties -->
<property name="customProperies">
<props>
<prop key="admin">[email protected]</prop>
<prop key="support">[email protected]</prop>
</props>
</property>

146、什麼是Spring MVC ？簡單介紹下你對springMVC的理解?

Spring MVC是一個基於MVC架構的
用來簡化web應用程式開發的應用開發框架，
它是Spring的一個模組,
無需中間整合層來整合 ，
它和Struts2一樣都屬於表現層的框架。
在web模型中，
MVC是一種很流行的框架，
通過把Model，View，Controller分離，
把較為複雜的web應用分成邏輯清晰的幾部分，
簡化開發，減少出錯，
方便組內開發人員之間的配合。

147、SpringMVC的流程？

（1）使用者傳送請求至前端控制器DispatcherServlet；
（2） DispatcherServlet收到請求後，呼叫HandlerMapping處理器對映器，請求獲取Handle；
（3）處理器對映器根據請求url找到具體的處理器，生成處理器物件及處理器攔截器(如果有則生成)一併返回給DispatcherServlet；
（4）DispatcherServlet通過HandlerAdapter處理器介面卡呼叫處理器；
（5）執行處理器(Handler，也叫後端控制器)；
（6）Handler執行完成返回ModelAndView；
（7）HandlerAdapter將Handler執行結果ModelAndView返回給DispatcherServlet；
（8）DispatcherServlet將ModelAndView傳給ViewResolver檢視解析器進行解析；
（9）ViewResolver解析後返回具體View；
（10）DispatcherServlet對View進行渲染檢視（即將模型資料填充至檢視中）
（11）DispatcherServlet響應使用者。

148.Springmvc的優點:

1.它是基於元件技術的。
全部的應用物件,無論控制器和檢視,
還是業務物件之類的都是 java元件.
並且和Spring提供的其他基礎結構緊密整合.

2.不依賴於Servlet API(目標雖是如此,
但是在實現的時候確實是依賴於Servlet的)

3.可以任意使用各種檢視技術,
而不僅僅侷限於JSP

4.支援各種請求資源的對映策略

5.它應是易於擴充套件的

149.Spring MVC的有哪些主要組鍵？

1.前端控制器 DispatcherServlet（不需要程式設計師開發）

作用：接收請求、響應結果 相當於轉發器，
有了DispatcherServlet 
就減少了其它元件之間的耦合度。

2.處理器對映器HandlerMapping（不需要程式設計師開發）

作用：根據請求的URL來查詢Handler

3.處理器介面卡HandlerAdapter

注意：在編寫Handler的時候要按照
HandlerAdapter要求的規則去編寫，
這樣介面卡HandlerAdapter
才可以正確的去執行Handler。

4.處理器Handler（需要程式設計師開發）

5.檢視解析器 ViewResolver（不需要程式設計師開發）

作用：進行檢視的解析 根據檢視邏輯名解析成真正的檢視（view）

6.檢視View（需要程式設計師開發jsp）

View是一個介面， 
它的實現類支援不同的檢視型別
（jsp，freemarker，pdf等等）

150、springMVC和struts2的區別有哪些?

1.springmvc的入口是一個servlet即前端控制器（DispatchServlet），
而struts2入口是一個filter過慮器（StrutsPrepareAndExecuteFilter）。

2.springmvc是基於方法開發(一個url對應一個方法)，
請求引數傳遞到方法的形參，
可以設計為單例或多例(建議單例)，
struts2是基於類開發，
傳遞引數是通過類的屬性，
只能設計為多例。

3.Struts採用值棧儲存請求和響應的資料，
通過OGNL存取資料，
springmvc通過引數解析器是將request請求內容解析，
並給方法形參賦值，
將資料和檢視封裝成ModelAndView物件，
最後又將ModelAndView中的模型資料
通過reques域傳輸到頁面。
Jsp檢視解析器預設使用jstl。