Java框架 面試題總結

1、 Struts1.x 4

一、 struts1優缺點,爲何要使用struts1 4

二、 Struts1核心組件 4

三、 Strust1請求處理流程  工做原理 4

四、 Struts1線程安全問題 4

五、 Struts1 它解決了什麼問題？ 4

六、 Struts1的框架的結構是什麼？ 4

七、 struts 1如何實現mvc 5

八、 DispatchAction與動態form 5

九、 爲何要使用動態form 5

2、 Hibernate面試題 5

十、 list，iterate區別 5

十一、 Hibernate 核心接口session介紹 5

十二、 Session接口常見方法 6

1三、 Hibernate操做的對象有三種狀態 7

1四、 Hibernate的檢索策略 7

1五、 Query 中常見方法 8

1六、 Hibernate參數綁定有幾種方式 8

1七、 在Hibernate中什麼是命名查詢 8

1八、 Hibernate優化 8

1九、 什麼是懶加載 懶加載用什麼技術實現，如何解決session關閉致使的懶加載問題 解決的方案有缺點嗎、 9

20、 hibernate核心類 9

2一、 hibernate抓取策略 9

2二、 hibernate 的原理 9

2三、 Hibernate 的session.save()與session.saveOrUpdate()的區別？ 9

2四、 Hibernate 中sedssion.get()與session.load()的區別？ 9

2五、 介紹下hibernate 9

2六、 Hibernate 中的HQL 和criteria 的區別？ 10

2七、 介紹hibernate 延持加載屬性 10

2八、 列舉你接觸過的框架，說明特色和原理 10

2九、 Hibernate 中離線查詢與在線查詢的區別 10

30、 Ibatis 框架和Hibernate 框架各有什麼特色？ 10

3一、 爲何要用ORM? 和JDBC 有何不同? 10

3二、 簡述Hibernate 和JDBC 的優缺點? 10

3三、 如何書寫一個one-to-many 配置文件 10

3四、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置? 10

3五、 hibernate 的inverse 屬性的做用? 11

3六、 Hibernate 對象有幾種狀態？如何轉換 11

3七、 Hibernate 中有幾種關係映射 11

3八、 介紹一下Hibernate 的一級緩存與二級緩存。 11

3九、 Hibernate 中的Cascade 屬性有什麼做用？ 11

40、 Hibernate.update()和merge()區別？ 11

4一、 Hibernate update和flush區別？ 11

4二、 Hibernate session的load()和get()的區別？ 11

4三、 Hibernate List和Iterator方式的比較 12

4四、 hibernate的inverse屬性的做用？ 12

4五、 hibernate的cascade屬性的做用？ 12

4六、 各類關聯關係下的lazy懶加載區別？ 12

4七、 類(Class)的延遲加載： 13

4八、 Hibernate工做原理 13

3、 Struts2.x 14

4九、 MVC是什麼 一種設計模式，M：model模型；V：View視圖；C：Control控制器 14

50、 簡述 Struts2 的工做流程: 14

5一、 Struts2 攔截器 和 過濾器 的區別 14

5二、 爲何要使用 Struts2 & Struts2 的優勢： 14

5三、 Struts2 如何訪問 HttpServletRequest、HttpSession、ServletContext 三個域對象 ? 14

5四、 Struts2 中的默認包 struts-default 有什麼做用？ 15

5五、 說出 struts2 中至少 5 個的默認攔截器 15

5六、 談談 ValueStack 15

5七、 ActionContext、ServletContext、pageContext的區別 ？ 15

5八、 Struts2 有哪幾種結果類型 ? 15

5九、 攔截器的生命週期與工做過程 ? 15

60、 如何在 Struts2 中使用 Ajax 功能 ? 15

6一、 用本身的話簡要闡述struts2的執行流程 15

6二、 Struts工做原理 16

6三、 Struts2.0 有幾種標籤庫 16

6四、 struts2 必備包有哪些？ 16

6五、 Hiberbate 優化方法有那些？ 16

6六、 應用服務器與Web Server 的區別 16

6七、 如何設置Hibernate 二級緩存 16

6八、 ApplicationContext 和BeanFactory 有什麼區別？ 16

6九、 Spring MVC 與Struts2 MVC 的不一樣之處 17

70、 Spring 使用了哪些設計模式，這樣用有什麼好處？ 17

7一、 Hibernate 有哪幾種查詢數據的方法？ 17

7二、 3 個框架在項目在項目當中的用，BaseDao 是用來作什麼的。 17

7三、 ThreadLocal 在項目中的實際意義？ 17

7四、 Spring 對多種ORM 框架提供了很好的支持，結合事務管理描述spring 從哪些方面提供了對Hibernate 的支持。 17

7五、 Hibernate 的session.save()與session.saveOrUpdate()的區別？ 17

7六、 Hibernate 中sedssion.get()與session.load()的區別？ 18

7七、 annotation 的使用方法和用途主要分爲幾類？ 18

7八、 Struts2 是怎麼實現MVC 的？ 18

7九、 介紹下hibernate【上海數字政通】 18

80、 在Struts2 中，配置文件中通配符是怎麼表示和使用的？使用通配符後有什麼好處 18

8一、 Hibernate 中的HQL 和criteria 的區別？ 18

8二、 介紹hibernate 延持加載屬性 18

8三、 列舉你接觸過的框架，說明特色和原理 19

8四、 解釋一下IOC,以及spring 的舉例 19

8五、 解釋一下mvc 以及熟悉的mvc 框架 19

8六、 Spring 工做原理 19

8七、 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

10八、 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

4、 Spring 27

13二、 對Spring理解與做用 27

13三、 在spring中有幾種事務管理，分別是什麼? 27

13四、 JDK動態代理學習 27

13五、 Spring與Struts集成 把業務對象、Action歸入spring的ioc容器， 27

13六、 怎麼理解OpenSessionInviewFilter？ 27

137、 講講spring中的事務，如何支持事務的，事務的7大傳播屬性,spring mvc 做爲控制器層須要注意什麼 27

138、 什麼是aop  說說AOP的一些概念概念和術語 aop好處 項目中怎麼用的 27

5、 SpringMVC 28

139、 spring 如何實現mvc 請求處理流程 28

140、 spring mvc如何執行靜態文件如js文件  css文件 圖片文件 28

141、 springmvc與struts2比較 28

142、 spring mvc 註解 28

143、 說說spring dao 29

6、 MyBatis 29

144、 .ibatis/mybatis框架的優缺點? 29

145、 ibatis核心類的做用;MyBatis核心類的做用? 29

146、 mybatis/ibatis跟hibernate的比較; 29

147、 ibatis的工做流程或運行原理? 29

148、 Ibatis中#與$的區別？ 29

7、 WebServices 30

149、 怎麼調用webservice 30

150、 wsdl soap 30

151、 你如何開發webservice 30

152、 項目用了webservice幹什麼 30

153、 安全問題： 30

154、 ejb 31

8、 EJB 31

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

 

 

1、 Struts1.x

一、 struts1優缺點,爲何要使用struts1

好處：1、良好的架構和設計

      2、可重用，模塊化，擴展性好

      3、Open source  開放源代碼

      4、它提供了豐富的標籤庫，使頁面能更加的靈活的使用。

 

缺點：1、依賴於servlet API  不方便測試

      2、單例模式，線程不安全

      3、視圖表現層技術都支持jsp

      4、類型轉換是單向的

      5、沒有針對具體方法的校驗。

      6、強制繼承action或者dispatchAction

      7、它太過於依賴web容器，當配置文件改動一次就要從新啓動。

      8、它的配置文件太過複雜。

      9、ActionForm沒法進行測試  

二、 Struts1核心組件

ActionServlet 核心控制器

Action        業務類

ActionForm    0顯示數據  1封裝頁面數據  2回顯數據   3校驗

ActionMapping 幫助ActionServlet控制器將請求映射到業務類操做（相似於查詢action）

ActionForward  導航器，進行jsp頁面轉發

ActionError與Actionmessage  用來存儲和回收錯誤

Struts標籤庫能夠減輕開發顯示層次的工做

三、 Strust1請求處理流程  工做原理

一、讀取配置

二、發送請求   

3、填充form

4、校驗form  input

5、派發請求  到Action的業務方法   好比execute方法

6、處理業務

7、返回響應

8、處理返回響應

 

工做原理：在Struts中，用戶的請求通常以*.do做爲服務名，全部的*.do請求均被指向ActionServlet

 ActionServlet根據Struts-config.xml中的配置信息，將用戶請求封裝成一個指定名稱的FromBean

 並將此FromBean傳至指定名稱的ActionBean，由ActionBean完成相應的業務操做。

 

四、 Struts1線程安全問題

一、由於struts1是單例的，因此存在線程安全問題，因此咱們採用在方法上標上線程同步或者使用同步代碼塊就能夠解決了。

二、Action交給spring建立

三、注意不要用實例變量或類變量共享只是針對某個請求的數據，注意資料操做的同步性

五、 Struts1 它解決了什麼問題？

它解決了jsp頁面代碼混亂和多個Servlet的問題

 

六、 Struts1的框架的結構是什麼？

Jsp + servlet + tiles

 

七、 struts 1如何實現mvc

用戶發送請求 到達ActionServlet核心控制器,而後在經過ActionMapping幫助ActionServlet將控制器請求映射到業務類

在此之間 經過ActionForm將數據進行類型轉換，數據封裝，和校驗。

而後執行業務類的的execute方法 而後將ActionForm轉換成咱們本身定義的form

在經過調用m層的方法將數據持久化到數據庫 再返回C層經過ActionForward進行頁面轉發返回到V層

 

八、 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實例

 

九、 爲何要使用動態form 

  很顯然隨着應用程序的變大，數百個ActionForm 這樣不只編程起來麻煩，之後維護起來也麻煩，好比：

  某個屬性變化了，則須要修改源代碼，而後從新編譯，可是若是使用DynaActionform則只須要修改

  struts-config.xml配置文件就好了。這樣提升了應用程序的開發效率與應用程序的可維護性

  但大量的使用它也會形成配置文件的臃腫

 

2、 Hibernate面試題

十、 list，iterate區別

• 使用list()方法獲取查詢結果，每次發出一條查詢語句，獲取所有數據
• 使用iterate()方法獲取查詢結果，先發出一條SQL 語句用來查詢知足條件數據的id，而後依次按這些id 查詢記錄，也就是要執行N+1 條SQL 語句（N 爲符合條件的記錄數）

 

• list()方法將不會在緩存中讀取數據，它老是一次性的從數據庫中直接查詢全部符合條件的數據，同時將獲取的數據寫入緩存
• iterate()方法則是獲取了符合條件的數據的id 後，首先根據id 在緩存中尋找符合條件的數據，若緩存中無符合條件的數據，再到數據庫中查詢

十一、 Hibernate 核心接口session介紹

一、做用：提供基本的保存，刪除，更新，和加載Java對象

二、什麼是清理緩存：

Session可以在某些時間點，按照緩存中對象的變化來執行相關的SQL語句，來同步更新數據庫，這一過程別稱爲清理緩存（flush）

三、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);

}

}

四、獲取session的兩種方式介紹

一、 getCurrentSession建立的Session會綁定到當前線程，而openSession不會

二、 getCurrentSession建立的Session會在事務回滾或者事務提交後自動關閉，而openSession建立的必須手動關閉（調用Session的cloe()方法）

三、 getCurrentSession使用方法

一、 當使用本地事務時（jdbc事務）

須要在hibernate.cfg.xml文件的<session-factor>節點添加：

<property name="hibernate.current_session_context_class">thread</property>

二、 當使用的是全局使唔時（jta事務）

<property name="hibernate.current_session_context_class">jta</property>

注意：若是使用了getCurrentSession方法又沒有在配置中配置以上方法時程序編譯無誤，可是運行彙報以下錯誤。

Exception in thread "main" org.hibernate.HibernateException: No CurrentSessionContext configured!

十二、 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)更新帶有標識符且是給定的處於脫管狀態的實例的持久化實例。

1三、 Hibernate操做的對象有三種狀態

一、瞬時狀態(Transient)/臨時。2.、持久化狀態（persistent）。三、託管狀態（detached）/遊離狀態

 

一、當一個對象經過new 新建立的時候就是瞬時狀態

    瞬時狀態下對象的主鍵沒有值，也沒有歸入session的管理，數據庫表中也沒有對應的記錄，當咱們調用save等相關的其餘方法是則進入了持久化狀態，

二、持久化狀態下對象歸入了session管理中，對象標示符有值。Hibernate保證在同一個session實例的緩存中數據庫中的一條記錄只對應惟一的一個持久化對象。session在清理緩存時會根據持久化對象的屬性變化會同步更新數據庫。當session關閉後持久化狀態就會變成託管狀態。當持久化對象調用delete方法就由持久化變成了移除狀態

三、託管狀態下的特色：對象不處於session的管理中。但他曾經與某個持久化上下文發生過關聯(session)，對象標示符有值，數據庫可能存在與之相對的記錄。Hibernate不可以保證託管狀態下的數據和數據庫中的數據同步更新。

四、臨時和遊離狀態下的對象特色：等待垃圾回收，

1四、 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

 

一、檢索方法

a) 經過Session類的get和load方法加載指定的OID的對象

b) 經過HQL,QBC等檢索方法記載知足條件的對象

二、檢索的做用域

a) 類級別：做用於當前對象。對當前對象時當即檢索，仍是延遲檢索。默認延遲檢索只對load有效

b) 關聯級別：對關聯對象是當即檢索，延遲檢索仍是迫切左外鏈接檢索。默認延遲檢索。對全部檢索方法有效

 

三、fetch的做用和取值

a) select   加載關聯對象時經過select語句實現。默認值

b) subselect  加載關聯對象時經過帶子查詢語句實現。

c) join  執行當即檢索，採用迫切左外鏈接檢索全部關聯對象，lazy屬性將被忽略。

 

總結：① select 和 subselect 適用於當即檢索和延遲檢索，join 僅使用當即檢索。

② select 和 subselect 決定加載關聯對象時查詢語句形式，join決定加載關聯對象的時機。

1五、 Query 中常見方法

1六、 Hibernate參數綁定有幾種方式

一、 佔位符「?」

二、 命名查詢

三、 封裝參數(投影查詢)

1七、 在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>

1八、 Hibernate優化

一、避免or操做

where 子句包含or 操做，執行時不使用索引

能夠使用in條件來替換

二、避免使用not

where 子句包含not 關鍵字，執行時該字段的索引失效

使用比較運算符替換not

三、避免like的特殊形式

查詢時，儘量少使用like

四、避免having子句

儘量在where 子句中指定條件

五、避免使用distinct

在不要求或容許冗餘時，應避免使用distinct

1九、 什麼是懶加載 懶加載用什麼技術實現，如何解決session關閉致使的懶加載問題 解決的方案有缺點嗎、

懶加載就是延遲加載,採用代理技術實現，採用openSessionInViewFilter,openSessionInViewFilter其實上就是一個過濾器頁面打開時開啓session，頁面訪問結束時關閉session

當訪問用戶過多，並且網速過慢的時候,會擠爆系統

事務擴大了 加鎖致使資源等待時間過長

session範圍變大  若是加載頁面的時間過長 如網速比較慢   session內存時間過長 致使系統性能下載

數據庫鏈接不能及時釋放

20、 hibernate核心類

congfigeration負責管理配置信息

sessionfactory負責建立出session

session負責調用持久化方法

Transaction 負責事務管理

query爲查詢接口

2一、 hibernate抓取策略

Hibernate的 抓取策略有四種

一、 join        鏈接抓取 它是經過select語句使用外鏈接來加載實體或者集合  懶加載會失效--同等於mybatis中的嵌套結果

二、 select     查詢抓取 它是經過發送一條select語句抓取當前對象關聯的實體或者集合 一條查本身 一條抓關聯數據

三、 subselect   子查詢抓取 發送一條select語句查詢出關聯的實體或者集合，而後經過子查詢in完成

四、 batch-size  批量抓取

2二、 hibernate 的原理           

1. 讀取並解析配置文件

2. 讀取並解析映射信息，建立SessionFactory

3. 打開Sesssion

4. 建立事務Transation

5. 持久化操做

6. 提交事務

7. 關閉Session

8. 關閉SesstionFactory

2三、 Hibernate 的session.save()與session.saveOrUpdate()的區別？

1.save（）方法，調用save 方法時，首先會在session 緩存中查找保存對象若是實體對象已經處於Persient 狀態，直接返回；不然並將保存至數據庫，對象變爲持久狀態。

2.saveOrUpdate（）方法：和save 方法同樣首先在session 緩存中查找，判斷對象是否爲爲保存狀態，若是對象處於Persient，不執行操做，處於Transient 執行save 操做，處於Detached 調用saveOrUpdate 將對象與session 從新關聯（簡單的說就是該方法會先看該對象是否已經存在，若是已經存在就更新，不然新增保存），若是此時saveOrUpdate 的對象與另外一個與Session 關聯的對象持有相同的持久化標識則拋出相同的標識符異常。

2四、 Hibernate 中sedssion.get()與session.load()的區別？

Session.load/get 方法都可以根據指定的實體類和id 從數據庫讀取記錄，並返回與之對

應的實體對象。其區別在於：

1) 若是未能發現符合條件的記錄， get 方法返回null ， 而load 方法會拋出一個

ObjectNotFoundException。

2) load 支持延遲加載，get 不支持

3) load 方法可返回實體的代理類實例，而get 方法永遠直接返回實體類。

4) load 方法能夠充分利用內部緩存和二級緩存中的現有數據，get 方法則僅僅在內部緩存

中進行數據查找，如沒有發現對應數據，將越過二級緩存，直接調用SQL 完成數據讀取。

2五、 介紹下hibernate

Hibernate 是一個開放源代碼Java 語言下的對象關係映射解決方案。它爲面向對象的領域模型到傳統的關係型數據庫的映射，提供了一個使用方便的框架。Hibernate 也是目前Java開發中最爲流行的數據庫持久層框架。將軟件開發人員從大量相同的數據持久層相關編程工做中解放出來，Hibernate 不只負責從Java 類到數據庫表的映射（還包括從Java 數據類型到SQL 數據類型的映射），還提供了面向對象的數據查詢檢索機制，從而極大地縮短的手動處理SQL 和JDBC 上的開發時間。

 

2六、 Hibernate 中的HQL 和criteria 的區別？

1.QBC(Query by Criteria)查詢對查詢條件進行了面向對象封裝，符合編程人員的思惟方式;

2．HQL(Hibernate Query Language)查詢提供了更加豐富的和靈活的查詢特性，在涵蓋

Criteria 查詢的全部功能的前提下，提供了相似標準SQL 語句的查詢方式，同時也

提供了更加面向對象的封裝。

 

2七、 介紹hibernate 延持加載屬性

Hibernate 經過lazy 來指定加載策略，通常值爲true 或false,。設爲flase 表示當即加載，true 表過延遲加載。

2八、 列舉你接觸過的框架，說明特色和原理

Hibernate 特色:

1. 基於JDBC 的主流持久化框架，是一個優秀的ORM 實現，對JDBC 訪問數據庫的代碼作了封裝，大大簡化了數據訪問層繁瑣的重複性代碼。

2. hibernate 使用Java 反射機制，而不是字節碼加強程序來實現透明性。

3. hibernate 的性能很是好，由於它是個輕量級框架。映射的靈活性很出色。它支持各類關係數據庫，從一對一到多對多的各類複雜關係。

Spring 特色：

Spring 框架的主要優點之一低侵入式的架構思想，實現了IOC 容器。另一個AOP 的編程也在不少應用場合下地位較重。提供了對各類不一樣類型框架的支持，如：Web 容器、持入層、事務層、其它J2EE 組件等。

2九、 Hibernate 中離線查詢與在線查詢的區別

Criteria 和DetachedCriteria 的主要區別在於建立的形式不同， Criteria 是在線的，因此它是由Hibernate Session 進行建立的；而DetachedCriteria 是離線的，建立時無需Session，DetachedCriteria 提供了2 個靜態方法forClass(Class) 或forEntityName(Name)進行DetachedCriteria 實例的建立。

30、 Ibatis 框架和Hibernate 框架各有什麼特色？

 

3一、 爲何要用ORM? 和JDBC 有何不同?

orm 是一種思想，就是把object 對象轉變成數據庫中的記錄，或者把數據庫中的記錄轉變成object 對象，咱們能夠用jdbc 來實現這種思想，orm 的思想本質就是創建是JDBC 上，對JDBC 的一種封裝，這種封裝能夠省去了直接使用jdbc 的繁瑣細節，提升了開發效率，如今用的較多的ORM 工具不少，通常咱們公司採用的ORM 框架主要有hibernate 和MyBatis。固然也據說一些其餘orm 工具，如toplink,ojb 等。

 

3二、 簡述Hibernate 和JDBC 的優缺點? 

一、封裝了jdbc，簡化了不少重複性代碼。

二、簡化了DAO 層編碼工做，使開發更對象化了。

三、移植性好，支持各類數據庫，若是換個數據庫只要在配置文件中變換配置就能夠了，不用改變hibernate 代碼。

四、支持透明持久化，由於hibernate 操做的是純粹的（pojo）java 類，沒有實現任何接口，沒有侵入性。

3三、 如何書寫一個one-to-many 配置文件

3四、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置?

一、 配置一對多

<!-- 部門對員工的一對多配置-->

<set name="employees" inverse="true" cascade="delete">

<key column="deptid"></key>

<one-to-many class="com.tsinghua.manager.vo.EmployeeVO"/>

</set>

二、 多對一

<!-- 員工對部門的多對一配置column 指定外鍵-->

<many-to-one name="department" class="com.tsinghua.manager.vo.DepartmentVO" column="deptid" />

3五、 hibernate 的inverse 屬性的做用?

在Hibernate 中，術語inverse 是反轉的意思，在關聯關係中，inverse="false"爲主控方，由主控方負責維護對象的關聯關係，若是設爲主控方對象，主控對象更新，則負責更新另外一方對象更新。

3六、 Hibernate 對象有幾種狀態？如何轉換

共3 種狀態，分別是：Transient 狀態（瞬時）、Persient 狀態（持久）、Detached（脫管狀態）狀態。

3七、 Hibernate 中有幾種關係映射

主要有單向一對1、單向一對多、單向多對1、單向多對多、雙向一對1、雙向一對多、雙向多對多

3八、 介紹一下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);

3九、 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仍是自由態。

4一、 Hibernate update和flush區別？

Hibernate update操做的是在自由態或脫管狀態(因session的關閉而處於脫管狀態)的對象，而flush是操做的在持久狀態的對象。

默認狀況下，一個持久狀態的對象的改動(包含set容器)是不須要update的，只要你更改了對象的值，等待Hibernate flush就自動更新或保存到數據庫了。
(1) 調用某些查詢的和手動flush(),session的關閉、SessionFactory關閉結合。get()一個對象，把對象的屬性進行改變,把資源關閉。
(2)transaction commit的時候(包含了flush) 。

4二、 Hibernate session的load()和get()的區別？

1：若是你使用load方法，hibernate認爲該id對應的對象（數據庫記錄）在數據庫中是必定存在的，因此它能夠放心的使用，它能夠放心的使用代理來延遲加載該對象。在用到對象中的其餘屬性數據時才查詢數據庫，可是萬一數據庫中不存在該記錄，那沒辦法，只能拋異常，所說的load方法拋異常是指在使用該對象的數據時，數據庫中不存在該數據時拋異常，而不是在建立這個對象時。因爲session中的緩存對於hibernate來講是個至關廉價的資源，因此在load時會先查一下session緩存看看該id對應的對象是否存在，不存在則建立代理。因此若是你知道該id在數據庫中必定有對應記錄存在就能夠使用load方法來實現延遲加載。 對於get方法，hibernate會確認一下該id對應的數據是否存在，首先在session緩存中查找，而後在二級緩存中查找，尚未就查數據庫，數據庫中沒有就返回null(網上有不少誤解覺得get就立刻去數據庫查找根本不先查session那是不正確的，不想信你就去作下試驗便知)。

二、「get()永遠只返回實體類」，但實際上這是不正確的，get方法若是在session緩存中找到了該id對應的對象，若是恰好該對象前面是被代理過的，如被load方法使用過，或者被其餘關聯對象延遲加載過，那麼返回的仍是原先的代理對象，而不是實體類對象，若是該代理對象尚未加載實體數據（就是id之外的其餘屬性數據），那麼它會查詢二級緩存或者數據庫來加載數據，可是返回的仍是代理對象，只不過已經加載了實體數據。

三、再注重說明get方法首先查詢session緩存，沒有的話查詢二級緩存，最後查詢數據庫；反而load方法建立時首先查詢session緩存，沒有就建立代理，實際使用數據時才查詢二級緩存和數據庫。

總之對於get和load的根本區別，一句話，hibernate對於load方法認爲該數據在數據庫中必定存在，能夠放心的使用代理來延遲加載，若是在使用過程當中發現了問題，只能拋異常；而對於get方法，hibernate必定要獲取到真實的數據，不然返回null。

4三、 Hibernate List和Iterator方式的比較

(1)、List方式是1次性把全部的數據所有取到內存中，構造一個超大的結果集，主要的時間開銷是這一步，這一步的時間開銷要遠遠超過JDBC和 Iterator方式下構造結果集的時間開銷，而且內存開銷也很驚人；而對結果集的遍歷操做，速度則是很是的驚人（通過測試，30萬記錄的內 存遍歷不到100ms，因爲這一步不受JDBC影響，所以結果可信）。所以，List方式適合於對結果集進行反覆屢次操做的狀況，例如分頁顯示，日後往前 遍歷，跳到第一行，跳到最後一行等等。

(2)、Iterator方式只取記錄id到內存中，並無把全部數據取到內存中，所以構造結果集的時間開銷很小，比JDBC和List方式都要少，而且內 存開銷也小不少。而對結果集的遍歷的操做的時候，Iterator仍然要訪問數據庫，全部主要的時間開銷都花在這裏。所以，Iterator方式適合於只 對結果集進行1次遍歷操做的狀況，而且Iterator方式特別適合於從超大結果集中取少許數據，這種狀況Iterator性能很是好

4四、 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。

4五、 hibernate的cascade屬性的做用？

cascade屬性的做用是描述關聯對象進行操做時的級聯特性。所以，只有涉及到關係的元素纔有cascade屬性。
具 有cascade屬性的標記包括<many-to-one /> <one-to-one /> <any /> <set /><bag /> <idbag /> <list /> <array />
注意：<ont-to-many />和 <many-to-many />是用在集合標記內部的，因此是不須要cascade屬性的。
級聯操做：指當主控方執行某項操做時，是否要對被關聯方也執行相同的操做。

4六、 各類關聯關係下的lazy懶加載區別？

一、 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查詢，這樣致使了懶加載的失效。

二、 one-to-many懶加載

與one-to-one關聯不一樣，對one-to-many而言，主表的每一條屬性都會對應從表的多條數據，這個時候懶加載就顯得很是有效了。好比一個部門裏面有多個員工，若是沒有懶加載，每查詢這個部門的時候都會查詢出多個員工，這會大大增長與數據庫交互的成本。因此Hbernate默認的是加入懶加載的。這就是查詢集合屬性的時候返回的是一個PersistentIndexed*類型對象的緣由。該對象其實就是一個代理對象。固然，能夠在映射文件中經過將lazy屬性設爲假來禁用。
Hibernate默認對one-to-many就是使用的懶加載，但用戶也能夠取消懶加載操做：
一：設置lazy=」false」;
二：設置fetch=」join」.

實現此種懶加載必須在從對象這邊同時知足兩個條件：
一、lazy!=false（lazy的屬性有三個選項分別爲：no-proxy、false和proxy）
二、fetch=select。

三、 many-to-one懶加載

此關聯關係的懶加載和one-to-one的懶加載同樣都是可要可不要的，由於對執行效率的提升都不是很是明顯。雖然多對一與一對一關係方式相同，可是在Hibernate中多對一時，默認是進行懶加載的。另外有一點須要注意的是懶加載並不會區分集合屬性裏面是否有值，即便是沒有值，他依然會使用懶加載。實現此種懶加載必須在從對象這邊同時知足兩個條件
一、lazy!=false（lazy的屬性有三個選項分別爲：no-proxy、false和proxy）
二、fetch=select

四、 many-to-many懶加載

此關聯關係的懶加載和one-to-many的懶加載同樣對程序的執行效率的提升都是很是明顯的。
實現此種懶加載必須在從對象這邊同時知足兩個條件：
一、lazy!=false（lazy的屬性有三個選項分別爲：no-proxy、false和proxy）
二、fetch=select

可以懶加載的對象都是被改過的代理對象，當相應的對象沒有關閉時，訪問這些懶加載對象的屬性（getId和getClass除外）Hibernate會初始化這些代理，或用hibernate.initalize(proxy)來初始化代理對象；當關閉session後在訪問懶加載的對象就會出現異常。

4七、 類(Class)的延遲加載：

◆設置<class>標籤中的lazy=」true」,或是保持默認（即不配置lazy屬性)

◆ 若是lazy的屬性值爲true，那麼在使用load方法加載數據時，只有確實用到數據的時候纔會發出sql語句；這樣有可能減小系統的開銷。
注意：在class標籤上配置的lazy屬性不會影響到關聯對象!

4八、 Hibernate工做原理

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

3、 Struts2.x

4九、 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() 以後的代碼

⑧  把結果發送到客戶端

5一、 Struts2 攔截器 和 過濾器 的區別

①  過濾器依賴於Servlet容器，而攔截器不依賴於Servlet容器。

②  Struts2 攔截器只能對 Action 請求起做用，而過濾器則能夠對幾乎全部請求起做用。

③  攔截器能夠訪問 Action 上下文(ActionContext)、值棧裏的對象(ValueStack)，而過濾器不能.

④  在 Action 的生命週期中，攔截器能夠屢次調用，而過濾器只能在容器初始化時被調用一次。

5二、 爲何要使用 Struts2 & Struts2 的優勢：

①  基於 MVC 架構，框架結構清晰。

②  使用 OGNL: OGNL 能夠快捷的訪問值棧中的數據、調用值棧中對象的方法

③ 攔截器: Struts2 的攔截器是一個 Action 級別的 AOP, Struts2 中的許多特性都是經過攔截器來實現的, 例如異常處理，文件上傳，驗證等。攔截器是可配置與重用的

③  多種表現層技術. 如：JSP、FreeMarker、Velocity 等

5三、 Struts2 如何訪問 HttpServletRequest、HttpSession、ServletContext 三個域對象 ?

①  與 Servlet API 解耦的訪問方式

      > 經過 ActionContext 訪問域對象對應的 Map 對象

      > 經過實現 Aware 接口使 Struts2 注入對應的 Map 對象

 ② 與 Servlet API 耦合的訪問方式

    > 經過 ServletActionContext 直接獲取 Servlet API 對象

> 經過實現 ServletXxxAware 接口的方式使 Struts2 注入對應的對象

5四、 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 包。

5五、 說出 struts2 中至少 5 個的默認攔截器

exception；fileUpload；i18n；modelDriven；params；prepare；token；tokenSession；validation 等

5六、 談談 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 直接訪問值棧中的內容

5七、 ActionContext、ServletContext、pageContext的區別 ？

①  ActionContext Struts2 的 API：是當前的 Action 的上下文環境

② ServletContext 和 PageContext 是 Servlet 的 API

5八、 Struts2 有哪幾種結果類型 ?

dispatcher、chain、redirect

5九、 攔截器的生命週期與工做過程 ?

每一個攔截器都是須要實現 Interceptor 接口

    > init()：在攔截器被建立後當即被調用, 它在攔截器的生命週期內只被調用一次. 能夠在該方法中對相關資源進行必要的初始化；

    > intercept(ActionInvocation invocation)：每攔截一個動做請求，該方法就會被調用一次；

    > destroy：該方法將在攔截器被銷燬以前被調用, 它在攔截器的生命週期內也只被調用一次；

60、 如何在 Struts2 中使用 Ajax 功能 ?

① . JSON plugin

② . DOJO plugin

③ . DWR plugin

④ . 使用 Stream 結果類型.

6一、 用本身的話簡要闡述struts2的執行流程

Struts 2框架自己大體能夠分爲3個部分：核心控制器FilterDispatcher、業務控制器Action和用戶實現的企業業務邏輯組件。核心控制器FilterDispatcher是Struts 2框架的基礎，包含了框架內部的控制流程和處理機制。業務控制器Action和業務邏輯組件是須要用戶來本身實現的。用戶在開發Action和業務邏輯組件的同時，還須要編寫相關的配置文件，供核心控制器FilterDispatcher來使用。 Struts 2的工做流程相對於Struts 1要簡單，與WebWork框架基本相同，因此說Struts 2是WebWork的升級版本。基本簡要流程以下：一、客戶端瀏覽器發出HTTP請求。二、根據web.xml配置，該請求被FilterDispatcher接收。三、根據struts.xml配置，找到須要調用的Action類和方法， 並經過IoC方式，將值注入給Aciton。四、Action調用業務邏輯組件處理業務邏輯，這一步包含表單驗證。五、Action執行完畢，根據struts.xml中的配置找到對應的返回結果result，並跳轉到相應頁面。六、返回HTTP響應到客戶端瀏覽器。

6二、 Struts工做原理

一個請求在Struts2框架中的處理大概分爲如下幾個步驟
一、客戶端初始化一個指向Servlet容器（例如Tomcat）的請求
2、 這個請求通過一系列的過濾器（Filter）（這些過濾器中有一個叫作ActionContextCleanUp的可選過濾器，這個過濾器對於Struts2和其餘框架的集成頗有幫助，例如：SiteMesh Plugin）
三、 接着FilterDispatcher被調用，FilterDispatcher詢問ActionMapper來決定這個請是否須要調用某個Action
四、 若是ActionMapper決定須要調用某個Action，FilterDispatcher把請求的處理交給ActionProxy
五、 ActionProxy經過Configuration Manager詢問框架的配置文件，找到須要調用的Action類
六、 ActionProxy建立一個ActionInvocation的實例。
七、 ActionInvocation實例使用命名模式來調用，在調用Action的過程先後，涉及到相關攔截器（Intercepter）的調用。
八、 一旦Action執行完畢，ActionInvocation負責根據struts.xml中的配置找到對應的返回結果。返回結果一般是（但不老是，也可 能是另外的一個Action鏈）一個須要被表示的JSP或者FreeMarker的模版。在表示的過程當中能夠使用Struts2 框架中繼承的標籤。在這個過程當中須要涉及到ActionMapper

基本簡要流程以下：一、客戶端瀏覽器發出HTTP請求。二、根據web.xml配置，該請求被FilterDispatcher接收。三、根據struts.xml配置，找到須要調用的Action類和方法， 並經過IoC方式，將值注入給Aciton。四、Action調用業務邏輯組件處理業務邏輯，這一步包含表單驗證。五、Action執行完畢，根據struts.xml中的配置找到對應的返回結果result，並跳轉到相應頁面。六、返回HTTP響應到客戶端瀏覽器。

6三、 Struts2.0 有幾種標籤庫

【參考答案】UI 標籤、控制標籤、數據標籤、雜項標籤

6四、 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

6五、 Hiberbate 優化方法有那些？

【參考答案】

1) 儘可能使用many-to-one，避免使用one-to-many

2) 靈活使用單向one-to-many

3) 不用一對一，使用多對一代替一對一

4) 配置對象緩存，不使用集合緩存

5) 一對多使用Bag 多對一使用Set

6) 繼承使用顯示多態HQL:from object polymorphism="exlicit" 避免查處全部對象

7) 消除大表，使用二級緩存

6六、 應用服務器與Web Server 的區別

6七、 如何設置Hibernate 二級緩存

一、首先要打開二級緩存，在hibernate.cfg.xml 中添加以下配置：<property name="hibernate.cache.use_second_level_cache">true</property>

二、Hibernate 的二級緩存使用第三方的緩存工具來實現，因此咱們須要指定Hibernate使用哪一個緩存工具。以下配置指定Hibernate 使用EhCache 緩存工具。

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider

</property>

三、 Hibernate 在默認狀況下並不會對全部實體對象進行緩存，因此，咱們須要指定緩存哪些對象，在實體對象的映射文件中（相應的<class>標籤內部），添加以下配置：<cache usage="read-only"/>usage="read-only"是「只讀」緩存策略。

6八、 ApplicationContext 和BeanFactory 有什麼區別？

BeanFactory 其實是實例化，配置和管理衆多bean 的容器。這些bean 一般會彼此合做，於是它們之間會產生依賴，而這種依賴只是體如今Bean 與Bean 之間的依賴這些依賴關係能夠經過配置來反映，而ApplicationContext beans 包是BeanFactory 的子類，提供了以編程的方式管理和操控bean 的基本功能，而context 包增長了ApplicationContext，它以一種更加面向框架的方式加強了BeanFactory 的功能，簡單說他加強了面向Web 容器的功能。ApplictionContext 徹底採用聲明式方式來使用容器，甚至不用去手工建立它，Web應用的啓動進程中用它啓動ApplicationContext 。固然用編程的方式建立一個ApplicationContext 對象能夠有如下幾種方式或實現：

一、ClassPathXmlApplicationContext:從類路徑中的XML 文件載入上下文定義信息，把上下文定義文件看成類路徑資源。

二、FileSystemXmlApplicationContext:從文件系統中的XML 文件載入上下文定義信息。

三、XmlWebApplicationContext：從Web 系統中的XMl 文件載入上下文信息。

6九、 Spring MVC 與Struts2 MVC 的不一樣之處

【參考答案】

一、請求處理機制：spring mvc 是基於方法的設計，而sturts 是基於類，每次發一次請求都會實例一個action，每一個action 都會被注入屬性，而spring 基於方法，粒度更細。

二、參數傳遞：struts 是在接受參數的時候，能夠用屬性來接受參數，這就說明參數是讓多個方法共享的。

三、設計思想上：struts 更加符合oop 的編程思想， spring 就比較謹慎，在servlet 上擴展。

四、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 中應用也較爲廣泛。

7一、 Hibernate 有哪幾種查詢數據的方法？

【參考答案】

hibernate 查詢有三種方式：HQL 查詢、結構化SQL 查詢、QBC 查詢

7二、 3 個框架在項目在項目當中的用，BaseDao 是用來作什麼的。

【參考答案】

DAO 組件主要提供數據庫訪問操做，針對不一樣數據源表持久化操做進行了封裝，這樣能夠提供其它層的訪問接口，使得組件之間解耦。而BaseDAO 是這些全部這些不一樣的持久化的DAO 的公共API 進行了封裝，進一步抽象提取，使其它各組件DAO 從BaseDAO 中派生，加強系統的重用性、維護性、擴展性。

7三、 ThreadLocal 在項目中的實際意義？

【參考答案】

ThreadLocal 和其它同步機制相比從另外一個角度來解決多線程的併發訪問，它爲每個線程維護一個和該線程綁定的變量的副本，從而隔離了多個線程的數據，每個線程都擁有本身的變量副本，從而也就沒有必要對該變量進行同步了。還提供了線程安全的共享對象，在編寫多線程代碼時，能夠把不安全的整個變量封裝進ThreadLocal

ThreadLocal 能夠大量減小參數的傳遞，能夠使代碼簡潔，但一個線程會綁定多個本身定義的局部對象，ThreadLocal 是抽象在線程上的對象建立工廠，目前的Tomcat5 使用了線程池，一個線程處理一個request，這樣ThreadLocal 對象能夠抽象的綁定在request 生命週期，不會存在線程危機，並且線程池也平衡了這些ThreadLocal

7四、 Spring 對多種ORM 框架提供了很好的支持，結合事務管理描述spring 從哪些方面提供了對Hibernate 的支持。

【參考答案】

一、SessionFactory 管理。使用Spring 整合Hibernate 時咱們不須要hibernate.cfg.xml 文件。首先， 在applicationContext.xml 中配置數據源（ dataSource ） bean 和session 工廠（sessionFactory）bean。

二、持入層管理。Spring 提供了HibernateTemplate，用於持久層訪問，無需打開Session及關閉Session。它只要得到SessionFactory 的引用，將能夠只讀地打開Session，並在持久化訪問結束後關閉Session，對持久層邏輯，通用的操做（如對數據庫中數據的增，刪，改，查）有HibernateTemplate 完成。

三、對DAO 的支持：經過繼承HibernateDaoSupport 實現DAO 基本操做。

四、對事務支持：Spring 的聲明式事務和編程式事務，很好的將持久化的操做歸入事務管理。

7五、 Hibernate 的session.save()與session.saveOrUpdate()的區別？

【參考答案】

1.save（）方法，調用save 方法時，首先會在session 緩存中查找保存對象若是實體對象已經處於Persient 狀態，直接返回；不然並將保存至數據庫，對象變爲持久狀態。

2.saveOrUpdate（）方法：和save 方法同樣首先在session 緩存中查找，判斷對象是否爲爲保存狀態，若是對象處於Persient，不執行操做，處於Transient 執行save 操做，處於Detached 調用saveOrUpdate 將對象與session 從新關聯（簡單的說就是該方法會先看該對象是否已經存在，若是已經存在就更新，不然新增保存），若是此時saveOrUpdate 的對象與另外一個與Session 關聯的對象持有相同的持久化標識則拋出相同的標識符異常。

7六、 Hibernate 中sedssion.get()與session.load()的區別？

【參考答案】

Session.load/get 方法都可以根據指定的實體類和id 從數據庫讀取記錄，並返回與之對應的實體對象。其區別在於：

1) 若是未能發現符合條件的記錄， get 方法返回null ， 而load 方法會拋出一個ObjectNotFoundException。

2) load 支持延遲加載，get 不支持

3) load 方法可返回實體的代理類實例，而get 方法永遠直接返回實體類。

4) load 方法能夠充分利用內部緩存和二級緩存中的現有數據，get 方法則僅僅在內部緩存中進行數據查找，如沒有發現對應數據，將越過二級緩存，直接調用SQL 完成數據讀取。

7七、 annotation 的使用方法和用途主要分爲幾類？

【參考答案】

一、內建Annotation——Java5.0 版在java 語法中常常用到的內建Annotation：

二、開發者自定義Annotation：由開發者自定義Annotation 類型；

三、使用第三方開發的Annotation 類型

7八、 Struts2 是怎麼實現MVC 的？

【參考答案】

MVC 就是model view controller，三種組件，Struts2 實現Controller 主要由一系列的前端過濾器（Filter）實現Controller。Model 層主要由Struts2 的Action 組件實現。View 層主要是由Struts2 的標籤庫、Freemarker 等組件實現視圖層

7九、 介紹下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 倡導的一種開發模式。

8一、 Hibernate 中的HQL 和criteria 的區別？

【參考答案】

1.QBC(Query by Criteria)查詢對查詢條件進行了面向對象封裝，符合編程人員的思惟方式;

2．HQL(Hibernate Query Language)查詢提供了更加豐富的和靈活的查詢特性，在涵蓋Criteria 查詢的全部功能的前提下，提供了相似標準SQL 語句的查詢方式，同時也提供了更加面向對象的封裝。

8二、 介紹hibernate 延持加載屬性

【參考答案】Hibernate 經過lazy 來指定加載策略，通常值爲true 或false,。設爲flase 表示當即加載，true 表過延遲加載。

8三、 列舉你接觸過的框架，說明特色和原理

Hibernate 特色：

1. 基於JDBC 的主流持久化框架，是一個優秀的ORM 實現，對JDBC 訪問數據庫的代碼作了封裝，大大簡化了數據訪問層繁瑣的重複性代碼。

2. hibernate 使用Java 反射機制，而不是字節碼加強程序來實現透明性。

3. hibernate 的性能很是好，由於它是個輕量級框架。映射的靈活性很出色。它支持各類關係數據庫，從一對一到多對多的各類複雜關係。

Spring 特色：

Spring 框架的主要優點之一低侵入式的架構思想，實現了IOC 容器。另一個AOP 的編程也在不少應用場合下地位較重。提供了對各類不一樣類型框架的支持，如：Web 容器、持入層、事務層、其它J2EE 組件等。

8四、 解釋一下IOC,以及spring 的舉例

IOC 稱爲控制反轉，也叫依賴注入，ioc 是Spring 的核心組件，它經過配置文件，將須要建立的對象以池的方式管理，將實例注入到須要的對象中區，是對象依賴於注入而不依賴於實現，解決了各個組件的耦合度，使得項目在後期的維護和擴展上很是方便。如在ssh框架整合中，咱們將datasource 對象注入給sessionFactory，再將sessionFactory 注入給dao 組件，再將dao 組件注入給struts 的Action 組件，在將action 對象注入給struts的攔截器。

8五、 解釋一下mvc 以及熟悉的mvc 框架

MVC 是Model－View－Controller 的簡寫。Model 表明的是應用的業務邏輯（經過JavaBean，EJB 組件實現）， View 是應用的表示層（由JSP、HTML、各類Taglib 等組成），Controller 是提供應用程序的中心控制處理。經過這種設計模型把應用邏輯，處理過程和顯示邏輯分紅不一樣的組件實現，這些組件能夠進行交互和重用，另外有利於維護。Struts一、Struts二、Spring MVC、WebWork 等這些都是屬於基於MVC 模式實現的框架

8六、 Spring 工做原理

內部最核心的就是IOC 了，動態注入，讓一個對象的建立不用new 了，能夠自動的生產，這其實就是利用java 裏的反射,反射其實就是在運行時動態的去建立、調用對象，Spring就是在運行時，跟xml Spring 的配置文件來動態的建立對象，和調用對象裏的方法的還有一個核心就是AOP 這個就是面向切面編程，能夠爲某一類對象進行監督和控制（也就是在調用這類對象的具體方法的先後去調用你指定的模塊）從而達到對一個模塊擴充的功能。這些都是經過配置類達到的

Spring 目的：

就是讓對象與對象（模塊與模塊）之間的關係沒有經過代碼來關聯，都是經過配置類說明管理的（Spring 根據這些配置內部經過反射去動態的組裝對象）要記住：Spring 是一個容器，凡是在容器裏的對象纔會有Spring 所提供的這些服務和功能

8七、 Hibernate 中離線查詢與在線查詢的區別

Criteria 和DetachedCriteria 的主要區別在於建立的形式不同， Criteria 是在線的，因此它是由Hibernate Session 進行建立的；而DetachedCriteria 是離線的，建立時無需Session，DetachedCriteria 提供了2 個靜態方法forClass(Class) 或forEntityName(Name)進行DetachedCriteria 實例的建立。

8八、 Struts2 實現攔截器的原理？

攔截器是AOP 中的概念，它自己是一段代碼，能夠經過定義「織入點」，來指定攔截器的代碼在「織入點」的先後執行，從而起到攔截的做用。而Struts2 的Interceptor，其攔截的對象是Action 代碼，能夠定義在Action 代碼以前或者以後執行攔截器的代碼。

1. 整個結構就如同一個堆棧，除了Action 之外，堆棧中的其餘元素是Interceptor

2. Action 位於堆棧的底部。因爲堆棧"先進後出"的特性，而這些都是圍繞着Action 的，當咱們請求Action 時，必須首先把位於Action 上端的Interceptor 拿出來執行。

8九、 Struts2 的實現原理

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

2 、這個請求通過一系列的過濾器（ Filter ）（ 這些過濾器中有一個叫作ActionContextCleanUp 的可選過濾器，這個過濾器對於Struts2 和其餘框架的集成頗有幫助，例如：SiteMesh Plugin）；

三、接着FilterDispatcher 被調用，FilterDispatcher 詢問ActionMapper 來決定這個請求是否須要調用某個Action；

四、若是ActionMapper 決定須要調用某個Action，FilterDispatcher 把請求的處理交給ActionProxy；

五、ActionProxy 經過Configuration Manager 詢問框架的配置文件，找到須要調用的Action 類；

六、ActionProxy 建立一個ActionInvocation 的實例。

七、ActionInvocation 實例使用命名模式來調用，在調用Action 的過程先後，涉及到相關攔截器（Intercepter）的調用。

八、一旦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 的隔離級別

一、Serializable：最嚴格的級別，事務串行執行，資源消耗最大；

二、REPEATABLE READ：保證了一個事務不會修改已經由另外一個事務讀取但未提交（回滾）的數據。避免了「髒讀取」和「不可重複讀取」的狀況，可是帶來了更多的性能損失。

三、READ COMMITTED:大多數主流數據庫的默認事務等級，保證了一個事務不會讀到另外一個並行事務已修改但未提交的數據，避免了「髒讀取」。該級別適用於大多數系統。

四、Read Uncommitted：保證了讀取過程當中不會讀取到非法數據。

9一、 Ibatis 框架和Hibernate 框架各有什麼特色？

 

9二、 爲何要用ORM? 和JDBC 有何不同?

orm 是一種思想，就是把object 對象轉變成數據庫中的記錄，或者把數據庫中的記錄轉變成object 對象，咱們能夠用jdbc 來實現這種思想，orm 的思想本質就是創建是JDBC 上，對JDBC 的一種封裝，這種封裝能夠省去了直接使用jdbc 的繁瑣細節，提升了開發效率，如今用的較多的ORM 工具不少，通常咱們公司採用的ORM 框架主要有hibernate 和MyBatis。固然也據說一些其餘orm 工具，如toplink,ojb 等。

9三、 談談你對Spring AOP 思想的理解。

【參考答案】

AOP（Aspect-OrientedProgramming，面向方面編程），能夠說是OOP（Object-OrientedPrograming，面向對象編程）的補充和完善。OOP 引入封裝、繼承和多態性等概念來創建一種對象層次結構，用以模擬公共行爲的一個集合。當咱們須要爲分散的對象引入公共行爲的時候，OOP 則顯得無能爲力。也就是說，OOP 容許你定義從上到下的關係，但並不適合定義從左到右的關係。例如日誌功能，日誌代碼每每水平地散佈在全部對象層次中，而與它所散佈到的對象的核心功能毫無關係。對於其餘類型的代碼，如安全性、異常處理和透明的持續性也是如此。這種散佈在各處的無關的代碼被稱爲橫切（cross-cutting）代碼，在OOP 設計中，它致使了大量代碼的重複，而不利於各個模塊的重用。而AOP 技術則偏偏相反，它利用一種稱爲「橫切」的技術，剖解開封裝的對象內部，並將那些影響了多個類的公共行爲封裝到一個可重用模塊，並將其名爲「Aspect」，即方面。所謂「方面」，簡單地說，就是將那些與業務無關，卻爲業務模塊所共同調用的邏輯或責任封裝起來，便於減小系統的重複代碼，下降模塊間的耦合度，並有利於將來的可操做性和可維護性。AOP 表明的是一個橫向的關係，若是說「對象」是一個空心的圓柱體，其中封裝的是對象的屬性和行爲；那麼面向方面編程的方法，就彷彿一把利刃，將這些空心圓柱體剖開，以得到其內部的消息。而剖開的切面，也就是所謂的「方面」了。而後它又以巧奪天功的妙手將這些剖開的切面復原，不留痕跡。使用「橫切」技術，AOP 把軟件系統分爲兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關係不大的部分是橫切關注點。橫切關注點的一個特色是，他們常常發生在覈心關注點的多處，而各處都基本類似。好比權限認證、日誌、事務處理。Aop 的做用在於分離系統中的各類關注點，將核心關注點和橫切關注點分離開來。實現AOP 的技術，主要分爲兩大類：一是採用動態代理技術，利用截取消息的方式，對該消息進行裝飾，以取代原有對象行爲的執行；二是採用靜態織入的方式，引入特定的語法建立「方面」，從而使得編譯器能夠在編譯期間織入有關「方面」的代碼。

9四、 談談你對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 類。

9五、 說說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 使用.

9六、 簡述Hibernate 和JDBC 的優缺點? 如何書寫一個one to many 配置文件

一、封裝了jdbc，簡化了不少重複性代碼。

二、簡化了DAO 層編碼工做，使開發更對象化了。

三、移植性好，支持各類數據庫，若是換個數據庫只要在配置文件中變換配置就能夠了，不用改變hibernate 代碼。

四、支持透明持久化，由於hibernate 操做的是純粹的（pojo）java 類，沒有實現任何接口，沒有侵入性。

9七、 寫Hibernate 的一對多和多對一雙向關聯的orm 配置?

 

9八、 hibernate 的inverse 屬性的做用?

在Hibernate 中，術語inverse 是反轉的意思，在關聯關係中，inverse="false"爲主控方，由主控方負責維護對象的關聯關係，若是設爲主控方對象，主控對象更新，則負責更新另外一方對象更新。

9九、 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）等等，使得應用可移植性更強。

10一、 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 註解來完成。

10二、 SSH 框架的優缺點。

1．struts 第一個優勢應該是實現了MVC。對Servlet 依賴減小，低侵入式的設計

2．Action 線程安全的設計

3．功能強大的OGNL 表達式使用。

4．支持多種複合視圖，表現層的使用也多樣化，像JSP\freeMarker\Velocity。

5．攔截器的應用，實現了AOP 的思想，方便重用與擴展

6．自動類型轉換功能。

7．相對低粗度的數據驗證功能

Struts 缺點：

Struts2 中Action 中取得從jsp 中傳過來的參數時，若是頁面過於複雜，會形成對象臃腫。

Spring 優勢：

一、很是優秀的輕量級，低侵入式的框架。

二、IOC 的容器週期式的管理，下降組件的偶合。

三、對其它容器有很是好的支持，像對持久層的Hibernate、Ibaits、TOP Link等。

Spring 缺點：

1．Web 層的MVC 框架單過於單薄，對頁面框架的支持，跟其它框架還有很大的差距。

2．不是一站式解決方案。

3．使用了反射來管理其容器中的bean，在程序中增大了內存和運行計算的時間。

4．部分組件功能還有待完善

Hibernate 的優勢：

一、很是好的ORM 的框架，在MVC 的切分和JDBC 的封裝上作的很好。

缺點：

一、對複雜查詢，多變的查詢，完成起來有難度。

二、自動化程序高，改寫靈活性不夠。

二、緩存不是過高效，因此有些企業單獨會選擇緩存框架或者棄用Hibernate 的緣由之一。

10三、 Spring 有哪幾種注入方式？

3 種方法。構造屬入、屬性注入、接口注入

10四、 Spring MVC 工做機制及爲何要用?

1) 客戶端全部的請求都提交給DispatcherServlet,它會委託應用系統的其餘模塊負責負責對請求進行真正的處理工做。

2) DispatcherServlet 查詢一個或多個HandlerMapping,找處處理請求的Controller.

3) DispatcherServlet 請請求提交到目標Controller

4) Controller 進行業務邏輯處理後，會返回一個ModelAndView

5) Dispathcher 查詢一個或多個ViewResolver 視圖解析器,找到ModelAndView 對象指定的視圖對象

6) 視圖對象負責渲染返回給客戶端。

10五、 spring 中經常使用的幾種advice

BeforeAdvice （前織入）、AfterAdvice （後織入）、ArroundAdvice （先後織入）ThrowAdvice （異常織入）

10六、 Spring 中bean 的配置scope 表示什麼含義？能夠有哪幾種取值。

【參考答案】

scope 表示Bean 的生命週期或者叫Bean 的做用域。scope 的值有兩個：

一、singleton，爲單例屬性，即Spring IoC 容器只會建立該bean 的惟一一個實例，這也是默認的。

二、prototype 爲原型屬性，即每一次請求都會產生一個新的bean 實例。

10七、 Hibernate 對象有幾種狀態？如何轉換

共3 種狀態，分別是：Transient 狀態（瞬時）、Persient 狀態（持久）、Detached（脫管狀態）狀態。

10八、 spring 中OpenSessionInViewFilter 做用什麼的，解決了什麼問題

解決Hibernate 的Session 的關閉與開啓問題。

SSH 整合問題：Hibernate 容許對關聯對象、屬性進行延遲加載，可是必須保證延遲加載的操做限於同一個Hibernate Session 範圍以內進行。若是Service 層返回一個啓用了延遲加載功能的領域對象給Web 層，當Web 層訪問到那些須要延遲加載的數據時，因爲加載領域對象的Hibernate Session 已經關閉，這些致使延遲加載數據的訪問異常。而Spring爲咱們提供的OpenSessionInViewFilter 過濾器爲咱們很好的解決了這個問題。OpenSessionInViewFilter 的主要功能是用來把一個Hibernate Session 和一次完整的請求過程對應的線程相綁定，容許在事務提交以後延遲加載顯示所須要的對象。實現"Open Session in View"的模式

10九、 hibernate 有哪五個核心接口。

Configuration 接口，SessionFactory 接口，Session 接口，Transaction 接口，Query 和Criteria接口

1十、 Hibernate 中有幾種關係映射

主要有單向一對1、單向一對多、單向多對1、單向多對多、雙向一對1、雙向一對多、雙向多對多。

1十一、 介紹一下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);

1十二、 如何在WEB 裏面配置SPRING

主要配置Spring Web 監聽器

11三、 Hibernate 中的Cascade 屬性有什麼做用？

cascade 屬性的做用是描述關聯對象進行操做時的級聯特性。能夠有如下幾種取值：

all : 全部狀況下均進行關聯操做。

save-update：(級聯保存) 代表保存或更新當前對象時會級聯保存或更新他所關聯的對象。

none：全部狀況下均不進行關聯操做。這是默認值。

delete ：(級聯刪除) 級聯刪除所關聯的對象。

all-delete-orphan：自動刪除再也不和父對象關聯的子對象。而且，在出現上面兩種狀況時執行上面兩種的功能，能夠說是一個全自動的屬性值。

11四、 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 中實際是一個表單只能對應一個事件。

 

11五、 整合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 的控制之下。無疑，這是最靈活的一種整合方式。

11六、 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 實現轉發;

11七、 談談Struts1 中的ActionServlet。

【參考答案】

中心控制器，負責因此請求處理，並根據配置文件，將請求轉到指定Action 執行，並根據Action 的ActionForward 返回，轉到指定視圖。

11八、 Struts1.X 中ActionServlet、ActionForm 、Action、ActionMapping 各起什麼做用？

【參考答案】

a. Actionservlet 爲控制器，接受用戶請求並派發給相應的Action 組件處理；

b. ActionForm 主要用於封裝請求中的數據和簡單驗證

c. Action 組件具體對用戶的請求進行處理

d. ActionMapping 封裝當前用戶請求Action 相關的配置信息

11九、 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 頁面名稱的解耦

12一、 Struts1 中的action 是安全線程麼？爲何

【參考答案】

Servlet 是在多線程環境下的。便可能有多個請求發給一個servelt 實例，每一個請求是一個線程。struts 下的action 也相似，一樣在多線程環境下。爲多線程環境編寫代碼。咱們的controller servlet 指揮建立你的Action 類的一個實例，用此實例來服務全部的請求。所以，你必須編寫線程安全的Action 類。遵循與寫線程安全的servlet 一樣的方針。

12二、 在Struts1 中actionform 屬於哪一層

【參考答案】

屬於視圖層組件，負責封裝頁面表單數據。

12三、 struts 控制器組件的主要包括?

【參考答案】

ActionServlet 組件：充當struts 框架的中央控制器。

RequestProcessor 組件，充當每一個子應用模塊的請求處理器

Action 組件，負責處理一項具體的業務。

12四、 常見的緩存技術舉例【大唐動力面試題】

【參考答案】

操做系統磁盤緩存->減小磁盤機械操做數據庫緩存->減小文件系統I/O應用程序緩存->減小對數據庫的查詢Web 服務器緩存->減小應用服務器請求客戶端瀏覽器緩存->少對網站的訪問

12五、  以Spring 爲基礎的J2EE 項目中，通常如何分層？每一個層的做用是什麼？事務控制放在哪一層？

通常分爲持久層（DAO 層）、業務層（Service 層）、控制層、視圖層；事務通常放在業務層，以一個業務做爲一個事務分割的最小單位。

12六、 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 組件。

12七、 Webservice 有什麼好處?

跨平臺的可互操做性跨防火牆的通訊應用程序集成軟件和數據重用。

12八、 什麼是事物處理，J2EE 提供哪兩種事物處理方式

事務（Transaction）是數據庫管理系統提供的基本功能之一，能夠把完成用戶一個特定工做的一組操做看做是一個不可拆分的工做單元，因此事務也就是做業或任務。

JDBC：支持單一數據庫鏈接事務JTA：支持分佈式事務

12九、 WEB SERVICE 的理解【大唐動力面試題】

Web Service 主要是爲了使原來各孤立的站點之間的信息可以相互通訊、共享而提出的一種接口。Web Service 所使用的是Internet 上統1、開放的標準，如HTTP、XML、SOAP（簡單對象訪問協議）、WSDL 等，因此Web Service 能夠在任何支持這些標準的環境（Windows,Linux）中使用。注：SOAP 協議（Simple Object Access Protocal,簡單對象訪問協議）,它是一個用於分散和分佈式環境下網絡信息交換的基於XML 的通信協議。在此協議下，軟件組件或應用程序可以經過標準的HTTP 協議進行通信。它的設計目標就是簡單性和擴展性，這有助於大量異構程序和平臺之間的互操做性，從而使存在的應用程序可以被普遍的用戶訪問。

130、 J2EE 系統訪問速度慢.從哪些方面能夠優化

J2EE 性能的優化包括不少方面的，要達到一個性能優良的系統，除了關注代碼以外，還應該根據系統實際的運行狀況，從服務器軟硬件環境、集羣技術、系統構架設計、系統部署環境、數據結構、算法設計等方面綜合考慮來優化。通常程序級別的優化首先考慮作數據緩存，數據庫方面全作表的切割、數據分區、索引等這些方面來加快對數據的訪問。

13一、 說說你所知道的應用服務器？

BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss

 

 

 

 

 

 

 

4、 Spring

13二、 對Spring理解與做用

Spring是一個開源的控制反轉和麪向切面的容器框架。
Spring包含依賴注入容器、AOP實現、DAO/ORM支持、Web集成等。
解耦合、提供各類服務（事務管理、消息服務）、單例模式支持、AOP技術能夠很容易的實現權限控制、監控等、不少輔助類加快應用開發、對各大主流的應用框架提供了集成支持。

13三、 在spring中有幾種事務管理，分別是什麼? 

代碼管理的事務處理、容器管理的事務處理；
並不直接管理事務、將事務管理委託給事務管理器；
聲明式事務
傳播行爲、隔離級別

13四、 JDK動態代理學習

動態生成代理、能夠和任何實現接口的目標對象融合

13五、 Spring與Struts集成
把業務對象、Action歸入spring的ioc容器，

13六、 怎麼理解OpenSessionInviewFilter？

save完一個對象後，因爲有這個過濾器，spring會把這個鏈接放到線程池裏面，而不是立刻關閉。當須要延遲加載的時候，spring會從線程池裏面取出那個session完成加載的動做，當肯定這個session確實再也不須要的時候，spring纔會close掉這個session

 

13七、 講講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層實例的配置文件最好分開

 

 

13八、  什麼是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 是沒有修改源代碼的狀況下加功能 加功能的代碼寫在通知類中

 

5、 SpringMVC

13九、 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/>

 

14一、 springmvc與struts2比較

   1  在數據封裝方面 ，spring3mvc方法級別  struts2 類級別  spring3mvc開發效率高於 struts2

   2  spring3mvc 註解版基本上是零配置

   3  springmvc與spring是一家人，兼容性好

   4  struts2 存在安全漏洞

      能夠經過ongl表達式 格式化硬盤

      使用重定向定位到釣魚網站

 

14二、 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  主要用於獲取路徑變量的值

 

 

14三、 說說spring dao  

     1 對jdbc進行了封裝,提供了兩大模板技術封裝了jdbc步驟,數據源的實現,行映射器進行記錄與對象的轉換工做,

          使用daoSupport方便獲取模板

     2 給模板類注入數據源，以後使用模板類的api進行數據操做

 

 

6、 MyBatis

14四、 .ibatis/mybatis框架的優缺點?

    優勢: 易於上手和掌握

          sql寫在xml裏,便於統一管理和優化

  解除sql與程序代碼的耦合

  提供對象關係映射標籤,支持對象關係組建維護

  提供xml標籤,支持編寫動態sql

    

缺點: 可讀性低,調試很是困難,很是受限,沒法像jdbc那樣在代碼里根據邏輯實現複雜動態sql拼接

 

14五、 ibatis核心類的做用;MyBatis核心類的做用?

    ibatis:

SqlMapClientBuilder: 加載配置文件，返回一個會話

SqlMapClient: 具體的會話

SqlSession: 對數據的增刪查改

SqlMapSession: 進行數據庫操做

SqlSessionManager: 建立SqlSesstion的對象

SqlMapTransactionManager: 定義事務管理功能

 

    Mybatis:

SqlSessionFactory 每一個MyBatis應用的核心

 

14六、 mybatis/ibatis跟hibernate的比較;

Hibernate是全自動化的,只要配置映射文件,能夠爲咱們動態的生成sql

ibatis是半自動化的,須要咱們手動的編寫sql,ibatis簡單易學

Hibernate比較複雜,ibatis能夠細粒度的優化,而Hibernate是根據映射文件進行優化

 

14七、 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文件的執行

 

14八、 Ibatis中#與$的區別？

(1)#號它會將傳進來的數據都當成一個一個字符串,會給數據加一對雙引號,而$號它會將傳進來的數據直接顯示生成到sql中

(2)#號可以防止sql的注入，而$號沒法防止sql的注入

(3)$方式一把用於傳入數據庫對象，好比表名

 

7、 WebServices

14九、 怎麼調用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

     方法

          參數

15一、  你如何開發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" />

15二、  項目用了webservice幹什麼

1 公共模塊 數據交換  數據中心  五表權限

2 流程審批

3 便民服務 天氣預報 手機號碼歸屬地查詢

 webservice安全 以及大數據量

大數據量  在cxf框架中

1 快速信息集 @FastInfoset  2 對返回的數據進行壓縮 @GZIP

 

2 數據緩存，它須要編寫代碼來實現

 實際使用中，多線程下載文件的方式，webservice把數據打包到壓縮文件，比較本地的文件名與時間，決定是否從遠程服務端下載文件

 

15三、 安全問題：

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一種實現。

15四、 ejb

   1 ejb是sun公司java的一種規範，webservice是跨語言的

   2 webservice 是經過http協議發送soap協議,ejb是jndi訪問，底層協議rmi-iiop

   3 能夠把ejb暴露成webservice

 

8、 EJB

9、 DAO

15五、 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)

     

15六、  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

 

15七、 說說spring dao  

     1 對jdbc進行了封裝,提供了兩大模板技術封裝了jdbc步驟,數據源的實現,行映射器進行記錄與對象的轉換工做,

          使用daoSupport方便獲取模板

     2 給模板類注入數據源，以後使用模板類的api進行數據操做

 

15八、 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效率最好

15九、 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會合並

 

16一、 什麼是懶加載 懶加載用代理技術實現  如何解決session關閉致使的懶加載問題 解決的方案有缺點嗎  

   1 懶加載 真正須要數據的時候才向數據庫發送sql,好比調用load方法，不會發出sql,而在加載對象屬性時才發出了sql,實現了數據的延遲加載,get則否則

   2 使用openSessionInView模式解決，實則是一個過濾器，保持session一直在view一直打開

     1 session範圍擴大，從dao擴展到了其餘的層，session所暫用的資源不能獲得及時的釋放,效率降低

     2 事務擴大了

 

16二、 緩存  

   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:是否容許對象被寫入到磁盤

16三、 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語句  

 

16四、 hibernate 實體的3種狀態  

     1  瞬時狀態 ：剛new出來的對象，與session沒關聯,調用delete方法也會使對象進入瞬時狀

     2  持久化狀態:調用session的api，如save saveorupdate,load get進入持久化狀態，屬性的改變在事務提交的時候同步數據庫

     3  脫管狀態 ：調用了session的clear或者close evit 都使對象脫離了session的管理，狀態發生改變不會影響到數據庫

 

16五、 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：事務管理

 

16六、 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 沒法與第三方系統共存，不然緩存沒法控制

 

16七、 hibenrate 查詢方式  離線查詢

答：1.hql：適合各類查詢，可是動態條件查詢構造起來很不方便；

2.qbc：適合動態查詢，不適合統計查詢；

3.qbe：只適合簡單的查詢 ；

4.sql：可實現特定數據庫的sql，方便優化，移植性很差；

離線查詢：建立查詢條件（DetachedCriteria）時不須要session，但執行時（getExecutableCriteria）仍須要session

    

16八、 hibernate抓取策略  指的是如何查詢關聯數據 （有關聯實體與關聯集合）

 答：   join：鏈接抓取（即嵌套結果）---使用左外鏈接加載關聯數據，而此時的懶加載會失效；

select：查詢抓取（即嵌套查詢）---另外發送一條select語句抓取當前對象關聯的數據；

subselect：子查詢（即經過in）---先把全部的id查詢出來做爲條件後面select語句的條件，使用in找出；

批量抓取    batch-size設置，一次抓幾條

 

16九、  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關閉問題

 使用鏈接抓取致使懶加載失效問題

 沒法與第三方系統共存