一、 Struts1.x 4
1、 struts1優缺點,為什么要使用struts1 4
2、 Struts1核心組件 4
3、 Strust1請求處理流程 工作原理 4
4、 Struts1線程安全問題 4
5、 Struts1 它解決了什么問題？ 4
6、 Struts1的框架的結構是什么？ 4
7、 struts 1如何實現mvc 5
8、 DispatchAction與動態form 5
9、 為什么要使用動態form 5
二、 Hibernate面試題 5
10、 list，iterate區別 5
11、 Hibernate 核心接口session介紹 5
12、 Session接口常見方法 6
13、 Hibernate操作的對象有三種狀態 7
14、 Hibernate的檢索策略 7
15、 Query 中常見方法 8
16、 Hibernate參數綁定有幾種方式 8
17、 在Hibernate中什么是命名查詢 8
18、 Hibernate優化 8
19、 什么是懶加載 懶加載用什么技術實現，如何解決session關閉導致的懶加載問題 解決的方案有缺點嗎、 9
20、 hibernate核心類 9
21、 hibernate抓取策略 9
22、 hibernate 的原理 9
23、 Hibernate 的session.save()與session.saveOrUpdate()的區別？ 9
24、 Hibernate 中sedssion.get()與session.load()的區別？ 9
25、 介紹下hibernate 9
26、 Hibernate 中的HQL 和criteria 的區別？ 10
27、 介紹hibernate 延持加載屬性 10
28、 列舉你接觸過的框架，說明特點和原理 10
29、 Hibernate 中離線查詢與在線查詢的區別 10
30、 Ibatis 框架和Hibernate 框架各有什么特點？ 10
31、 為什么要用ORM? 和JDBC 有何不一樣? 10
32、 簡述Hibernate 和JDBC 的優缺點? 10
33、 如何書寫一個one-to-many 配置文件 10
34、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置? 10
35、 hibernate 的inverse 屬性的作用? 11
36、 Hibernate 對象有幾種狀態？如何轉換 11
37、 Hibernate 中有幾種關系映射 11
38、 介紹一下Hibernate 的一級緩存與二級緩存。 11
39、 Hibernate 中的Cascade 屬性有什么作用？ 11
40、 Hibernate.update()和merge()區別？ 11
41、 Hibernate update和flush區別？ 11
42、 Hibernate session的load()和get()的區別？ 11
43、 Hibernate List和Iterator方式的比較 12
44、 hibernate的inverse屬性的作用？ 12
45、 hibernate的cascade屬性的作用？ 12
46、 各種關聯關系下的lazy懶加載區別？ 12
47、 類(Class)的延遲加載： 13
48、 Hibernate工作原理 13
三、 Struts2.x 14
49、 MVC是什么 一種設計模式，M：model模型；V：View視圖；C：Control控制器 14
50、 簡述 Struts2 的工作流程: 14
51、 Struts2 攔截器 和 過濾器 的區別 14
52、 為什么要使用 Struts2 & Struts2 的優點： 14
53、 Struts2 如何訪問 HttpServletRequest、HttpSession、ServletContext 三個域對象 ? 14
54、 Struts2 中的默認包 struts-default 有什么作用？ 15
55、 說出 struts2 中至少 5 個的默認攔截器 15
56、 談談 ValueStack 15
57、 ActionContext、ServletContext、pageContext的區別 ？ 15
58、 Struts2 有哪幾種結果類型 ? 15
59、 攔截器的生命周期與工作過程 ? 15
60、 如何在 Struts2 中使用 Ajax 功能 ? 15
61、 用自己的話簡要闡述struts2的執行流程 15
62、 Struts工作原理 16
63、 Struts2.0 有幾種標簽庫 16
64、 struts2 必備包有哪些？ 16
65、 Hiberbate 優化方法有那些？ 16
66、 應用服務器與Web Server 的區別 16
67、 如何設置Hibernate 二級緩存 16
68、 ApplicationContext 和BeanFactory 有什么區別？ 16
69、 Spring MVC 與Struts2 MVC 的不同之處 17
70、 Spring 使用了哪些設計模式，這樣用有什么好處？ 17
71、 Hibernate 有哪幾種查詢數據的方法？ 17
72、 3 個框架在項目在項目當中的用，BaseDao 是用來做什么的。 17
73、 ThreadLocal 在項目中的實際意義？ 17
74、 Spring 對多種ORM 框架提供了很好的支持，結合事務管理描述spring 從哪些方面提供了對Hibernate 的支持。 17
75、 Hibernate 的session.save()與session.saveOrUpdate()的區別？ 17
76、 Hibernate 中sedssion.get()與session.load()的區別？ 18
77、 annotation 的使用方法和用途主要分為幾類？ 18
78、 Struts2 是怎么實現MVC 的？ 18
79、 介紹下hibernate【上海數字政通】 18
80、 在Struts2 中，配置文件中通配符是怎么表示和使用的？使用通配符后有什么好處 18
81、 Hibernate 中的HQL 和criteria 的區別？ 18
82、 介紹hibernate 延持加載屬性 18
83、 列舉你接觸過的框架，說明特點和原理 19
84、 解釋一下IOC,以及spring 的舉例 19
85、 解釋一下mvc 以及熟悉的mvc 框架 19
86、 Spring 工作原理 19
87、 Hibernate 中離線查詢與在線查詢的區別 19
88、 Struts2 實現攔截器的原理？ 19
89、 Struts2 的實現原理 19
90、 簡述spring 的事務傳播行為和隔離級別 19
91、 Ibatis 框架和Hibernate 框架各有什么特點？ 20
92、 為什么要用ORM? 和JDBC 有何不一樣? 20
93、 談談你對Spring AOP 思想的理解。 20
94、 談談你對Spring 的理解。 20
95、 說說struts1 與struts2 的區別。 20
96、 簡述Hibernate 和JDBC 的優缺點? 如何書寫一個one to many 配置文件 21
97、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置? 21
98、 hibernate 的inverse 屬性的作用? 21
99、 Spring 的依賴注入是什么意思? 給一個Bean 的message 屬性, 字符串類型, 注入值為"Hello" 的XML 配置文件該怎么寫? 21
100、 JDO 是什么? 22
101、 Spring 與EJB 的區別？ 22
102、 SSH 框架的優缺點。 22
103、 Spring 有哪幾種注入方式？ 22
104、 Spring MVC 工作機制及為什么要用? 23
105、 spring 中常用的幾種advice 23
106、 Spring 中bean 的配置scope 表示什么含義？可以有哪幾種取值。 23
107、 Hibernate 對象有幾種狀態？如何轉換 23
108、 spring 中OpenSessionInViewFilter 作用什么的，解決了什么問題 23
109、 hibernate 有哪五個核心接口。 23
110、 Hibernate 中有幾種關系映射 23
111、 介紹一下Hibernate 的一級緩存與二級緩存。 23
112、 如何在WEB 里面配置SPRING 23
113、 Hibernate 中的Cascade 屬性有什么作用？ 24
114、 Struts1 優缺點 24
115、 整合spring 與struts1 的方法，那種最好，為什么？ 24
116、 Struts1.2 的工作原理 24
117、 談談Struts1 中的ActionServlet。 24
118、 Struts1.X 中ActionServlet、ActionForm 、Action、ActionMapping 各起什么作用？ 25
119、 Struts 1 的Action 類與Struts 2 的Action 類區別？ 25
120、 談談你對Struts1 的理解。 25
121、 Struts1 中的action 是安全線程么？為什么 25
122、 在Struts1 中actionform 屬於哪一層 25
123、 struts 控制器組件的主要包括? 25
124、 常見的緩存技術舉例【大唐動力面試題】 25
125、 以Spring 為基礎的J2EE 項目中，一般如何分層？每個層的作用是什么？事務控制放在哪一層？ 25
126、 EBJ 是基於哪些技術實現的和JavaBean 的區別？ 25
127、 Webservice 有什么好處? 26
128、 什么是事物處理，J2EE 提供哪兩種事物處理方式 26
129、 WEB SERVICE 的理解【大唐動力面試題】 26
130、 J2EE 系統訪問速度慢.從哪些方面可以優化 26
131、 說說你所知道的應用服務器？ 26
四、 Spring 27
132、 對Spring理解與作用 27
133、 在spring中有幾種事務管理，分別是什么? 27
134、 JDK動態代理學習 27
135、 Spring與Struts集成 把業務對象、Action納入spring的ioc容器， 27
136、 怎么理解OpenSessionInviewFilter？ 27
137、 講講spring中的事務，如何支持事務的，事務的7大傳播屬性,spring mvc 作為控制器層需要注意什么 27
138、 什么是aop 說說AOP的一些概念概念和術語 aop好處 項目中怎么用的 27
五、 SpringMVC 28
139、 spring 如何實現mvc 請求處理流程 28
140、 spring mvc如何執行靜態文件如js文件 css文件 圖片文件 28
141、 springmvc與struts2比較 28
142、 spring mvc 注解 28
143、 說說spring dao 29
六、 MyBatis 29
144、 .ibatis/mybatis框架的優缺點? 29
145、 ibatis核心類的作用;MyBatis核心類的作用? 29
146、 mybatis/ibatis跟hibernate的比較; 29
147、 ibatis的工作流程或運行原理? 29
148、 Ibatis中#與$的區別？ 29
七、 WebServices 30
149、 怎么調用webservice 30
150、 wsdl soap 30
151、 你如何開發webservice 30
152、 項目用了webservice干什么 30
153、 安全問題： 30
154、 ejb 31
八、 EJB 31
九、 DAO 31
155、 dao是什么及其優點 31
156、 jdbc 31
157、 說說spring dao 31
158、 orm框架 什么是orm orm比較 與jdbc比較 31
159、 ibatis與mybatis比較 # $ %干什么的 32
160、 hibernate load與get list() 和 iterate() saveOrUpdate與merge 32
161、 什么是懶加載 懶加載用代理技術實現 如何解決session關閉導致的懶加載問題 解決的方案有缺點嗎 32
162、 緩存 32
163、 mybatis,hibernate如何開發一對多的案例 過程以及如何配置 33
164、 hibernate 實體的3種狀態 33
165、 hibernate 的原理步驟 核心類 33
166、 hibernate 的經驗 （如 大數據處理 性能優化 有什么經驗 最佳實踐） 33
167、 hibenrate 查詢方式 離線查詢 33
168、 hibernate抓取策略 指的是如何查詢關聯數據 （有關聯實體與關聯集合） 34
169、 hibernate注解 34
170、 你了解ejb或者jpa嗎，隨便談一下 34
一、 Struts1.x
1、 struts1優缺點,為什么要使用struts1
好處：1、良好的架構和設計
2、可重用，模塊化，擴展性好
3、Open source 開放源代碼
4、它提供了豐富的標簽庫，使頁面能更加的靈活的使用。
缺點：1、依賴於servlet API 不方便測試
2、單例模式，線程不安全
3、視圖表現層技術都支持jsp
4、類型轉換是單向的
5、沒有針對具體方法的校驗。
6、強制繼承action或者dispatchAction
7、它太過於依賴web容器，當配置文件改動一次就要重新啟動。
8、它的配置文件太過復雜。
9、ActionForm無法進行測試
2、 Struts1核心組件
ActionServlet 核心控制器
Action 業務類
ActionForm 0顯示數據 1封裝頁面數據 2回顯數據 3校驗
ActionMapping 幫助ActionServlet控制器將請求映射到業務類操作（類似於查詢action）
ActionForward 導航器，進行jsp頁面轉發
ActionError與Actionmessage 用來存儲和回收錯誤
Struts標簽庫可以減輕開發顯示層次的工作
3、 Strust1請求處理流程 工作原理
1、讀取配置
2、發送請求
3、填充form
4、校驗form input
5、派發請求 到Action的業務方法 比如execute方法
6、處理業務
7、返回響應
8、處理返回響應
工作原理：在Struts中，用戶的請求一般以*.do作為服務名，所有的*.do請求均被指向ActionServlet
ActionServlet根據Struts-config.xml中的配置信息，將用戶請求封裝成一個指定名稱的FromBean
並將此FromBean傳至指定名稱的ActionBean，由ActionBean完成相應的業務操作。
4、 Struts1線程安全問題
1、因為struts1是單例的，所以存在線程安全問題，所以我們采用在方法上標上線程同步或者使用同步代碼塊就可以解決了。
2、Action交給spring創建
3、注意不要用實例變量或類變量共享只是針對某個請求的數據，注意資料操作的同步性
5、 Struts1 它解決了什么問題？
它解決了jsp頁面代碼混亂和多個Servlet的問題
6、 Struts1的框架的結構是什么？
Jsp + servlet + tiles
7、 struts 1如何實現mvc
用戶發送請求 到達ActionServlet核心控制器,然后在通過ActionMapping幫助ActionServlet將控制器請求映射到業務類
在此之間 通過ActionForm將數據進行類型轉換，數據封裝，和校驗。
然后執行業務類的的execute方法 然后將ActionForm轉換成我們自己定義的form
在通過調用m層的方法將數據持久化到數據庫 再返回C層通過ActionForward進行頁面轉發返回到V層
8、 DispatchAction與動態form
DispatchAction:分發方法，不需要實現execute方法否則失效 在配置文件中配置parameter 里面放入如：xxx; 在調用
可在？號傳值xxx=方法名即可
動態form:
可以在配置文件里配置動態的form 他里面的屬性字段和定義的bean一樣
當前台數據傳送過來的時候可以將ActionForm直接轉換成動態的form就可以了 但是一個項目中form不可以太多
如果配置太多的話會導致項目過於臃腫
1 不能通過new創建動態form 實例 減少actionform的個數
2 修改了某個屬性不需要編譯源代碼，方便后期維護
缺點：
1 會導致配置文件臃腫
可以不用通過編程的方式而只要通過struts-config.xml文件中進行配置，以后在struts運行時，會自動根
據struts-config.xml中配置的DynaActionform來生成一個ActionForm實例
9、 為什么要使用動態form
很顯然隨着應用程序的變大，數百個ActionForm 這樣不僅編程起來麻煩，以后維護起來也麻煩，比如：
某個屬性變化了，則需要修改源代碼，然后重新編譯，但是如果使用DynaActionform則只需要修改
struts-config.xml配置文件就行了。這樣提高了應用程序的開發效率與應用程序的可維護性
但大量的使用它也會造成配置文件的臃腫
二、 Hibernate面試題
10、 list，iterate區別
- 使用list()方法獲取查詢結果，每次發出一條查詢語句，獲取全部數據
- 使用iterate()方法獲取查詢結果，先發出一條SQL 語句用來查詢滿足條件數據的id，然后依次按這些id 查詢記錄，也就是要執行N+1 條SQL 語句（N 為符合條件的記錄數）
- list()方法將不會在緩存中讀取數據，它總是一次性的從數據庫中直接查詢所有符合條件的數據，同時將獲取的數據寫入緩存
- iterate()方法則是獲取了符合條件的數據的id 后，首先根據id 在緩存中尋找符合條件的數據，若緩存中無符合條件的數據，再到數據庫中查詢
11、 Hibernate 核心接口session介紹
1、作用：提供基本的保存，刪除，更新，和加載Java對象
2、什么是清理緩存：
Session能夠在某些時間點，按照緩存中對象的變化來執行相關的SQL語句，來同步更新數據庫，這一過程別稱為清理緩存（flush）
3、SessionFactory是線程安全的（可以多個對象共用同一個對象）。而Session不是線程安全的。
為了解決Session線程不安全我們采用ThreadLocal方案。
ThreadLocal 模式的解決方案：
ThreadLocal並不是一個線程的本地實現，也就是說它不是一個Thread，而是Thread local variable（線程局部變量）。它的作用就是為每一個使用這個變量的線程提供一個變量的副本，並且每一個線程都可以獨立地改變自己的副本，而不會和其它線程的副本沖突。
ThreadLocal模式實例代碼：
public void getSession() {
Configuration cfg = new Configuration().configure();
SessionFactory sf = cfg.buildSessionFactory();
session = sf.openSession();
}
//創建ThreadLocal對象
private static final ThreadLocal threadLodacl = new ThreadLocal();
public void getSession() {
Configuration cfg = new Configuration().configure();
SessionFactory sf = cfg.buildSessionFactory();
//session = sf.openSession();
//解決session線程非安全的方式
this.session = (Session) threadLodacl.get();
if(session == null){
this.session = sf.openSession();
threadLodacl.set(this.session);
}
}
4、獲取session的兩種方式介紹
1、 getCurrentSession創建的Session會綁定到當前線程，而openSession不會
2、 getCurrentSession創建的Session會在事務回滾或者事務提交后自動關閉，而openSession創建的必須手動關閉（調用Session的cloe()方法）
3、 getCurrentSession使用方法
1、 當使用本地事務時（jdbc事務）
需要在hibernate.cfg.xml文件的<session-factor>節點添加：
<property name="hibernate.current_session_context_class">thread</property>
2、 當使用的是全局使唔時（jta事務）
<property name="hibernate.current_session_context_class">jta</property>
注意：如果使用了getCurrentSession方法又沒有在配置中配置以上方法時程序編譯無誤，但是運行匯報如下錯誤。
Exception in thread "main" org.hibernate.HibernateException: No CurrentSessionContext configured!
12、 Session接口常見方法
| 序號 |
Session 方法及說明 |
| 1 |
Transaction beginTransaction()開始工作單位，並返回關聯事務對象。 |
| 2 |
void cancelQuery()取消當前的查詢執行。 |
| 3 |
void clear()完全清除該會話。 |
| 4 |
Connection close()通過釋放和清理 JDBC 連接以結束該會話。 |
| 5 |
Criteria createCriteria(Class persistentClass)為給定的實體類或實體類的超類創建一個新的 Criteria 實例。 |
| 6 |
Criteria createCriteria(String entityName)為給定的實體名稱創建一個新的 Criteria 實例。 |
| 7 |
Serializable getIdentifier(Object object)返回與給定實體相關聯的會話的標識符值。 |
| 8 |
Query createFilter(Object collection, String queryString)為給定的集合和過濾字符創建查詢的新實例。 |
| 9 |
Query createQuery(String queryString)為給定的 HQL 查詢字符創建查詢的新實例。 |
| 10 |
SQLQuery createSQLQuery(String queryString)為給定的 SQL 查詢字符串創建 SQLQuery 的新實例。 |
| 11 |
void delete(Object object)從數據存儲中刪除持久化實例。 |
| 12 |
void delete(String entityName, Object object)從數據存儲中刪除持久化實例。 |
| 13 |
Session get(String entityName, Serializable id)返回給定命名的且帶有給定標識符或 null 的持久化實例（若無該種持久化實例）。 |
| 14 |
SessionFactory getSessionFactory()獲取創建該會話的 session 工廠。 |
| 15 |
void refresh(Object object)從基本數據庫中重新讀取給定實例的狀態。 |
| 16 |
Transaction getTransaction()獲取與該 session 關聯的事務實例。 |
| 17 |
boolean isConnected()檢查當前 session 是否連接。 |
| 18 |
boolean isDirty()該 session 中是否包含必須與數據庫同步的變化？ |
| 19 |
boolean isOpen()檢查該 session 是否仍處於開啟狀態。 |
| 20 |
Serializable save(Object object)先分配一個生成的標識，以保持給定的瞬時狀態實例。 |
| 21 |
void saveOrUpdate(Object object)保存（對象）或更新（對象）給定的實例。 |
| 22 |
void update(Object object)更新帶有標識符且是給定的處於脫管狀態的實例的持久化實例。 |
| 23 |
void update(String entityName, Object object)更新帶有標識符且是給定的處於脫管狀態的實例的持久化實例。 |
13、 Hibernate操作的對象有三種狀態
1、瞬時狀態(Transient)/臨時。2.、持久化狀態（persistent）。3、托管狀態（detached）/游離狀態
1、當一個對象通過new 新創建的時候就是瞬時狀態
瞬時狀態下對象的主鍵沒有值，也沒有納入session的管理，數據庫表中也沒有對應的記錄，當我們調用save等相關的其他方法是則進入了持久化狀態，
2、持久化狀態下對象納入了session管理中，對象標示符有值。Hibernate保證在同一個session實例的緩存中數據庫中的一條記錄只對應唯一的一個持久化對象。session在清理緩存時會根據持久化對象的屬性變化會同步更新數據庫。當session關閉后持久化狀態就會變成托管狀態。當持久化對象調用delete方法就由持久化變成了移除狀態
3、托管狀態下的特點：對象不處於session的管理中。但他曾經與某個持久化上下文發生過關聯(session)，對象標示符有值，數據庫可能存在與之相對的記錄。Hibernate不能夠保證托管狀態下的數據和數據庫中的數據同步更新。
4、臨時和游離狀態下的對象特點：等待垃圾回收，
14、 Hibernate的檢索策略
| 檢索策略 |
運行機制 |
| 立即檢索 |
立即加載與當前對象關聯的對象，需要執行多條select語句 |
| 延遲檢索 |
不立即加載與當前對象關聯的對象，在第一次訪問關聯對象時才加載其信息 |
| 迫切左外連接檢索 |
通過左外連接加載與當前對象的關聯對象。為立即檢索策略，但執行的select語句少，只執行1條select連接查詢語句 |
| 屬性 |
類級別 |
一對多關聯級別 |
多對一關聯級別 |
|
lazy |
1.<class>元素中lazy屬性的可選值為：true（延遲檢索）和false（立即檢索） 2. <class>元素中lazy屬性的默認值為true |
1.<set>元素中lazy屬性的可選值為：true（延遲檢索）、false（立即檢索）和extra（增強延遲檢索） 2. <set>元素中lazy屬性的默認值為true |
1.<many-to-one>元素中的lazy屬性的可選 值為：proxy（延遲檢索）、no-proxy（無代理延遲檢索）和false（立即檢索） 2.<many-to-one>元素中的lazy屬性的默認值為true |
|
fetch |
沒有此屬性 |
1.<set>元素中fetch屬性的可選值為：select（查詢語句）、subselect（子查詢語句）和join（迫切左外連接檢索） 2. <set>元素的fetch屬性的默認值為select |
1.<many-to-one>元素中fetch屬性的可選 值為：select（查詢語句）和join（迫切左外連接檢索） 2.<many-to-one>元素的fetch屬性的默認值為select |
1、檢索方法
a) 通過Session類的get和load方法加載指定的OID的對象
b) 通過HQL,QBC等檢索方法記載滿足條件的對象
2、檢索的作用域
a) 類級別：作用於當前對象。對當前對象時立即檢索，還是延遲檢索。默認延遲檢索只對load有效
b) 關聯級別：對關聯對象是立即檢索，延遲檢索還是迫切左外連接檢索。默認延遲檢索。對所有檢索方法有效
3、fetch的作用和取值
a) select 加載關聯對象時通過select語句實現。默認值
b) subselect 加載關聯對象時通過帶子查詢語句實現。
c) join 執行立即檢索，采用迫切左外連接檢索所有關聯對象，lazy屬性將被忽略。
總結：① select 和 subselect 適用於立即檢索和延遲檢索，join 僅使用立即檢索。
② select 和 subselect 決定加載關聯對象時查詢語句形式，join決定加載關聯對象的時機。
15、 Query 中常見方法
16、 Hibernate參數綁定有幾種方式
1、 占位符“?”
2、 命名查詢
3、 封裝參數(投影查詢)
17、 在Hibernate中什么是命名查詢
命名查詢是在映射文件中定義字符串形式的查詢語句
<query name="findPrimaryKey">
<![CDATA[
from Emp e where e.job = :job
]]>
</query>
<sql-query name="findPrimaryKey">
<![CDATA[
select * from emp where job = ‘研發部’
]]>
</sql-query>
18、 Hibernate優化
1、避免or操作
where 子句包含or 操作，執行時不使用索引
可以使用in條件來替換
2、避免使用not
where 子句包含not 關鍵字，執行時該字段的索引失效
使用比較運算符替換not
3、避免like的特殊形式
查詢時，盡可能少使用like
4、避免having子句
盡可能在where 子句中指定條件
5、避免使用distinct
在不要求或允許冗余時，應避免使用distinct
19、 什么是懶加載 懶加載用什么技術實現，如何解決session關閉導致的懶加載問題 解決的方案有缺點嗎、
懶加載就是延遲加載,采用代理技術實現，采用openSessionInViewFilter,openSessionInViewFilter其實上就是一個過濾器頁面打開時開啟session，頁面訪問結束時關閉session
當訪問用戶過多，而且網速過慢的時候,會擠爆系統
事務擴大了 加鎖導致資源等待時間過長
session范圍變大 如果加載頁面的時間過長 如網速比較慢 session內存時間過長 導致系統性能下載
數據庫連接不能及時釋放
20、 hibernate核心類
congfigeration負責管理配置信息
sessionfactory負責創建出session
session負責調用持久化方法
Transaction 負責事務管理
query為查詢接口
21、 hibernate抓取策略
Hibernate的 抓取策略有四種
1、 join 連接抓取 它是通過select語句使用外連接來加載實體或者集合 懶加載會失效--同等於mybatis中的嵌套結果
2、 select 查詢抓取 它是通過發送一條select語句抓取當前對象關聯的實體或者集合 一條查自己 一條抓關聯數據
3、 subselect 子查詢抓取 發送一條select語句查詢出關聯的實體或者集合，然后通過子查詢in完成
4、 batch-size 批量抓取
22、 hibernate 的原理
1. 讀取並解析配置文件
2. 讀取並解析映射信息，創建SessionFactory
3. 打開Sesssion
4. 創建事務Transation
5. 持久化操作
6. 提交事務
7. 關閉Session
8. 關閉SesstionFactory
23、 Hibernate 的session.save()與session.saveOrUpdate()的區別？
1.save（）方法，調用save 方法時，首先會在session 緩存中查找保存對象如果實體對象已經處於Persient 狀態，直接返回；否則並將保存至數據庫，對象變為持久狀態。
2.saveOrUpdate（）方法：和save 方法一樣首先在session 緩存中查找，判斷對象是否為為保存狀態，如果對象處於Persient，不執行操作，處於Transient 執行save 操作，處於Detached 調用saveOrUpdate 將對象與session 重新關聯（簡單的說就是該方法會先看該對象是否已經存在，如果已經存在就更新，否則新增保存），如果此時saveOrUpdate 的對象與另一個與Session 關聯的對象持有相同的持久化標識則拋出相同的標識符異常。
24、 Hibernate 中sedssion.get()與session.load()的區別？
Session.load/get 方法均可以根據指定的實體類和id 從數據庫讀取記錄，並返回與之對
應的實體對象。其區別在於：
1) 如果未能發現符合條件的記錄， get 方法返回null ， 而load 方法會拋出一個
ObjectNotFoundException。
2) load 支持延遲加載，get 不支持
3) load 方法可返回實體的代理類實例，而get 方法永遠直接返回實體類。
4) load 方法可以充分利用內部緩存和二級緩存中的現有數據，get 方法則僅僅在內部緩存
中進行數據查找，如沒有發現對應數據，將越過二級緩存，直接調用SQL 完成數據讀取。
25、 介紹下hibernate
Hibernate 是一個開放源代碼Java 語言下的對象關系映射解決方案。它為面向對象的領域模型到傳統的關系型數據庫的映射，提供了一個使用方便的框架。Hibernate 也是目前Java開發中最為流行的數據庫持久層框架。將軟件開發人員從大量相同的數據持久層相關編程工作中解放出來，Hibernate 不僅負責從Java 類到數據庫表的映射（還包括從Java 數據類型到SQL 數據類型的映射），還提供了面向對象的數據查詢檢索機制，從而極大地縮短的手動處理SQL 和JDBC 上的開發時間。
26、 Hibernate 中的HQL 和criteria 的區別？
1.QBC(Query by Criteria)查詢對查詢條件進行了面向對象封裝，符合編程人員的思維方式;
2．HQL(Hibernate Query Language)查詢提供了更加豐富的和靈活的查詢特性，在涵蓋
Criteria 查詢的所有功能的前提下，提供了類似標准SQL 語句的查詢方式，同時也
提供了更加面向對象的封裝。
27、 介紹hibernate 延持加載屬性
Hibernate 通過lazy 來指定加載策略，一般值為true 或false,。設為flase 表示立即加載，true 表過延遲加載。
28、 列舉你接觸過的框架，說明特點和原理
Hibernate 特點:
1. 基於JDBC 的主流持久化框架，是一個優秀的ORM 實現，對JDBC 訪問數據庫的代碼做了封裝，大大簡化了數據訪問層繁瑣的重復性代碼。
2. hibernate 使用Java 反射機制，而不是字節碼增強程序來實現透明性。
3. hibernate 的性能非常好，因為它是個輕量級框架。映射的靈活性很出色。它支持各種關系數據庫，從一對一到多對多的各種復雜關系。
Spring 特點：
Spring 框架的主要優勢之一低侵入式的架構思想，實現了IOC 容器。另外一個AOP 的編程也在很多應用場合下地位較重。提供了對各種不同類型框架的支持，如：Web 容器、持入層、事務層、其它J2EE 組件等。
29、 Hibernate 中離線查詢與在線查詢的區別
Criteria 和DetachedCriteria 的主要區別在於創建的形式不一樣， Criteria 是在線的，所以它是由Hibernate Session 進行創建的；而DetachedCriteria 是離線的，創建時無需Session，DetachedCriteria 提供了2 個靜態方法forClass(Class) 或forEntityName(Name)進行DetachedCriteria 實例的創建。
30、 Ibatis 框架和Hibernate 框架各有什么特點？
31、 為什么要用ORM? 和JDBC 有何不一樣?
orm 是一種思想，就是把object 對象轉變成數據庫中的記錄，或者把數據庫中的記錄轉變成object 對象，我們可以用jdbc 來實現這種思想，orm 的思想本質就是建立是JDBC 上，對JDBC 的一種封裝，這種封裝可以省去了直接使用jdbc 的繁瑣細節，提高了開發效率，現在用的較多的ORM 工具很多，一般我們公司采用的ORM 框架主要有hibernate 和MyBatis。當然也聽說一些其他orm 工具，如toplink,ojb 等。
32、 簡述Hibernate 和JDBC 的優缺點?
1、封裝了jdbc，簡化了很多重復性代碼。
2、簡化了DAO 層編碼工作，使開發更對象化了。
3、移植性好，支持各種數據庫，如果換個數據庫只要在配置文件中變換配置就可以了，不用改變hibernate 代碼。
4、支持透明持久化，因為hibernate 操作的是純粹的（pojo）java 類，沒有實現任何接口，沒有侵入性。
33、 如何書寫一個one-to-many 配置文件
34、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置?
1、 配置一對多
<!-- 部門對員工的一對多配置-->
<set name="employees" inverse="true" cascade="delete">
<key column="deptid"></key>
<one-to-many class="com.tsinghua.manager.vo.EmployeeVO"/>
</set>
2、 多對一
<!-- 員工對部門的多對一配置column 指定外鍵-->
<many-to-one name="department" class="com.tsinghua.manager.vo.DepartmentVO" column="deptid" />
35、 hibernate 的inverse 屬性的作用?
在Hibernate 中，術語inverse 是反轉的意思，在關聯關系中，inverse="false"為主控方，由主控方負責維護對象的關聯關系，如果設為主控方對象，主控對象更新，則負責更新另一方對象更新。
36、 Hibernate 對象有幾種狀態？如何轉換
共3 種狀態，分別是：Transient 狀態（瞬時）、Persient 狀態（持久）、Detached（脫管狀態）狀態。
37、 Hibernate 中有幾種關系映射
主要有單向一對一、單向一對多、單向多對一、單向多對多、雙向一對一、雙向一對多、雙向多對多
38、 介紹一下Hibernate 的一級緩存與二級緩存。
緩存就是把以前從數據庫中查詢出來和使用過的對象保存在內存中（一個數據結構中），這個數據結構通常是或類似Hashmap，當以后要使用某個對象時，先查詢緩存中是否有這個對象，如果有則使用緩存中的對象，如果沒有則去查詢數據庫，並將查詢出來的對象保存在緩存中，以便下次使用。Hibernate 的Session 就是一種緩存，我們通常將之稱為Hibernate的一級緩存，當想使用session 從數據庫中查詢出一個對象時，Session 也是先從自己內部查看是否存在這個對象，存在則直接返回，不存在才去訪問數據庫，並將查詢的結果保存在自己內部。由於Session 代表一次會話過程，一個Session 與一個數據庫連接相關連，所以Session 最好不要長時間保持打開，通常僅用於一個事務當中，在事務結束時就應關閉。並且Session 是線程不安全的，被多個線程共享時容易出現問題。通常只有那種全局意義上的緩存才是真正的緩存應用，才有較大的緩存價值，因此，Hibernate 的Session 這一級緩存的緩存作用並不明顯，應用價值不大。Hibernate 的二級緩存就是要為Hibernate 配置一種全局緩存，讓多個線程和多個事務都可以共享這個緩存。一般我們叫它sessionFactory 緩存，也叫進程級的緩存，使用第3 方插件實現的，也值緩存實體，生命周期和sessionFactory 一致，可以進行管理。
二級緩存具體實現：
首先配置第3 放插件，我們用的是EHCache，在hibernate.cfg.xml 文件中加入<propertyname="hibernate.cache.user_second_level_cache">true</property>
在映射中也要顯示的調用，<cacheusage="read-only"/>二級緩存之查詢緩存：對普通屬性進行緩存。如果關聯的表發生了修改，那么查詢緩存的生
命周期也結束了。在程序中必須手動啟用查詢緩存：query.setCacheable(true);
39、 Hibernate 中的Cascade 屬性有什么作用？
cascade 屬性的作用是描述關聯對象進行操作時的級聯特性。可以有以下幾種取值：
all : 所有情況下均進行關聯操作。
save-update：(級聯保存) 表明保存或更新當前對象時會級聯保存或更新他所關聯的對象。
none：所有情況下均不進行關聯操作。這是默認值。
delete ：(級聯刪除) 級聯刪除所關聯的對象。
all-delete-orphan：自動刪除不再和父對象關聯的子對象。並且，在出現上面兩種情況時執行上面兩種的功能，可以說是一個全自動的屬性值。
40、 Hibernate.update()和merge()區別？
前面說過update，基本merge和update一樣。但如果session中存在相同持久化標識(identifier)的實例，用用戶給出的對象覆蓋session已有的持久實例
(1)當我們使用update的時候，執行完成后，會拋出異常
(2)但當我們使用merge的時候，把處理自由態的po對象A的屬性copy到session當中處於持久態的po的屬性中，執行完成后原來是持久狀態還是持久態，而我們提供的A還是自由態。
41、 Hibernate update和flush區別？
Hibernate update操作的是在自由態或脫管狀態(因session的關閉而處於脫管狀態)的對象，而flush是操作的在持久狀態的對象。
默認情況下，一個持久狀態的對象的改動(包含set容器)是不需要update的，只要你更改了對象的值，等待Hibernate flush就自動更新或保存到數據庫了。
(1) 調用某些查詢的和手動flush(),session的關閉、SessionFactory關閉結合。get()一個對象，把對象的屬性進行改變,把資源關閉。
(2)transaction commit的時候(包含了flush) 。
42、 Hibernate session的load()和get()的區別？
1：如果你使用load方法，hibernate認為該id對應的對象（數據庫記錄）在數據庫中是一定存在的，所以它可以放心的使用，它可以放心的使用代理來延遲加載該對象。在用到對象中的其他屬性數據時才查詢數據庫，但是萬一數據庫中不存在該記錄，那沒辦法，只能拋異常，所說的load方法拋異常是指在使用該對象的數據時，數據庫中不存在該數據時拋異常，而不是在創建這個對象時。由於session中的緩存對於hibernate來說是個相當廉價的資源，所以在load時會先查一下session緩存看看該id對應的對象是否存在，不存在則創建代理。所以如果你知道該id在數據庫中一定有對應記錄存在就可以使用load方法來實現延遲加載。 對於get方法，hibernate會確認一下該id對應的數據是否存在，首先在session緩存中查找，然后在二級緩存中查找，還沒有就查數據庫，數據庫中沒有就返回null(網上有很多誤解以為get就馬上去數據庫查找根本不先查session那是不正確的，不想信你就去做下試驗便知)。
2、“get()永遠只返回實體類”，但實際上這是不正確的，get方法如果在session緩存中找到了該id對應的對象，如果剛好該對象前面是被代理過的，如被load方法使用過，或者被其他關聯對象延遲加載過，那么返回的還是原先的代理對象，而不是實體類對象，如果該代理對象還沒有加載實體數據（就是id以外的其他屬性數據），那么它會查詢二級緩存或者數據庫來加載數據，但是返回的還是代理對象，只不過已經加載了實體數據。
3、再注重說明get方法首先查詢session緩存，沒有的話查詢二級緩存，最后查詢數據庫；反而load方法創建時首先查詢session緩存，沒有就創建代理，實際使用數據時才查詢二級緩存和數據庫。
總之對於get和load的根本區別，一句話，hibernate對於load方法認為該數據在數據庫中一定存在，可以放心的使用代理來延遲加載，如果在使用過程中發現了問題，只能拋異常；而對於get方法，hibernate一定要獲取到真實的數據，否則返回null。
43、 Hibernate List和Iterator方式的比較
(1)、List方式是1次性把所有的數據全部取到內存中，構造一個超大的結果集，主要的時間開銷是這一步，這一步的時間開銷要遠遠超過JDBC和 Iterator方式下構造結果集的時間開銷，並且內存開銷也很驚人；而對結果集的遍歷操作，速度則是非常的驚人（經過測試，30萬記錄的內 存遍歷不到100ms，由於這一步不受JDBC影響，因此結果可信）。因此，List方式適合於對結果集進行反復多次操作的情況，例如分頁顯示，往后往前 遍歷，跳到第一行，跳到最后一行等等。
(2)、Iterator方式只取記錄id到內存中，並沒有把所有數據取到內存中，因此構造結果集的時間開銷很小，比JDBC和List方式都要少，並且內 存開銷也小很多。而對結果集的遍歷的操作的時候，Iterator仍然要訪問數據庫，所有主要的時間開銷都花在這里。因此，Iterator方式適合於只 對結果集進行1次遍歷操作的情況，並且Iterator方式特別適合於從超大結果集中取少量數據，這種情況Iterator性能非常好
44、 hibernate的inverse屬性的作用？
在Hibernate中，術語inverse是反轉的意思，在關聯關系中，inverse=”false”為主控方，由主控方負責維護對象的關聯關系。
inverse 決定是否把對對象中集合的改動反映到數據庫中，所以inverse只對集合起作用，也就是只對one-to-many或many-to-many有效（因 為只有這兩種關聯關系包含集合，而one-to-one和many-to-one只含有關系對方的一個引用，注意一般只在雙向關聯時才有需要設置inverse）。
（1）、一對多：
通常會在的one一方放棄對多的關系的維護，這樣效率會高起來（如老師記住每位學生是件困難的事情，效率是很低的，所以干脆就不記了，這關系由學生來維護，學生記住一位老師是很容易）
所以應該在一方的設置 inverse=true ，多的一方設置 inverse=false（多的一方也可以不設置inverse屬性，因為默認值是false），這說明關聯關系由多的一方來維護。
如果要一方維護關系，就會使在插入或是刪除”一”方時去update”多”方的每一個與這個”一”的對象有關系的對象。
而如果讓”多”方面維護關系時就不會有update操作，因為關系就是在多方的對象中的，直指插入或是刪除多方對象就行了。
顯然這樣做的話，會減少很多操作，提高了效率。
注：單向one-to-many關聯關系中，不可以設置inverse=”true”,因為被控方的映射文件中沒有主控方的信息。
（2）、多對多： 屬性在獨立表中。inverse屬性的默認值為false。在多對多關聯關系中，關系的兩端 inverse不能都設為false,即默認的情況是不對的，如果都設為false,在做插入操作時會導致在關系表中插入兩次關系。也不能都設為 true，如果都設為true,任何操作都不會觸發對關系表的操作。因此在任意一方設置inverse=true，另一方inverse=false。
45、 hibernate的cascade屬性的作用？
cascade屬性的作用是描述關聯對象進行操作時的級聯特性。因此，只有涉及到關系的元素才有cascade屬性。
具 有cascade屬性的標記包括<many-to-one /> <one-to-one /> <any /> <set /><bag /> <idbag /> <list /> <array />
注意：<ont-to-many />和 <many-to-many />是用在集合標記內部的，所以是不需要cascade屬性的。
級聯操作：指當主控方執行某項操作時，是否要對被關聯方也執行相同的操作。
46、 各種關聯關系下的lazy懶加載區別？
1、 one-to-one懶加載
一對一的懶加載並不常用，因為懶加載的目的是為了減少與數據庫的交互，從而提高執行效率，而在一對一關系中，主表中的每一條數據只對應從表的一條數據庫，就算都查詢也不會增加多少交互的成本，而且主表不能有contrained=true，所以主表是不能懶加載的。但是從表可以有。實現此種懶加載必須在從對象這邊同時滿足三個條件：
a）lazy!=false（lazy的屬性有三個選項分別為：no-proxy、false和proxy）
b）Constrained = true ；
c）fetch=select。
注：當fetch設置為join時，懶加載就會失效。因為fetch的作用是抓取方式，他有兩個值分別為select和join，默認值為select。即在設為join時，他會直接將從表信息以join方式查詢到而不是再次使用select查詢，這樣導致了懶加載的失效。
2、 one-to-many懶加載
與one-to-one關聯不同，對one-to-many而言，主表的每一條屬性都會對應從表的多條數據，這個時候懶加載就顯得非常有效了。比如一個部門里面有多個員工，如果沒有懶加載，每查詢這個部門的時候都會查詢出多個員工，這會大大增加與數據庫交互的成本。所以Hbernate默認的是加入懶加載的。這就是查詢集合屬性的時候返回的是一個PersistentIndexed*類型對象的原因。該對象其實就是一個代理對象。當然，可以在映射文件中通過將lazy屬性設為假來禁用。
Hibernate默認對one-to-many就是使用的懶加載，但用戶也可以取消懶加載操作：
一：設置lazy=”false”;
二：設置fetch=”join”.
實現此種懶加載必須在從對象這邊同時滿足兩個條件：
1、lazy!=false（lazy的屬性有三個選項分別為：no-proxy、false和proxy）
2、fetch=select。
3、 many-to-one懶加載
此關聯關系的懶加載和one-to-one的懶加載一樣都是可要可不要的，因為對執行效率的提高都不是非常明顯。雖然多對一與一對一關系方式相同，但是在Hibernate中多對一時，默認是進行懶加載的。另外有一點需要注意的是懶加載並不會區分集合屬性里面是否有值，即使是沒有值，他依然會使用懶加載。實現此種懶加載必須在從對象這邊同時滿足兩個條件
1、lazy!=false（lazy的屬性有三個選項分別為：no-proxy、false和proxy）
2、fetch=select
4、 many-to-many懶加載
此關聯關系的懶加載和one-to-many的懶加載一樣對程序的執行效率的提高都是非常明顯的。
實現此種懶加載必須在從對象這邊同時滿足兩個條件：
1、lazy!=false（lazy的屬性有三個選項分別為：no-proxy、false和proxy）
2、fetch=select
能夠懶加載的對象都是被改過的代理對象，當相應的對象沒有關閉時，訪問這些懶加載對象的屬性（getId和getClass除外）Hibernate會初始化這些代理，或用hibernate.initalize(proxy)來初始化代理對象；當關閉session后在訪問懶加載的對象就會出現異常。
47、 類(Class)的延遲加載：
◆設置<class>標簽中的lazy=”true”,或是保持默認（即不配置lazy屬性)
◆ 如果lazy的屬性值為true，那么在使用load方法加載數據時，只有確實用到數據的時候才會發出sql語句；這樣有可能減少系統的開銷。
注意：在class標簽上配置的lazy屬性不會影響到關聯對象!
48、 Hibernate工作原理
三、 Struts2.x
49、 MVC是什么
一種設計模式，M：model模型；V：View視圖；C：Control控制器
50、 簡述 Struts2 的工作流程:
① 請求發送給 StrutsPrepareAndExecuteFilter
② StrutsPrepareAndExecuteFilter 判定該請求是否是一個 Struts2 請求
③ 若該請求是一個 Struts2 請求，則 StrutsPrepareAndExecuteFilter 把請求的處理交給 ActionProxy
④ ActionProxy 創建一個 ActionInvocation 的實例，並進行初始化
⑤ ActionInvocation 實例在調用 Action 的過程前后，涉及到相關攔截器（Intercepter）的調用。
⑥ Action 執行完畢，ActionInvocation 負責根據 struts.xml 中的配置找到對應的返回結果。調用結果的 execute 方法，渲染結果。
⑦ 執行各個攔截器 invocation.invoke() 之后的代碼
⑧ 把結果發送到客戶端
51、 Struts2 攔截器 和 過濾器 的區別
① 過濾器依賴於Servlet容器，而攔截器不依賴於Servlet容器。
② Struts2 攔截器只能對 Action 請求起作用，而過濾器則可以對幾乎所有請求起作用。
③ 攔截器可以訪問 Action 上下文(ActionContext)、值棧里的對象(ValueStack)，而過濾器不能.
④ 在 Action 的生命周期中，攔截器可以多次調用，而過濾器只能在容器初始化時被調用一次。
52、 為什么要使用 Struts2 & Struts2 的優點：
① 基於 MVC 架構，框架結構清晰。
② 使用 OGNL: OGNL 可以快捷的訪問值棧中的數據、調用值棧中對象的方法
③ 攔截器: Struts2 的攔截器是一個 Action 級別的 AOP, Struts2 中的許多特性都是通過攔截器來實現的, 例如異常處理，文件上傳，驗證等。攔截器是可配置與重用的
③ 多種表現層技術. 如：JSP、FreeMarker、Velocity 等
53、 Struts2 如何訪問 HttpServletRequest、HttpSession、ServletContext 三個域對象 ?
① 與 Servlet API 解耦的訪問方式
> 通過 ActionContext 訪問域對象對應的 Map 對象
> 通過實現 Aware 接口使 Struts2 注入對應的 Map 對象
② 與 Servlet API 耦合的訪問方式
> 通過 ServletActionContext 直接獲取 Servlet API 對象
> 通過實現 ServletXxxAware 接口的方式使 Struts2 注入對應的對象
54、 Struts2 中的默認包 struts-default 有什么作用？
①. struts-default 包是 struts2 內置的，它定義了 struts2 內部的眾多攔截器和 Result 類型，而 Struts2 很多核心的功能都是通過這些內置的攔截器實現，如：從請求中把請求參數封裝到action、文件上傳和數據驗證等等都是通過攔截器實現的。當包繼承了truts-default包才能使用struts2為我們提供的這些功能。
②.struts-default 包是在 struts-default.xml 中定義，struts-default.xml 也是 Struts2 默認配置文件。Struts2 每次都會自動加載 struts-default.xml文件。
③. 通常每個包都應該繼承 struts-default 包。
55、 說出 struts2 中至少 5 個的默認攔截器
exception；fileUpload；i18n；modelDriven；params；prepare；token；tokenSession；validation 等
56、 談談 ValueStack
①. ValueStack 貫穿整個 Action 的生命周期，保存在 request 域中，所以 ValueStack 和 request 的生命周期一樣. 當 Struts2 接受一個請求時，會迅速創建 ActionContext，ValueStack，Action. 然后把 Action 存放進 ValueStack，所以 Action 的實例變量可以被 OGNL 訪問。請求來的時候，Action、ValueStack 的生命開始；請求結束，Action、ValueStack的生命結束
②. 值棧是多實例的，因為Action 是多例的(和 Servlet 不一樣，Servelt 是單例的)，而每個 Action 都有一個對應的值棧，Action 對象默認保存在棧頂；
③. ValueStack 本質上就是一個 ArrayList(查看源代碼得到)；
④. 使用 OGNL 訪問值棧的內容時，不需要#號，而訪問 request、session、application、attr 時，需要加#號；
⑤. Struts2 重寫了 request 的 getAttribute 方法，所以可以使用 EL 直接訪問值棧中的內容
57、 ActionContext、ServletContext、pageContext的區別 ？
① ActionContext Struts2 的 API：是當前的 Action 的上下文環境
② ServletContext 和 PageContext 是 Servlet 的 API
58、 Struts2 有哪幾種結果類型 ?
dispatcher、chain、redirect
59、 攔截器的生命周期與工作過程 ?
每個攔截器都是需要實現 Interceptor 接口
> init()：在攔截器被創建后立即被調用, 它在攔截器的生命周期內只被調用一次. 可以在該方法中對相關資源進行必要的初始化；
> intercept(ActionInvocation invocation)：每攔截一個動作請求，該方法就會被調用一次；
> destroy：該方法將在攔截器被銷毀之前被調用, 它在攔截器的生命周期內也只被調用一次；
60、 如何在 Struts2 中使用 Ajax 功能 ?
① . JSON plugin
② . DOJO plugin
③ . DWR plugin
④ . 使用 Stream 結果類型.
61、 用自己的話簡要闡述struts2的執行流程
Struts 2框架本身大致可以分為3個部分：核心控制器FilterDispatcher、業務控制器Action和用戶實現的企業業務邏輯組件。核心控制器FilterDispatcher是Struts 2框架的基礎，包含了框架內部的控制流程和處理機制。業務控制器Action和業務邏輯組件是需要用戶來自己實現的。用戶在開發Action和業務邏輯組件的同時，還需要編寫相關的配置文件，供核心控制器FilterDispatcher來使用。 Struts 2的工作流程相對於Struts 1要簡單，與WebWork框架基本相同，所以說Struts 2是WebWork的升級版本。基本簡要流程如下：1、客戶端瀏覽器發出HTTP請求。2、根據web.xml配置，該請求被FilterDispatcher接收。3、根據struts.xml配置，找到需要調用的Action類和方法， 並通過IoC方式，將值注入給Aciton。4、Action調用業務邏輯組件處理業務邏輯，這一步包含表單驗證。5、Action執行完畢，根據struts.xml中的配置找到對應的返回結果result，並跳轉到相應頁面。6、返回HTTP響應到客戶端瀏覽器。
62、 Struts工作原理
一個請求在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中的配置找到對應的返回結果。返回結果通常是（但不總是，也可 能是另外的一個Action鏈）一個需要被表示的JSP或者FreeMarker的模版。在表示的過程中可以使用Struts2 框架中繼承的標簽。在這個過程中需要涉及到ActionMapper
基本簡要流程如下：1、客戶端瀏覽器發出HTTP請求。2、根據web.xml配置，該請求被FilterDispatcher接收。3、根據struts.xml配置，找到需要調用的Action類和方法， 並通過IoC方式，將值注入給Aciton。4、Action調用業務邏輯組件處理業務邏輯，這一步包含表單驗證。5、Action執行完畢，根據struts.xml中的配置找到對應的返回結果result，並跳轉到相應頁面。6、返回HTTP響應到客戶端瀏覽器。
63、 Struts2.0 有幾種標簽庫
【參考答案】UI 標簽、控制標簽、數據標簽、雜項標簽
64、 struts2 必備包有哪些？
【參考答案】
commons-fileupload-1.2.1.jar
freemarker-2.3.13.jar
ognl-2.6.11.jar
struts2-core-2.1.6.jar
xwork-2.1.2.jar
65、 Hiberbate 優化方法有那些？
【參考答案】
1) 盡量使用many-to-one，避免使用one-to-many
2) 靈活使用單向one-to-many
3) 不用一對一，使用多對一代替一對一
4) 配置對象緩存，不使用集合緩存
5) 一對多使用Bag 多對一使用Set
6) 繼承使用顯示多態HQL:from object polymorphism="exlicit" 避免查處所有對象
7) 消除大表，使用二級緩存
66、 應用服務器與Web Server 的區別
67、 如何設置Hibernate 二級緩存
1、首先要打開二級緩存，在hibernate.cfg.xml 中添加如下配置：<property name="hibernate.cache.use_second_level_cache">true</property>
2、Hibernate 的二級緩存使用第三方的緩存工具來實現，所以我們需要指定Hibernate使用哪個緩存工具。如下配置指定Hibernate 使用EhCache 緩存工具。
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider
</property>
3、 Hibernate 在默認情況下並不會對所有實體對象進行緩存，所以，我們需要指定緩存哪些對象，在實體對象的映射文件中（相應的<class>標簽內部），添加如下配置：<cache usage="read-only"/>usage="read-only"是“只讀”緩存策略。
68、 ApplicationContext 和BeanFactory 有什么區別？
BeanFactory 實際上是實例化，配置和管理眾多bean 的容器。這些bean 通常會彼此合作，因而它們之間會產生依賴，而這種依賴只是體現在Bean 與Bean 之間的依賴這些依賴關系可以通過配置來反映，而ApplicationContext beans 包是BeanFactory 的子類，提供了以編程的方式管理和操控bean 的基本功能，而context 包增加了ApplicationContext，它以一種更加面向框架的方式增強了BeanFactory 的功能，簡單說他增強了面向Web 容器的功能。ApplictionContext 完全采用聲明式方式來使用容器，甚至不用去手工創建它，Web應用的啟動進程中用它啟動ApplicationContext 。當然用編程的方式創建一個ApplicationContext 對象可以有以下幾種方式或實現：
1、ClassPathXmlApplicationContext:從類路徑中的XML 文件載入上下文定義信息，把上下文定義文件當作類路徑資源。
2、FileSystemXmlApplicationContext:從文件系統中的XML 文件載入上下文定義信息。
3、XmlWebApplicationContext：從Web 系統中的XMl 文件載入上下文信息。
69、 Spring MVC 與Struts2 MVC 的不同之處
【參考答案】
1、請求處理機制：spring mvc 是基於方法的設計，而sturts 是基於類，每次發一次請求都會實例一個action，每個action 都會被注入屬性，而spring 基於方法，粒度更細。
2、參數傳遞：struts 是在接受參數的時候，可以用屬性來接受參數，這就說明參數是讓多個方法共享的。
3、設計思想上：struts 更加符合oop 的編程思想， spring 就比較謹慎，在servlet 上擴展。
4、intercepter 的實現機制：struts 有以自己的interceptor 機制，spring mvc 用的是獨立的AOP 方式。這樣導致struts 的配置文件量還是比spring mvc 大，雖然struts 的配置能繼承，所以我覺得論使用上來講，spring mvc 使用更加簡潔，開發效率Spring MVC 確實比struts2高。
70、 Spring 使用了哪些設計模式，這樣用有什么好處？
【參考答案】
最典型的像：工廠模式，Spring 的IOC 容器就是一個大的Bean 實例的工廠，負責Bean的周期管理。單例模式，這個和Spring 的IOC 一起的，既然是IOC 是一個大工廠，那個Bean對象為減少內存開銷就需要提供單例特征。適配器模式，在Spring 的AOP 編程中隨處可見Adapter 模式的應用。代理模式，為其它對象提供一種代理訪問的機制。觀察者模式，當對象發生變化時，其它對象需要得到相應更新，Spring 中應用也較為普遍。
71、 Hibernate 有哪幾種查詢數據的方法？
【參考答案】
hibernate 查詢有三種方式：HQL 查詢、結構化SQL 查詢、QBC 查詢
72、 3 個框架在項目在項目當中的用，BaseDao 是用來做什么的。
【參考答案】
DAO 組件主要提供數據庫訪問操作，針對不同數據源表持久化操作進行了封裝，這樣可以提供其它層的訪問接口，使得組件之間解耦。而BaseDAO 是這些所有這些不同的持久化的DAO 的公共API 進行了封裝，進一步抽象提取，使其它各組件DAO 從BaseDAO 中派生，增強系統的重用性、維護性、擴展性。
73、 ThreadLocal 在項目中的實際意義？
【參考答案】
ThreadLocal 和其它同步機制相比從另一個角度來解決多線程的並發訪問，它為每一個線程維護一個和該線程綁定的變量的副本，從而隔離了多個線程的數據，每一個線程都擁有自己的變量副本，從而也就沒有必要對該變量進行同步了。還提供了線程安全的共享對象，在編寫多線程代碼時，可以把不安全的整個變量封裝進ThreadLocal
ThreadLocal 可以大量減少參數的傳遞，可以使代碼簡潔，但一個線程會綁定多個自己定義的局部對象，ThreadLocal 是抽象在線程上的對象創建工廠，目前的Tomcat5 使用了線程池，一個線程處理一個request，這樣ThreadLocal 對象可以抽象的綁定在request 生命周期，不會存在線程危機，而且線程池也平衡了這些ThreadLocal
74、 Spring 對多種ORM 框架提供了很好的支持，結合事務管理描述spring 從哪些方面提供了對Hibernate 的支持。
【參考答案】
1、SessionFactory 管理。使用Spring 整合Hibernate 時我們不需要hibernate.cfg.xml 文件。首先， 在applicationContext.xml 中配置數據源（ dataSource ） bean 和session 工廠（sessionFactory）bean。
2、持入層管理。Spring 提供了HibernateTemplate，用於持久層訪問，無需打開Session及關閉Session。它只要獲得SessionFactory 的引用，將可以只讀地打開Session，並在持久化訪問結束后關閉Session，對持久層邏輯，通用的操作（如對數據庫中數據的增，刪，改，查）有HibernateTemplate 完成。
3、對DAO 的支持：通過繼承HibernateDaoSupport 實現DAO 基本操作。
4、對事務支持：Spring 的聲明式事務和編程式事務，很好的將持久化的操作納入事務管理。
75、 Hibernate 的session.save()與session.saveOrUpdate()的區別？
【參考答案】
1.save（）方法，調用save 方法時，首先會在session 緩存中查找保存對象如果實體對象已經處於Persient 狀態，直接返回；否則並將保存至數據庫，對象變為持久狀態。
2.saveOrUpdate（）方法：和save 方法一樣首先在session 緩存中查找，判斷對象是否為為保存狀態，如果對象處於Persient，不執行操作，處於Transient 執行save 操作，處於Detached 調用saveOrUpdate 將對象與session 重新關聯（簡單的說就是該方法會先看該對象是否已經存在，如果已經存在就更新，否則新增保存），如果此時saveOrUpdate 的對象與另一個與Session 關聯的對象持有相同的持久化標識則拋出相同的標識符異常。
76、 Hibernate 中sedssion.get()與session.load()的區別？
【參考答案】
Session.load/get 方法均可以根據指定的實體類和id 從數據庫讀取記錄，並返回與之對應的實體對象。其區別在於：
1) 如果未能發現符合條件的記錄， get 方法返回null ， 而load 方法會拋出一個ObjectNotFoundException。
2) load 支持延遲加載，get 不支持
3) load 方法可返回實體的代理類實例，而get 方法永遠直接返回實體類。
4) load 方法可以充分利用內部緩存和二級緩存中的現有數據，get 方法則僅僅在內部緩存中進行數據查找，如沒有發現對應數據，將越過二級緩存，直接調用SQL 完成數據讀取。
77、 annotation 的使用方法和用途主要分為幾類？
【參考答案】
1、內建Annotation——Java5.0 版在java 語法中經常用到的內建Annotation：
2、開發者自定義Annotation：由開發者自定義Annotation 類型；
3、使用第三方開發的Annotation 類型
78、 Struts2 是怎么實現MVC 的？
【參考答案】
MVC 就是model view controller，三種組件，Struts2 實現Controller 主要由一系列的前端過濾器（Filter）實現Controller。Model 層主要由Struts2 的Action 組件實現。View 層主要是由Struts2 的標簽庫、Freemarker 等組件實現視圖層
79、 介紹下hibernate【上海數字政通】
【參考答案】
Hibernate 是一個開放源代碼Java 語言下的對象關系映射解決方案。它為面向對象的領域模型到傳統的關系型數據庫的映射，提供了一個使用方便的框架。Hibernate 也是目前Java開發中最為流行的數據庫持久層框架。將軟件開發人員從大量相同的數據持久層相關編程工作中解放出來，Hibernate 不僅負責從Java 類到數據庫表的映射（還包括從Java 數據類型到SQL 數據類型的映射），還提供了面向對象的數據查詢檢索機制，從而極大地縮短的手動處理SQL 和JDBC 上的開發時間。
80、 在Struts2 中，配置文件中通配符是怎么表示和使用的？使用通配符后有什么好處
調用相同Action 中的不同方法
<action name="*Action" class="Jcuckoo.LoginRegistAction" method="{1}">
<result name="input">/login.jsp</result>
<result name="error">/error.jsp</result>
<result name="success">/welcome.jsp</result>
</action>
其中表達式{1}的值name 屬性值中第一個*的值。如果用戶請求的URL 為loginAction.action,則調用Jcuckoo.LoginRegistAction 中的login 方法；
如果用戶請求的URL 為registerAction.action,則調用Jcuckoo.LoginRegistAction 中的register 方法
示例2：帶轉視圖
<action name="crud_*" class="Jcuckoo.CrudAction" method="{1}">
<result name="input">/input.jsp</result>
<result>/{1}.jsp</result>
</action>
當處理結果是input 時，會轉到/input.jsp 頁面當處理結果是success 時，如果crud_create.action，則會執行Jcuckoo.CrudAction 中的create 方法，並且跳
轉到/create.jsp；如果crud_delete.action，則會執行Jcuckoo.CrudAction 中的delete 方法，並且跳轉到/delete.jsp；
優點：
使用通配符能規范命名格式，簡潔配置文件，加速開發效率，也是Struts 倡導的一種開發模式。
81、 Hibernate 中的HQL 和criteria 的區別？
【參考答案】
1.QBC(Query by Criteria)查詢對查詢條件進行了面向對象封裝，符合編程人員的思維方式;
2．HQL(Hibernate Query Language)查詢提供了更加豐富的和靈活的查詢特性，在涵蓋Criteria 查詢的所有功能的前提下，提供了類似標准SQL 語句的查詢方式，同時也提供了更加面向對象的封裝。
82、 介紹hibernate 延持加載屬性
【參考答案】Hibernate 通過lazy 來指定加載策略，一般值為true 或false,。設為flase 表示立即加載，true 表過延遲加載。
83、 列舉你接觸過的框架，說明特點和原理
Hibernate 特點：
1. 基於JDBC 的主流持久化框架，是一個優秀的ORM 實現，對JDBC 訪問數據庫的代碼做了封裝，大大簡化了數據訪問層繁瑣的重復性代碼。
2. hibernate 使用Java 反射機制，而不是字節碼增強程序來實現透明性。
3. hibernate 的性能非常好，因為它是個輕量級框架。映射的靈活性很出色。它支持各種關系數據庫，從一對一到多對多的各種復雜關系。
Spring 特點：
Spring 框架的主要優勢之一低侵入式的架構思想，實現了IOC 容器。另外一個AOP 的編程也在很多應用場合下地位較重。提供了對各種不同類型框架的支持，如：Web 容器、持入層、事務層、其它J2EE 組件等。
84、 解釋一下IOC,以及spring 的舉例
IOC 稱為控制反轉，也叫依賴注入，ioc 是Spring 的核心組件，它通過配置文件，將需要創建的對象以池的方式管理，將實例注入到需要的對象中區，是對象依賴於注入而不依賴於實現，解決了各個組件的耦合度，使得項目在后期的維護和擴展上非常方便。如在ssh框架整合中，我們將datasource 對象注入給sessionFactory，再將sessionFactory 注入給dao 組件，再將dao 組件注入給struts 的Action 組件，在將action 對象注入給struts的攔截器。
85、 解釋一下mvc 以及熟悉的mvc 框架
MVC 是Model－View－Controller 的簡寫。Model 代表的是應用的業務邏輯（通過JavaBean，EJB 組件實現）， View 是應用的表示層（由JSP、HTML、各種Taglib 等組成），Controller 是提供應用程序的中心控制處理。通過這種設計模型把應用邏輯，處理過程和顯示邏輯分成不同的組件實現，這些組件可以進行交互和重用，另外有利於維護。Struts1、Struts2、Spring MVC、WebWork 等這些都是屬於基於MVC 模式實現的框架
86、 Spring 工作原理
內部最核心的就是IOC 了，動態注入，讓一個對象的創建不用new 了，可以自動的生產，這其實就是利用java 里的反射,反射其實就是在運行時動態的去創建、調用對象，Spring就是在運行時，跟xml Spring 的配置文件來動態的創建對象，和調用對象里的方法的還有一個核心就是AOP 這個就是面向切面編程，可以為某一類對象進行監督和控制（也就是在調用這類對象的具體方法的前后去調用你指定的模塊）從而達到對一個模塊擴充的功能。這些都是通過配置類達到的
Spring 目的：
就是讓對象與對象（模塊與模塊）之間的關系沒有通過代碼來關聯，都是通過配置類說明管理的（Spring 根據這些配置內部通過反射去動態的組裝對象）要記住：Spring 是一個容器，凡是在容器里的對象才會有Spring 所提供的這些服務和功能
87、 Hibernate 中離線查詢與在線查詢的區別
Criteria 和DetachedCriteria 的主要區別在於創建的形式不一樣， Criteria 是在線的，所以它是由Hibernate Session 進行創建的；而DetachedCriteria 是離線的，創建時無需Session，DetachedCriteria 提供了2 個靜態方法forClass(Class) 或forEntityName(Name)進行DetachedCriteria 實例的創建。
88、 Struts2 實現攔截器的原理？
攔截器是AOP 中的概念，它本身是一段代碼，可以通過定義“織入點”，來指定攔截器的代碼在“織入點”的前后執行，從而起到攔截的作用。而Struts2 的Interceptor，其攔截的對象是Action 代碼，可以定義在Action 代碼之前或者之后執行攔截器的代碼。
1. 整個結構就如同一個堆棧，除了Action 以外，堆棧中的其他元素是Interceptor
2. Action 位於堆棧的底部。由於堆棧"先進后出"的特性，而這些都是圍繞着Action 的，當我們請求Action 時，必須首先把位於Action 上端的Interceptor 拿出來執行。
89、 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 中的配置找到對應的返回結果。返回結果通常是（但不總是，也可能是另外的一個Action 鏈）一個需要被表示的JSP 或者FreeMarker 的模版。在表示的過程中可以使用Struts2 框架中繼承的標簽。在這個過程中需要涉及到ActionMapper
90、 簡述spring 的事務傳播行為和隔離級別
spring 的事務傳播行為：
Spring 在TransactionDefinition 接口中規定了7 種類型的事務傳播行為，它們規定了事務方法和事務方法發生嵌套調用時事務如何進行傳播：PROPAGATION_REQUIRED：如果當前沒有事務，就新建一個事務，如果已經存在一個事務中，加入到這個事務中。這是最常見的選擇。PROPAGATION_SUPPORTS：支持當前事務，如果當前沒有事務，就以非事務方式執行。PROPAGATION_MANDATORY：使用當前的事務，如果當前沒有事務，就拋出異常。PROPAGATION_REQUIRES_NEW：新建事務，如果當前存在事務，把當前事務掛起。PROPAGATION_NOT_SUPPORTED：以非事務方式執行操作，如果當前存在事務，就把當前事務掛起。PROPAGATION_NEVER：以非事務方式執行，如果當前存在事務，則拋出異常。PROPAGATION_NESTED：如果當前存在事務，則在嵌套事務內執行。如果當前沒有事務，則執行與PROPAGATION_REQUIRED 類似的操作。
Spring 的隔離級別
1、Serializable：最嚴格的級別，事務串行執行，資源消耗最大；
2、REPEATABLE READ：保證了一個事務不會修改已經由另一個事務讀取但未提交（回滾）的數據。避免了“臟讀取”和“不可重復讀取”的情況，但是帶來了更多的性能損失。
3、READ COMMITTED:大多數主流數據庫的默認事務等級，保證了一個事務不會讀到另一個並行事務已修改但未提交的數據，避免了“臟讀取”。該級別適用於大多數系統。
4、Read Uncommitted：保證了讀取過程中不會讀取到非法數據。
91、 Ibatis 框架和Hibernate 框架各有什么特點？
92、 為什么要用ORM? 和JDBC 有何不一樣?
orm 是一種思想，就是把object 對象轉變成數據庫中的記錄，或者把數據庫中的記錄轉變成object 對象，我們可以用jdbc 來實現這種思想，orm 的思想本質就是建立是JDBC 上，對JDBC 的一種封裝，這種封裝可以省去了直接使用jdbc 的繁瑣細節，提高了開發效率，現在用的較多的ORM 工具很多，一般我們公司采用的ORM 框架主要有hibernate 和MyBatis。當然也聽說一些其他orm 工具，如toplink,ojb 等。
93、 談談你對Spring AOP 思想的理解。
【參考答案】
AOP（Aspect-OrientedProgramming，面向方面編程），可以說是OOP（Object-OrientedPrograming，面向對象編程）的補充和完善。OOP 引入封裝、繼承和多態性等概念來建立一種對象層次結構，用以模擬公共行為的一個集合。當我們需要為分散的對象引入公共行為的時候，OOP 則顯得無能為力。也就是說，OOP 允許你定義從上到下的關系，但並不適合定義從左到右的關系。例如日志功能，日志代碼往往水平地散布在所有對象層次中，而與它所散布到的對象的核心功能毫無關系。對於其他類型的代碼，如安全性、異常處理和透明的持續性也是如此。這種散布在各處的無關的代碼被稱為橫切（cross-cutting）代碼，在OOP 設計中，它導致了大量代碼的重復，而不利於各個模塊的重用。而AOP 技術則恰恰相反，它利用一種稱為“橫切”的技術，剖解開封裝的對象內部，並將那些影響了多個類的公共行為封裝到一個可重用模塊，並將其名為“Aspect”，即方面。所謂“方面”，簡單地說，就是將那些與業務無關，卻為業務模塊所共同調用的邏輯或責任封裝起來，便於減少系統的重復代碼，降低模塊間的耦合度，並有利於未來的可操作性和可維護性。AOP 代表的是一個橫向的關系，如果說“對象”是一個空心的圓柱體，其中封裝的是對象的屬性和行為；那么面向方面編程的方法，就仿佛一把利刃，將這些空心圓柱體剖開，以獲得其內部的消息。而剖開的切面，也就是所謂的“方面”了。然后它又以巧奪天功的妙手將這些剖開的切面復原，不留痕跡。使用“橫切”技術，AOP 把軟件系統分為兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關系不大的部分是橫切關注點。橫切關注點的一個特點是，他們經常發生在核心關注點的多處，而各處都基本相似。比如權限認證、日志、事務處理。Aop 的作用在於分離系統中的各種關注點，將核心關注點和橫切關注點分離開來。實現AOP 的技術，主要分為兩大類：一是采用動態代理技術，利用截取消息的方式，對該消息進行裝飾，以取代原有對象行為的執行；二是采用靜態織入的方式，引入特定的語法創建“方面”，從而使得編譯器可以在編譯期間織入有關“方面”的代碼。
94、 談談你對Spring 的理解。
1.Spring 實現了工廠模式的工廠類（在這里有必要解釋清楚什么是工廠模式），這個類名為BeanFactory （ 實際上是一個接口）， 在程序中通常BeanFactory 的子類
ApplicationContext。Spring 相當於一個大的工廠類，在其配置文件中通過<bean>元素配置用於創建實例對象的類名和實例對象的屬性。
2. Spring 提供了對IOC 良好支持，IOC 是一種編程思想，是一種架構藝術，利用這種思想可以很好地實現模塊之間的解耦。IOC 也稱為DI（Depency Injection）。
3. Spring 提供了對AOP 技術的良好封裝， AOP 稱為面向切面編程，就是系統中有很多各不相干的類的方法，在這些眾多方法中要加入某種系統功能的代碼，例如，加入日志，加入權限判斷，加入異常處理，這種應用稱為AOP。實現AOP 功能采用的是代理技術，客戶端程序不再調用目標，而調用代理類，代理類與目標類對外具有相同的方法聲明，有兩種方式可以實現相同的方法聲明，一是實現相同的接口，二是作為目標的子類在，JDK 中采用Proxy類產生動態代理的方式為某個接口生成實現類，如果要為某個類生成子類，則可以用CGLI B。在生成的代理類的方法中加入系統功能和調用目標類的相應方法，系統功能的代理以Advice 對象進行提供，顯然要創建出代理對象，至少需要目標類和Advice 類。
95、 說說struts1 與struts2 的區別。
1) Servlet 依賴性
由於Action 在被調用時,HttpServletRequest 和HttpServletResponse 被傳遞到execute()方法中,Struts1中的Action 對Servlet 的API 是有依賴性的.但如果在Struts2中,Action 就不會對容器有依賴了,因為Action 是由簡單的POJO 組成的.在Struts2中,servlet 上下文以簡單的Map 的形式表現出來,這使得Action 可以得到獨立的測試.如果需要,Struts2也可以訪問原始的請求與響應。不過,其他的框架元素減少或排除直接訪問HttpServetRequest 或HttpServletResponse 的必要。
2) Action 類
使用抽象類而不是接口設計是Struts1設計上的問題,這已經在Struts2中得到了解決.Struts1中的Action 類需要繼承框架中依賴的抽象基礎類.但在Struts2中,Action 類可能會也可能不會實現接口來啟用可選的或者自定義的服務.在Struts2中,Action 是不會依賴於容器的,因為它是由簡單的POJO 組成的.Struts2提供了一個基礎的ActionSupport 類來實現一些常用的接口。盡管這樣,Action 接口仍然不是必須要繼承的,任何含有execute 方法的POJO 對象都可以當作Action 對象來用。
3) 驗證
Struts1與Struts2都支持通過validate 方法的手動驗證.Struts1使用ActionForm 中的validate 方法或者通過擴展Commons Validator 來進行校驗.然而,Struts2支持通過Validate 方法與Xwork 校驗框架的手動驗證. Xwork 框架支持驗證鏈到子屬性----使用為屬性類文件和校驗上下文定義的驗證.
4) 線程模型
在Struts1中,Action 資源一定是線程安全或者同步的.所以Action 是singletons 並且線程安全的,一定只有一個Action 類的實例處理該Action 的所有請求,singleton 策略限制了Struts1的Action 所能完成的,並且需要更加謹慎的開發.但是在Struts2中,Action 對象對每一個請求都生成實例,所以在Struts2中不存在線程安全的問題。
5) 易測性
測試Struts1的程序會有些復雜.測試Struts1 Action 的主要它依賴容器。但是在Struts2中,Action 可以經由創建Action 的實例,設置屬性和調用方法來得到測試。Struts2中的測試是很簡單的，不依賴於容器。
6) 獲取輸入
Struts1使用ActionForm 來捕獲輸入，而且所有的ActionForm 需要繼承一個框架依賴的基類.由於JavaBean 不能當作ActionForm 來用,開發人員不得不創建冗繁的類來獲取輸入.不過Struts2使用Action 屬性(例如輸入屬性不依賴於底層框架)這避免了需要創建第二個輸入對象,從此冗繁減少了.此外在Struts2中,Action 的屬性可以通過標簽在web 頁面中得到訪問，POJO 表單對象和POJO Action.甚至富對象類型,包括業務或域對象,都可以被當作輸入/輸出對象來使用。
7) 表達式語言
Struts1與JSTL 整合,所以它使用JSTL 表達式語言.Struts1的表達式語言含有遍歷圖表的基礎對象,但是在集合和索引屬性的支持上表現不好.Struts2同樣支持JSTL,但是它也支持一種更強大且靈活的表達式語言----“對象圖標記語言”(OGNL)
8) 將綁定值到視圖中
在視圖層,Struts1使用標准的JSP 來綁定對象(在模型層被處理的)到頁面上下文來進行訪問.然而Struts2使用一種叫做值棧的技術,這使得標簽可以訪問值而不需將視圖與正在呈遞的對象類型連接起來.值棧允許重用一些屬性名相同但類型不同的視圖類型.
9) 類型轉換
通常Struts1的ActionForm 屬性都是String 型的。Struts1使用Commons-Beanutils進行類型轉換，這些針對每一個類的類型轉換無法為每一個實例配置。然而Struts2使用OGNL 來進行類型轉換.框架包含了針對基礎類型,常見對象類型與原始類型的轉換器。
10) Action 的生存周期
Struts1支持對每一個模塊的請求處理器的分離(生命周期),但是同一模塊下的所有Action 必須共享相同的生命周期。Struts2支持通過攔截器棧為每一個Action 創建不同的生命周期.自定義棧可以視需要對不同的Action 使用.
96、 簡述Hibernate 和JDBC 的優缺點? 如何書寫一個one to many 配置文件
1、封裝了jdbc，簡化了很多重復性代碼。
2、簡化了DAO 層編碼工作，使開發更對象化了。
3、移植性好，支持各種數據庫，如果換個數據庫只要在配置文件中變換配置就可以了，不用改變hibernate 代碼。
4、支持透明持久化，因為hibernate 操作的是純粹的（pojo）java 類，沒有實現任何接口，沒有侵入性。
97、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置?
98、 hibernate 的inverse 屬性的作用?
在Hibernate 中，術語inverse 是反轉的意思，在關聯關系中，inverse="false"為主控方，由主控方負責維護對象的關聯關系，如果設為主控方對象，主控對象更新，則負責更新另一方對象更新。
99、 Spring 的依賴注入是什么意思? 給一個Bean 的message 屬性, 字符串類型, 注入值為"Hello" 的XML 配置文件該怎么寫?
依賴注入(Dependency Injection)和控制反轉(Inversion of Control)是同一個概念。具體含義是：當某一個Java 類，需要另一個Java 類的協助時，在傳統的程序設計過程中，通常由當前類（調用者）來創建被調用者的實例，然后使用被調用者的方法。但在Spring 里，創建被調用者的工作不再由調用者來完成，而是由其它類（往往是工廠類）或容器（Spring IOC容器）完成，當前調用者從其它類或容器中來獲取被調用者的實例，這種方式稱為控制反轉;創建被調用者實例的工作通常由Spring 容器來完成，然后注入調用者，因此也稱為依賴注入，這是Spring 的一種編程思想的體現。依賴注入在設計模式也體現得非常多，比如說工廠模式和構建模式，這種就是一個依賴
注入的實現
<bean id="helloBean" class="com.spring.demo.HelloWorld">
<property name="msg" value="Hello!"/>
</bean>
100、 JDO 是什么?
JDO 是Java 對象持久化的新的規范，為java data object 的簡稱,也是一個用於存取某種數據倉庫中的對象的標准化API。JDO 提供了透明的對象存儲，因此對開發人員來說，存儲數據對象完全不需要額外的代碼（如JDBC API 的使用）。這些繁瑣的例行工作已經轉移到JDO 產品提供商身上，使開發人員解脫出來，從而集中時間和精力在業務邏輯上。另外，JDO很靈活，因為它可以在任何數據底層上運行。JDBC 只是面向關系數據庫（RDBMS）JDO更通用，提供到任何數據底層的存儲功能，比如關系數據庫、文件、XML 以及對象數據庫（ODBMS）等等，使得應用可移植性更強。
101、 Spring 與EJB 的區別？
1) 提供商無關性
EJB 3.0 是一個被設計為對提供商沒有依賴性的開放的標准。EJB 3.0 規范由企業JAVA社區的主流開源組織和廠商共同編寫和支持的。EJB 3.0 框架使開發者的應用程序實現可以獨立於應用服務器。而Spring 一直是一個非標准的技術，盡管你在任何應用服務器都上可以使用Spring 框架，但基於Spring 的應用仍然被限制於Spring 本身和在你的應用中使用到的Spring 提供的各種特別服務。
2) 服務整合
Spring 框架是建立在應用服務器和服務庫之上，它的服務整合代碼（如數據訪問模板和Helper 類）是基於框架的，並暴露給應用開發者。相反，EJB 3.0 框架是緊密整合到應用服務器中的，它的服務整合代碼是封裝在一個標准的接口下的。
3) 服務聚合的靈活性
由於Spring 中的服務整合代碼是作為編程接口暴露給應用開發者的，因此開發人員可以根據需要來聚合多個服務。這個特性使你可以集成一個你自己的“輕量”級應用服務器。通常，EJB 3.0 應用服務器不提供給開發者這種按照你的需要來選擇服務的靈活性。大多數情況，你會得到一系列已經預先打包好的特性，其中有些你可能是不需要的。
4) 聲明式服務
EJB 3.0 和Spring 都將運行時服務（如事務管理、安全、日志、消息、和信息服務）連接給應用程序。由於這些服務同應用程序的業務邏輯並不是直接相關的，因此，它們不被應用程序本身來管理。相反，這些服務被服務容器（如EJB 3.0 和Spring）以不可見的方式在運行時提供給應用程序。開發人員（或系統管理員）通過配置來告訴容器什么時候，以怎樣的方式來應用這些服務。
5) 注射依賴
Spring 和EJB 3.0 都提供了大量的DI 模式支持。但是，它們之間也有着根本的不同。Spring 支持了通常意義上的但是復雜的基於XML 配置文件的注射依賴API；EJB 3.0 支持的注射大多數通用服務對象（如，EJB 和容器對象）和JNDI 對象，它通過簡單的JAVA 注解來完成。
102、 SSH 框架的優缺點。
1．struts 第一個優點應該是實現了MVC。對Servlet 依賴減少，低侵入式的設計
2．Action 線程安全的設計
3．功能強大的OGNL 表達式使用。
4．支持多種復合視圖，表現層的使用也多樣化，像JSP\freeMarker\Velocity。
5．攔截器的應用，實現了AOP 的思想，方便重用與擴展
6．自動類型轉換功能。
7．相對低粗度的數據驗證功能
Struts 缺點：
Struts2 中Action 中取得從jsp 中傳過來的參數時，如果頁面過於復雜，會造成對象臃腫。
Spring 優點：
1、非常優秀的輕量級，低侵入式的框架。
2、IOC 的容器周期式的管理，降低組件的偶合。
3、對其它容器有非常好的支持，像對持久層的Hibernate、Ibaits、TOP Link等。
Spring 缺點：
1．Web 層的MVC 框架單過於單薄，對頁面框架的支持，跟其它框架還有很大的差距。
2．不是一站式解決方案。
3．使用了反射來管理其容器中的bean，在程序中增大了內存和運行計算的時間。
4．部分組件功能還有待完善
Hibernate 的優點：
1、非常好的ORM 的框架，在MVC 的切分和JDBC 的封裝上做的很好。
缺點：
1、對復雜查詢，多變的查詢，完成起來有難度。
2、自動化程序高，改寫靈活性不夠。
2、緩存不是太高效，所以有些企業單獨會選擇緩存框架或者棄用Hibernate 的原因之一。
103、 Spring 有哪幾種注入方式？
3 種方法。構造屬入、屬性注入、接口注入
104、 Spring MVC 工作機制及為什么要用?
1) 客戶端所有的請求都提交給DispatcherServlet,它會委托應用系統的其他模塊負責負責對請求進行真正的處理工作。
2) DispatcherServlet 查詢一個或多個HandlerMapping,找到處理請求的Controller.
3) DispatcherServlet 請請求提交到目標Controller
4) Controller 進行業務邏輯處理后，會返回一個ModelAndView
5) Dispathcher 查詢一個或多個ViewResolver 視圖解析器,找到ModelAndView 對象指定的視圖對象
6) 視圖對象負責渲染返回給客戶端。
105、 spring 中常用的幾種advice
BeforeAdvice （前織入）、AfterAdvice （后織入）、ArroundAdvice （前后織入）ThrowAdvice （異常織入）
106、 Spring 中bean 的配置scope 表示什么含義？可以有哪幾種取值。
【參考答案】
scope 表示Bean 的生命周期或者叫Bean 的作用域。scope 的值有兩個：
1、singleton，為單例屬性，即Spring IoC 容器只會創建該bean 的唯一一個實例，這也是默認的。
2、prototype 為原型屬性，即每一次請求都會產生一個新的bean 實例。
107、 Hibernate 對象有幾種狀態？如何轉換
共3 種狀態，分別是：Transient 狀態（瞬時）、Persient 狀態（持久）、Detached（脫管狀態）狀態。
108、 spring 中OpenSessionInViewFilter 作用什么的，解決了什么問題
解決Hibernate 的Session 的關閉與開啟問題。
SSH 整合問題：Hibernate 允許對關聯對象、屬性進行延遲加載，但是必須保證延遲加載的操作限於同一個Hibernate Session 范圍之內進行。如果Service 層返回一個啟用了延遲加載功能的領域對象給Web 層，當Web 層訪問到那些需要延遲加載的數據時，由於加載領域對象的Hibernate Session 已經關閉，這些導致延遲加載數據的訪問異常。而Spring為我們提供的OpenSessionInViewFilter 過濾器為我們很好的解決了這個問題。OpenSessionInViewFilter 的主要功能是用來把一個Hibernate Session 和一次完整的請求過程對應的線程相綁定，允許在事務提交之后延遲加載顯示所需要的對象。實現"Open Session in View"的模式
109、 hibernate 有哪五個核心接口。
Configuration 接口，SessionFactory 接口，Session 接口，Transaction 接口，Query 和Criteria接口
110、 Hibernate 中有幾種關系映射
主要有單向一對一、單向一對多、單向多對一、單向多對多、雙向一對一、雙向一對多、雙向多對多。
111、 介紹一下Hibernate 的一級緩存與二級緩存。
緩存就是把以前從數據庫中查詢出來和使用過的對象保存在內存中（一個數據結構中），這個數據結構通常是或類似Hashmap，當以后要使用某個對象時，先查詢緩存中是否有這個對象，如果有則使用緩存中的對象，如果沒有則去查詢數據庫，並將查詢出來的對象保存在緩存中，以便下次使用。Hibernate 的Session 就是一種緩存，我們通常將之稱為Hibernate的一級緩存，當想使用session 從數據庫中查詢出一個對象時，Session 也是先從自己內部查看是否存在這個對象，存在則直接返回，不存在才去訪問數據庫，並將查詢的結果保存在自己內部。由於Session 代表一次會話過程，一個Session 與一個數據庫連接相關連，所以Session 最好不要長時間保持打開，通常僅用於一個事務當中，在事務結束時就應關閉。並且Session 是線程不安全的，被多個線程共享時容易出現問題。通常只有那種全局意義上的緩存才是真正的緩存應用，才有較大的緩存價值，因此，Hibernate 的Session 這一級緩存的緩存作用並不明顯，應用價值不大。Hibernate 的二級緩存就是要為Hibernate 配置一種全局緩存，讓多個線程和多個事務都可以共享這個緩存。一般我們叫它sessionFactory 緩存，也叫進程級的緩存，使用第3 方插件實現的，也值緩存實體，生命周期和sessionFactory 一致，可以進行管理。
二級緩存具體實現：
首先配置第3 放插件，我們用的是EHCache，在hibernate.cfg.xml 文件中加入<propertyname="hibernate.cache.user_second_level_cache">true</property>
在映射中也要顯示的調用，<cacheusage="read-only"/>二級緩存之查詢緩存：對普通屬性進行緩存。如果關聯的表發生了修改，那么查詢緩存的生命周期也結束了。在程序中必須手動啟用查詢緩存：query.setCacheable(true);
112、 如何在WEB 里面配置SPRING
主要配置Spring Web 監聽器
113、 Hibernate 中的Cascade 屬性有什么作用？
cascade 屬性的作用是描述關聯對象進行操作時的級聯特性。可以有以下幾種取值：
all : 所有情況下均進行關聯操作。
save-update：(級聯保存) 表明保存或更新當前對象時會級聯保存或更新他所關聯的對象。
none：所有情況下均不進行關聯操作。這是默認值。
delete ：(級聯刪除) 級聯刪除所關聯的對象。
all-delete-orphan：自動刪除不再和父對象關聯的子對象。並且，在出現上面兩種情況時執行上面兩種的功能，可以說是一個全自動的屬性值。
114、 Struts1 優缺點
優點：
1) 實現MVC 模式，結構清晰,使開發者只關注業務邏輯的實現.
2) 有豐富的tag 可以用,Struts 的標記庫(Taglib)，如能靈活動用，則能大大提高開發效率
3) 頁面導航
4) 使系統的脈絡更加清晰。通過一個配置文件，即可把握整個系統各部分之間的聯系，這對於后期的維護有着莫大的好處。尤其是當另一批開發者接手這個項目時，這種優勢體現得更加明顯。
5) 提供Exception 處理機制。
6) 數據庫鏈接池管理。
7) 支持I18N (國際化)
缺點
1) 轉到展示層時，需要配置forward，如果有十個展示層的jsp，需要配置十次struts，而且還不包括有時候目錄、文件變更，需要重新修改forward，注意，每
2) Struts 的Action 必需是thread－safe 方式，它僅僅允許一個實例去處理所有的請求。所以action 用到的所有的資源都必需統一同步，這個就引起了線程安全的問題。
3) 測試不方便. Struts 的每個Action 都同Web 層耦合在一起，這樣它的測試依賴於Web容器，單元測試也很難實現
4) 類型的轉換. Struts 的FormBean 把所有的數據都作為String 類型，它可以使用工具Commons-Beanutils 進行類型轉化。但它的轉化都是在Class 級別，而且轉化的類型是不可配置的。
5) 對Servlet 的依賴性過強. Struts 處理Action 時必需要依賴ServletRequest 和ServletResponse，所有它擺脫不了Servlet 容器。
6) 前端表達式語言方面集成了JSTL，所以它主要使用JSTL 的表達式語言來獲取數據。可是JSTL 的表達式語言在Collection 和索引屬性方面處理顯得很弱。
7) 對Action 執行的控制困難. Struts 創建一個Action，如果想控制它的執行順序將會非常困難。
8) 對Action 執行前和后的處理. Struts 處理Action 的時候是基於class 的hierarchies，很難在action 處理前和后進行操作。
9) 對事件支持不夠. 在struts 中， 實際是一個表單Form 對應一個Action 類(或DispatchAction)，換一句話說：在Struts 中實際是一個表單只能對應一個事件。
115、 整合spring 與struts1 的方法，那種最好，為什么？
1.第一種方法:
Struts 的Action 繼承Spring 的ActionSupport 類，並在Action 中獲取Spring 的ApplicationContext。這是最簡單的一種整合方式，但有三個缺點：第一，Struts 與Spring緊密耦合，不能改換到其他IoC 容器；第二，難以使用Spring AOP 特性；第三，對於需要使用DispatchAction 的Struts 應用無能為力。
2.第二種方法:
在Struts 的配置文件中，以Spring 的DelegatingRequestProcessor 類代替Struts的RequestProcessor 類， 並在Spring 的配置文件中定義與Struts 配置文件中<action-mappings>對應的bean，從而將Struts 的Action 與Spring 分開，並把Struts 的動作置於Spring 的控制之下。這種整合方式的優點是將不再依賴Spring 這個特定的IoC容器，但必須依賴Struts 的RequestProcessor 類。
3.第三種方法:
通過Spring 的DelegatingActionProxy 類代理Struts 的動作，即在Struts 配置文件中，定義<action-mappings>的type 屬性全部改為DelegatingActionProxy，而不是具體的類名，並在Spring 配置文件中定義與Struts 動作映射對應的bean，從而將Struts 的Action與Spring 分開，並把Struts 的動作置於Spring 的控制之下。無疑，這是最靈活的一種整合方式。
116、 Struts1.2 的工作原理
【參考答案】
1.ActionServlet 核心控制器會攔截所有*.do 的請求
2.從struts-config.xml 中找到用戶請求的Action
3.通過struts-config.xml 中的配置再去找這個Action 對應的ActionForm,並實例化
4.把用戶填寫的數據自動填充到ActionForm 中(調用ActionForm 中的setXX()方法填充)
5.同時把ActionForm 放入到指定的范圍中（request，session）
6.然后把請求轉發給Action
7.Action 獲取ActionForm 中的值然后調用業務邏輯層實現功能
8.在通過ActionMapping 查找Actionforward 實現轉發;
117、 談談Struts1 中的ActionServlet。
【參考答案】
中心控制器，負責所以請求處理，並根據配置文件，將請求轉到指定Action 執行，並根據Action 的ActionForward 返回，轉到指定視圖。
118、 Struts1.X 中ActionServlet、ActionForm 、Action、ActionMapping 各起什么作用？
【參考答案】
a. Actionservlet 為控制器，接受用戶請求並派發給相應的Action 組件處理；
b. ActionForm 主要用於封裝請求中的數據和簡單驗證
c. Action 組件具體對用戶的請求進行處理
d. ActionMapping 封裝當前用戶請求Action 相關的配置信息
119、 Struts 1 的Action 類與Struts 2 的Action 類區別？
【參考答案】
Struts 1 要求Action 類要擴展自一個抽象基類。Struts 1 的一個共有的問題是面向抽象類編程而不是面向接口編程。Struts 2 的Action 類實現了一個Action 接口，連同其他接口一起實現可選擇和自定義的服務。
Struts 1 Action 類是單例類，因只有一個示例控制所有的請求。
Struts 2 Action 對象每一個請求都實例化對象，所以沒有程安全的問題。
120、 談談你對Struts1 的理解。
【參考答案】
1. struts 是一個按MVC 模式設計的Web 層框架，其實它就是一個大大的servlet，這個Servlet 名為ActionServlet，或是ActionServlet 的子類。我們可以在web.xml 文件中將符合某種特征的所有請求交給這個Servlet 處理，這個Servlet 再參照一個配置文件（通常為/WEB-INF/struts-config.xml）將各個請求分別分配給不同的action 去處理。
2. ActionServlet 把請求交給action 去處理之前，會將請求參數封裝成一個formbean對象（就是一個java 類，這個類中的每個屬性對應一個請求參數）
3.要說明的是， ActionServlet 把formbean 對象傳遞給action 的execute 方法之前，可能會調用formbean 的validate 方法進行校驗，只有校驗通過后才將這個formbean 對象傳遞給action 的execute 方法，否則，它將返回一個錯誤頁面，這個錯誤頁面由input 屬性指定，（看配置文件）作者為什么將這里命名為input 屬性，而不是error 屬性，我們后面結合實際的運行效果進行分析。4.action 執行完后要返回顯示的結果視圖，這個結果視圖是用一個ActionForward 對象來表示的，actionforward 對象通過struts-config.xml 配置文件中的配置關聯到某個jsp頁面，因為程序中使用的是在struts-config.xml 配置文件為jsp 頁面設置的邏輯名，這樣可以實現action 程序代碼與返回的jsp 頁面名稱的解耦
121、 Struts1 中的action 是安全線程么？為什么
【參考答案】
Servlet 是在多線程環境下的。即可能有多個請求發給一個servelt 實例，每個請求是一個線程。struts 下的action 也類似，同樣在多線程環境下。為多線程環境編寫代碼。我們的controller servlet 指揮創建你的Action 類的一個實例，用此實例來服務所有的請求。因此，你必須編寫線程安全的Action 類。遵循與寫線程安全的servlet 同樣的方針。
122、 在Struts1 中actionform 屬於哪一層
【參考答案】
屬於視圖層組件，負責封裝頁面表單數據。
123、 struts 控制器組件的主要包括?
【參考答案】
ActionServlet 組件：充當struts 框架的中央控制器。
RequestProcessor 組件，充當每個子應用模塊的請求處理器
Action 組件，負責處理一項具體的業務。
124、 常見的緩存技術舉例【大唐動力面試題】
【參考答案】
操作系統磁盤緩存->減少磁盤機械操作數據庫緩存->減少文件系統I/O應用程序緩存->減少對數據庫的查詢Web 服務器緩存->減少應用服務器請求客戶端瀏覽器緩存->少對網站的訪問
125、 以Spring 為基礎的J2EE 項目中，一般如何分層？每個層的作用是什么？事務控制放在哪一層？
一般分為持久層（DAO 層）、業務層（Service 層）、控制層、視圖層；事務一般放在業務層，以一個業務作為一個事務分割的最小單位。
126、 EBJ 是基於哪些技術實現的和JavaBean 的區別？
EJB 包括Session Bean、Entity Bean、Message Driven Bean，基於JNDI、RMI、JAT 等技術實現EJB 是一個關於用JAVA 語言開發的可部署的服務器端組件的組件體系結構。它是一個技術協議，能使組件運行於任何應用服務器,專門用來解決商務問題JAVABEANS 是JAVA 類，是由屬性、事件和方法組成的JAVA 組件，它們可以用來組成JAVA 應用程序Java Bean 是可復用的組件，對Java Bean 並沒有嚴格的規范，理論上講，任何一個Java類都可以是一個Bean。但通常情況下，由於Java Bean 是被容器所創建（如Tomcat）的，所以Java Bean 應具有一個無參的構造器，另外，通常Java Bean 還要實現Serializable 接口用於實現Bean 的持久性。Java Bean 實際上相當於微軟COM 模型中的本地進程內COM 組件，它是不能被跨進程訪問的。Enterprise Java Bean 相當於DCOM，即分布式組件。它是基於Java 的遠程方法調用（RMI）技術的，所以EJB 可以被遠程訪問（跨進程、跨計算機）。但EJB 必須被布署在諸如Webspere、WebLogic 這樣的容器中，EJB 客戶從不直接訪問真正的EJB 組件，而是通過其容器訪問。EJB 容器是EJB 組件的代理，EJB 組件由容器所創建和管理，客戶通過容器來訪問真正的EJB 組件。
127、 Webservice 有什么好處?
跨平台的可互操作性跨防火牆的通信應用程序集成軟件和數據重用。
128、 什么是事物處理，J2EE 提供哪兩種事物處理方式
事務（Transaction）是數據庫管理系統提供的基本功能之一，可以把完成用戶一個特定工作的一組操作看作是一個不可拆分的工作單元，所以事務也就是作業或任務。
JDBC：支持單一數據庫連接事務JTA：支持分布式事務
129、 WEB SERVICE 的理解【大唐動力面試題】
Web Service 主要是為了使原來各孤立的站點之間的信息能夠相互通信、共享而提出的一種接口。Web Service 所使用的是Internet 上統一、開放的標准，如HTTP、XML、SOAP（簡單對象訪問協議）、WSDL 等，所以Web Service 可以在任何支持這些標准的環境（Windows,Linux）中使用。注：SOAP 協議（Simple Object Access Protocal,簡單對象訪問協議）,它是一個用於分散和分布式環境下網絡信息交換的基於XML 的通訊協議。在此協議下，軟件組件或應用程序能夠通過標准的HTTP 協議進行通訊。它的設計目標就是簡單性和擴展性，這有助於大量異構程序和平台之間的互操作性，從而使存在的應用程序能夠被廣泛的用戶訪問。
130、 J2EE 系統訪問速度慢.從哪些方面可以優化
J2EE 性能的優化包括很多方面的，要達到一個性能優良的系統，除了關注代碼之外，還應該根據系統實際的運行情況，從服務器軟硬件環境、集群技術、系統構架設計、系統部署環境、數據結構、算法設計等方面綜合考慮來優化。一般程序級別的優化首先考慮做數據緩存，數據庫方面全做表的切割、數據分區、索引等這些方面來加快對數據的訪問。
131、 說說你所知道的應用服務器？
BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss
四、 Spring
132、 對Spring理解與作用
Spring是一個開源的控制反轉和面向切面的容器框架。
Spring包含依賴注入容器、AOP實現、DAO/ORM支持、Web集成等。
解耦合、提供各種服務（事務管理、消息服務）、單例模式支持、AOP技術可以很容易的實現權限控制、監控等、很多輔助類加快應用開發、對各大主流的應用框架提供了集成支持。
133、 在spring中有幾種事務管理，分別是什么?
代碼管理的事務處理、容器管理的事務處理；
並不直接管理事務、將事務管理委托給事務管理器；
聲明式事務
傳播行為、隔離級別
134、 JDK動態代理學習
動態生成代理、可以和任何實現接口的目標對象融合
135、 Spring與Struts集成
把業務對象、Action納入spring的ioc容器，
136、 怎么理解OpenSessionInviewFilter？
save完一個對象后，由於有這個過濾器，spring會把這個連接放到線程池里面，而不是馬上關閉。當需要延遲加載的時候，spring會從線程池里面取出那個session完成加載的動作，當確定這個session確實不再需要的時候，spring才會close掉這個session
137、 講講spring中的事務，如何支持事務的，事務的7大傳播屬性,spring mvc 作為控制器層需要注意什么
有編程型（事務量比較少）與聲明型事務(aop)
1 不同平台下的有不同事務管理器
2 加功能的代碼寫在通知類中，spring已經提供了環繞通知，事務攔截器TransactionInteceptor
3 專門提供了一個類TransactionProxyFactoryBean生成事務代理類，該類內部持有事務攔截器TransactionInteceptor，只需注入
事務管理器與目標類即可
事務的7大傳播屬性 required(有就使用沒有就建立一個) required_new(有沒有都創建一個) support(支持) not_suppot(不支持) never(不支持，有事務管理器還報錯) 嵌套
spring mvc的配置文件與ContextLoaderListener加載的包含service層 dao層實例的配置文件最好分開
138、 什么是aop 說說AOP的一些概念概念和術語 aop好處 項目中怎么用的
aop aspect oriedted program 面向切面(方面)編程，在不改變源代碼的基礎上給目標類加上一些非業務性功能,如事務，日志，權限,需要給目標類生成代理類，生成代理類的技術有面向接口的jdk動態代理以及面向具體類的cglib技術（jdk通過接口實現,cglib通過繼承來實現）,加功能的代碼寫在通知類中，有五種 通知類，前置通知
后置通知，環繞通知，異常通知，最終通知，給代理類注入目標類和通知類，客戶操縱的是代理類,想更精確的切入，使用切入點，例如
如果想把功能切入到哪些包下的哪些類的哪些方法需要aspectJ切入點表達式. exucution( * com.lxit..*.add(..) ) //修飾符? 返回值 類全名.方法名(..) 異常?
連接點是某個方法的調用或者異常的拋出，連接點的集合就是切入點
aop好處 源代碼的無關性,低侵入式設計
項目中怎么用
1 事務 2 日志 3 權限
1 事務
1 配置事務管理器，不同的平台有不同的事務管理器，如DataSourceTransactionManager,HibernateTransactionManager,JPATransactionManager
2 使用<tx:annotation-driver transaction-manager="事務管理器"引入事務管理器
3 在需要事務的類或方法上使用@Transactionnal
日志
struts2的攔截器就是一個環繞通知 我們可以把消息通知寫在invoke前后，怎么就是aop了 aop 是沒有修改源代碼的情況下加功能 加功能的代碼寫在通知類中
五、 SpringMVC
139、 spring 如何實現mvc 請求處理流程
view發送請求---- 核心控制器DispathcerServlet--- hangldermapping（映射器）（類型轉換，數據封轉，數據檢驗，異常處理等）
-----------業務控制器-調用m層----
modelAndview(String)-----視圖解析器（內部資源視圖解析器）-- -視圖層使用標簽國際化展示數據
1 映射器 hangldermapping 定位action,使用@requestmapping
2 類型轉換
1 實現convert接口
2 定義類型轉化器服務工廠類FormattingConversionServiceFactoryBean ,注入我們的類型轉換器
3 使用<mvc:anotation-driver 引入類型轉換器
3 數據封轉 參數封轉 使用對象或者是model
4 數據檢驗 jsr303校驗
1 引入jsr303的校驗實現者，如hibernate, <mvc:anotation-driver 標簽自動引入
2 在參數對象上標上@valid注解，校驗錯誤放在緊跟對象后的bindResult，
之后根據bindResult是否有校驗錯誤進行相應的跳轉
3 在校驗的實體類中編寫jsr303的注解校驗 如notnull length eamli
5 值綁定到頁面 model
6 視圖解析器---內部資源視圖解析器，xml視圖解析器等，采用鏈式解析
7 國際化
1 定義id為messageSource的bean，注入國際化資源文件基礎名
2 定義LocaleChangeInteceptor攔截器，攔截local參數,使用mvc:interceptors引入攔截器
3 語言環境放到哪里，如session作用域
140、 spring mvc如何執行靜態文件如js文件 css文件 圖片文件
1 <mvc:resources location="/js/" mapping="/js/**"/>
<mvc:annotation-driven/>
141、 springmvc與struts2比較
1 在數據封裝方面 ，spring3mvc方法級別 struts2 類級別 spring3mvc開發效率高於 struts2
2 spring3mvc 注解版基本上是零配置
3 springmvc與spring是一家人，兼容性好
4 struts2 存在安全漏洞
可以通過ongl表達式 格式化硬盤
使用重定向定位到釣魚網站
142、 spring mvc 注解
1 @Controller 標注為spring容器的中的bean 做為c
2 作用域注解 有五大作用域： 原型 單例 request session 全局session
3 @RequestMapping 訪問路徑，可以用在類或者方法上 訪問路徑類/方法
4 @responsebody 返回字符串，一般用於返回json格式
5 @ModelAttribute 放入request作用域
6 @SessionAttributes 值能用在類上
7 @requestParam 主要用於數據封裝時，頁面的參數名與方法參數不一致時
8 @pathVarible 主要用於獲取路徑變量的值
143、 說說spring dao
1 對jdbc進行了封裝,提供了兩大模板技術封裝了jdbc步驟,數據源的實現,行映射器進行記錄與對象的轉換工作,
使用daoSupport方便獲取模板
2 給模板類注入數據源，之后使用模板類的api進行數據操作
六、 MyBatis
144、 .ibatis/mybatis框架的優缺點?
優點: 易於上手和掌握
sql寫在xml里,便於統一管理和優化
解除sql與程序代碼的耦合
提供對象關系映射標簽,支持對象關系組建維護
提供xml標簽,支持編寫動態sql
缺點: 可讀性低,調試非常困難,非常受限,無法像jdbc那樣在代碼里根據邏輯實現復雜動態sql拼接
145、 ibatis核心類的作用;MyBatis核心類的作用?
ibatis:
SqlMapClientBuilder: 加載配置文件，返回一個會話
SqlMapClient: 具體的會話
SqlSession: 對數據的增刪查改
SqlMapSession: 進行數據庫操作
SqlSessionManager: 創建SqlSesstion的對象
SqlMapTransactionManager: 定義事務管理功能
Mybatis:
SqlSessionFactory 每個MyBatis應用的核心
146、 mybatis/ibatis跟hibernate的比較;
Hibernate是全自動化的,只要配置映射文件,可以為我們動態的生成sql
ibatis是半自動化的,需要我們手動的編寫sql,ibatis簡單易學
Hibernate比較復雜,ibatis可以細粒度的優化,而Hibernate是根據映射文件進行優化
147、 ibatis的工作流程或運行原理?
1.在sqlMapConfig的配置文件中進行數據庫連接的配置。
2.在sqlMapConfig的xml配置文件中引用sqlMap的xml配置文件。
3.在sqlMap的xml配置文件中進行SQL文件的配置。(文件名稱隨意，一般是javaBean的類名加xml。)
4.通過SqlMapClient生成具體的操作,用來操作sqlMap配置文件中SQL文件的IBATIS對象。
5.SqlMapClient對象提供函數，函數的參數對應替換sqlMap配置文件的id，parameter等屬性，完成SQL文件的執行
148、 Ibatis中#與$的區別？
(1)#號它會將傳進來的數據都當成一個一個字符串,會給數據加一對雙引號,而$號它會將傳進來的數據直接顯示生成到sql中
(2)#號能夠防止sql的注入，而$號無法防止sql的注入
(3)$方式一把用於傳入數據庫對象，比如表名
七、 WebServices
149、 怎么調用webservice
1 wsdl文件地址，根據該文件通過myeclipse webservice視圖進行訪問進而拿到soap協議
2 使用HttpUrlConnection進行網路連接,使用conection中的輸出流發送soap協議,返回值也是一個soap協議，用conection中的輸入流接,進行解析(dom sax stax)
150、 wsdl soap
1 wsdl web service description language 網絡服務描述語言
wsdl 作用
1 提供了， 服務的訪問地址，服務的綁定協議
2 wsdl生成客戶端訪問代碼
3 wsdl 用過myeclipe工具獲取soap協議
wsdl 7大元素
1 servides:服務的集合
2 port:單個服務訪問點
3 porttype:相當於接口
4 operation: 操作 相當接口中的方法
5 message :方法中的參數以及返回值
6 type:數據類型
7 binding:協議
2 soap
簡單對象訪問協議 本質上就是xml格式 xml是國際工業標准的數據交換格式，所以會跨平台跨語言，其格式如下
信封
信封頭 (加密的時候用到)
信封body
方法
參數
151、 你如何開發webservice
有一個場景，你的項目中有一個類中的某方法，公司有5個項目都要調用，最好的方式暴露成webservice
用的cxf技術，與spring結合較好，使用jdk中的jax-ws語法,那么如何把spring容器中的bean暴露成webservice
1 cxf技術 它使用 jax-ws的語法
2 接口類 使用@WebService注解 實現類 使用@WebService注解指定接口
3 配置CXFServlet,使得服務器啟動時發布webservice
4 在spring配置文件中 導入cxf支持spring的3個文件
5 配置jaxws命名空間endpoint 發布spring中的bean,主要指定實現類,即#bean的id,以及地址
<cxf:endpoint id="helloWorld" implementor="#cal" address="/xxx" />
152、 項目用了webservice干什么
1 公共模塊 數據交換 數據中心 五表權限
2 流程審批
3 便民服務 天氣預報 手機號碼歸屬地查詢
webservice安全 以及大數據量
大數據量 在cxf框架中
1 快速信息集 @FastInfoset 2 對返回的數據進行壓縮 @GZIP
2 數據緩存，它需要編寫代碼來實現
實際使用中，多線程下載文件的方式，webservice把數據打包到壓縮文件，比較本地的文件名與時間，決定是否從遠程服務端下載文件
153、 安全問題：
1 使用攔截器技術，配置用戶名以及密碼，本質上是對soap-header信封頭進行加密
服務端: 發布spring中的bean成webservice，配置inInterceptors 配置攔截器WSS4JInInterceptor,注入服務端密碼驗證類,該類實現了CallbackHandler
客戶端：配置outInterceptors，配置out攔截器WSS4JOutInterceptor,注入客戶端驗證類
密碼驗證類實現 CallbackHandler
2 帶證ca認證 配置 tomcat https http+Security
soa Service-Oriented Architecture 面向服務架構 WebService是soa一種實現。
154、 ejb
1 ejb是sun公司java的一種規范，webservice是跨語言的
2 webservice 是通過http協議發送soap協議,ejb是jndi訪問，底層協議rmi-iiop
3 可以把ejb暴露成webservice
八、 EJB
九、 DAO
155、 dao是什么及其優點
1 dao data access object 數據訪問對象 持久化層，主要用來進行數據操作的，經常成為dao模式
2 優點
1 數據訪問獨立到了一層，分層 ，易於分工，可重用
2 修改具體的dao層實現類，不會影響到其他層，實現松耦合
3 dao的結構 四大組件
1 doa接口
2 dao實現類
3 pojo(plain old java objecct)類
4 dao定位( 如何獲取實例 spring)
4 常用的dao技術
jdbc spring的dao 以及orm(ibatis mybatis hibernate)
156、 jdbc
1 步驟手寫
1 加載驅動 Class.forName("oralce.jdbc.driver.OracleDriver");
2 獲取數據庫連接 Connection connection=Drivermanager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl","aaa","aaa");
3 創建statement Statement statement= connection.createStatement();
4 執行sql statement.executeQuery(sql);
5 處理ResutlSet結果集---手動轉成javabean
6 關閉 ResutlSet statement Connection
2 3個statement
1 Statement 一邊編譯邊執行
2 PrepareStatement 預編譯，效率高，安全,阻止sql攻擊,支持占位符
3 CallableStatement 調用存儲過程
PrepareStatement繼承Statement，CallableStatement 繼承PrepareStatement
157、 說說spring dao
1 對jdbc進行了封裝,提供了兩大模板技術封裝了jdbc步驟,數據源的實現,行映射器進行記錄與對象的轉換工作,
使用daoSupport方便獲取模板
2 給模板類注入數據源，之后使用模板類的api進行數據操作
158、 orm框架 什么是orm orm比較 與jdbc比較
1 orm object relaction mapping 對象關系映射,解決面向對象與關系數據庫不匹配的技術，對jdbc進行了封裝，
使得我們可以使用面向對象的思維操縱數據庫。使用緩存與懶加載技術提高效率
2 常見的orm框架有ibatis mybatis hibernate
mybatis與hibernate
1 mybatis 半自動需要手動編寫sql, 靈活控制sql,方便sql優化，代碼量增加，不易移植, 也叫sql映射、不方便移植
2 hibernate 全自動，自動生成sql, 方便移植,也叫對象映射、方便移植
3 hibernate 與jdbc
1 hibernate封裝了jdbc,使得我們可以使用面向對象的思維操縱數據庫
2 hibernate 全自動，自動生成sql, 方便移植,也叫對象映射、方便移植
3 jdbc效率最好
159、 ibatis與mybatis比較 # $ %干什么的
1 iBATIS3.0以后到goole公司了，更名為mybatis
2 mybatis增加了接口綁定
3 傳值方式由##---#{} $：解析數據庫的關鍵字 %：模糊查詢
4 mybatis核心類SqlSessionfactory SqlSeession ibatis sqlMapclient
5 使用ognl表達式，體現在動態sql上
6 配置的改變，如別名的配置，mybatis移動到了總配置文件中
160、 hibernate load與get list() 和 iterate() saveOrUpdate與merge
1 load與get
load 支持懶加載，沒找到數據時報異常，get不支持懶加載，沒找到數據時返回null
2 list() 和 iterate()
list:查詢緩存不存在時，一條sql去數據庫把所有數據加載，填充一級緩存，二級緩存
iterate:去數據線加載id,根據id去緩存查詢，如果緩存沒有，以id為條件到數據庫查詢數據，會造成n+1次查詢
由於list或填充緩存，而iterate會使用緩存，因此第一次使用list，之后使用iterate可提高效率
3 saveOrUpdate與merge
1 merge不會使對象變成持久化狀態
2 緩存中存在相同id的實體，saveOrUpdate會報錯，merge會合並
161、 什么是懶加載 懶加載用代理技術實現 如何解決session關閉導致的懶加載問題 解決的方案有缺點嗎
1 懶加載 真正需要數據的時候才向數據庫發送sql,比如調用load方法，不會發出sql,而在加載對象屬性時才發出了sql,實現了數據的延遲加載,get則不然
2 使用openSessionInView模式解決，實則是一個過濾器，保持session一直在view一直打開
1 session范圍擴大，從dao擴展到了其他的層，session所暫用的資源不能得到及時的釋放,效率下降
2 事務擴大了
162、 緩存
1 使用
1 hibernate緩存
一級緩存 內置的 調用session api如(save saveopupdate load等)會hibernate會把實體放入一級緩存 session級別緩存
二級緩存 可配置的 sessionFactory級別緩存,為所有session共享
1 打開二級緩存開關
2 指定哪種緩存 如 EHCache
3 指定哪些實體要放入二級緩存
查詢緩存 ：命中率較低 比較少用
2 ibatis 在映射文件配置Cachemodel
3 mybatis 在映射文件配置Cache，實體類實現序列化
2 優點與缺點
1 減少應用程序對數據庫的訪問次數，提高效率
2 數據量大時導致內存溢出
3 容忍無效的數據（緩存里的數據有可能是過期的），經常修改的數據不適合放入緩存中
3 緩存中配置一些什么東西
<!--
defaultCache:默認的緩存配置信息,如果不加特殊說明,則所有對象按照此配置項處理
maxElementsInMemory:設置了緩存的上限,最多存儲多少個記錄對象
eternal:代表對象是否永不過期
timeToIdleSeconds:最大的發呆時間
timeToLiveSeconds:最大的存活時間
overflowToDisk:是否允許對象被寫入到磁盤
163、 mybatis,hibernate如何開發一對多的案例 過程以及如何配置
o : 一方放多方的集合，多方放一方的實體
r : 多方放一方的id
m :
mybatis: 查詢數據
1 使用嵌套查詢或者嵌套結果
嵌套查詢: 先查詢自己的數據，另外發送一條sql查詢關聯數據，在collection標簽上使用select屬性指定id，如select='xxx',
嵌套結果: 一條sql查詢自己以及關聯數據，結果由mybatis自行封裝,在collection標簽上使用resultMap
2 插入數據 使用動態sql
hibernate ：在set標簽上使用級聯與反轉
1 級聯：主對象做什么，其關聯對象也做同樣的操作
2 反轉 將關聯字段的維護權交給多方，減少update語句
164、 hibernate 實體的3種狀態
1 瞬時狀態 ：剛new出來的對象，與session沒關聯,調用delete方法也會使對象進入瞬時狀
2 持久化狀態:調用session的api，如save saveorupdate,load get進入持久化狀態，屬性的改變在事務提交的時候同步數據庫
3 脫管狀態 ：調用了session的clear或者close evit 都使對象脫離了session的管理，狀態發生改變不會影響到數據庫
165、 hibernate 的原理步驟 核心類
答： 1.讀取配置文件；
2.創建SessionFactory(安全)；
3.創建session(不安全)；
4.開啟事務；
5.進行Crud操作（save,update,saveOrUpdate,load,get方法）；
6.提交事務；
7.關閉session;
8.關閉SessionFactory;
核心類：1.Configuration：讀取配置文件；
2.SessionFactory：通過Configuration的實例創建，是線程安全的；
3.Session：通過SessionFactory的實例創建，線程不安全；
4.Transaction：事務管理
166、 hibernate 的經驗 （如 大數據處理 性能優化 有什么經驗 最佳實踐）
1 當session關閉仍導致懶加載問題，可使用openSessionInView模式來解決
2 sql優化九大原則
3 配置二級緩存EHCache
4 對於內容較大的字段使用懶加載
5 api的正確使用，第一次使用list,之后使用iterbate
6 關聯優化
7 項目上線后把hql的輸出關閉
8 大數據量的處理
摻入大數據
1 分批刷新，清除緩存
2 使用無狀態的session
3 更新 exeuteupdate
查詢： 分頁機制
setFirstresult（起始位置） setMaxResult(一次取幾條)
9 session無法控制數量，導致緩存溢出
10 無法與第三方系統共存，否則緩存無法控制
167、 hibenrate 查詢方式 離線查詢
答：1.hql：適合各種查詢，但是動態條件查詢構造起來很不方便；
2.qbc：適合動態查詢，不適合統計查詢；
3.qbe：只適合簡單的查詢 ；
4.sql：可實現特定數據庫的sql，方便優化，移植性不好；
離線查詢：創建查詢條件（DetachedCriteria）時不需要session，但執行時（getExecutableCriteria）仍需要session
168、 hibernate抓取策略 指的是如何查詢關聯數據 （有關聯實體與關聯集合）
答： join：連接抓取（即嵌套結果）---使用左外連接加載關聯數據，而此時的懶加載會失效；
select：查詢抓取（即嵌套查詢）---另外發送一條select語句抓取當前對象關聯的數據；
subselect：子查詢（即通過in）---先把所有的id查詢出來作為條件后面select語句的條件，使用in找出；
批量抓取 batch-size設置，一次抓幾條
169、 hibernate注解
答：1.@Entity
@Table(name="表名") 標記為持久類映射
2.@Id @GeneratedValue 主鍵生成機制
3.@ElementCollection 集合映射
4.@OneToMany 一對多
5.@ManyToMany 多對多
170、 你了解ejb或者jpa嗎，隨便談一下
ejb3 是一種規范,包含了3種bean
1 實體bean 相當於hibernate中的實體
2 會話bean
1 有狀態的會話bean
每個請求返回的實例不同
2 無狀態的會話bean
每個請求返回的實例相同
3 消息bean
jpa 就是java 持久化api 來源於ejb3 ejb3持久化規范部分,可以不需要容器即可運行，直接運行在j2se平台上,ejb需要ejb容器，
如jboss weblogic等
hibernate 是一種產品，是jpa規范的實現者，jpa規范的實現着還有toplink jboosjpa eclipsejpa
ejb可以用來開發分布式組件，hibernate無法做到，因為它的緩存無法控制
如何調用ejb 使用jndi技術（Java命名目錄接口）
1 創建InintContext ,指定ejb組件的位置以及端口號
2 使用context.lookUp("jndi名字")返回接口代理，強轉成接口，即可調用接口中的方法
Hashtable jndiPro=new Hashtable();
jndiPro.put(Context.URL_PKG_PREFIXES,"org.jboss.ejb.client.naming");
InitialContext context=new InitialContext(jndiPro);
Cal cal=(Cal)context.lookup("ejb:/ejb-sessionbean/CalImpl!com.Cal?stateful");
cal.add(1);
System.out.println(cal.getNum());
中間件：即ejb
表關系（映射）
一對一
任意一方放對方的id 加上唯一性約束
一對多
一方放多方的set集合 多方放一方的實體類 映射文件中 一方set標簽中放onetomany 多方方法manytoone 放一方的id 使用級聯與反轉
多對多
多對多關系存在中間表 中間表由一方維護就行，否則主鍵重復
數據庫多 類多
使用 Hibernate
類少
使用 mybatis
Hibernate遇到的問題
說Hibernate的缺點
session關閉問題
使用連接抓取導致懶加載失效問題
無法與第三方系統共存