Java基礎面試題

時間 2019-11-10

標籤 java 基礎面試欄目 Java 简体版

原文原文鏈接

1: Arraylist和Linkedlist的區別?

ArrayListcss

1）ArrayList底層數組結構，原理：數組複製html

2）底層自動擴容數組，初始爲10，每次擴容上次的1/2前端

3）善於查詢java

4）利用index按順序存儲mysql

LinkedListjquery

1）底層鏈表結構（雙鏈表）程序員

2）善於插入刪除數據web

3）特殊方法：addLast（），addFirst（），removeFirst（），remove（）刪除第一個；removeLast（）ajax

總結：ArrayList更適合讀取數據，linkedList更多的時候添加或刪除數據。正則表達式

ArrayList內部是使用可増長數組實現的，因此是用get和set方法是花費常數時間的，可是若是插入元素和刪除元素，除非插入和刪除的位置都在表末尾，不然代碼開銷會很大，由於裏面須要數組的移動。
LinkedList是使用雙鏈表實現的，因此get會很是消耗資源，除非位置離頭部很近。可是插入和刪除元素花費常數時間。

2:重載與重寫有什麼區別?

重寫：不一樣類中，方法體結構相同，邏輯代碼能夠不一樣，方法被定義爲final不能被重寫。

重載：同一類中，方法體結構相同參數列表類型和個數不能相同。

3: &和&&有什麼區別?

&和&&均可以做邏輯與，&它的左邊不管是true仍是false，右邊的條件都要進行判斷，&&它的左邊若是是false，右邊則不用進行判斷。

&能夠用做位運算符，將左邊和右邊兩個數轉換成二進制數而後進行與運算。

4:接口和抽象類有什麼區別?

抽象類特色：

1）不能被實例化（子類繼承後可實例化子類）

2）充當父類

3）有屬性，方法，構造方法，抽象方法

4）抽象類中抽象方法必須被重寫

5）子類有且只有一個父類

接口特色：

1）不能被實例化

2）充當父接口

3）有屬性，抽象方法（屬性必須初始化，且不能更改）

4）子類能夠實現多個接口

抽象類（abstract class）：
1：abstract 關鍵字修飾，而且沒有方法體
2：抽象類不能直接建立實例
3：抽象類只能被繼承，一個具體類繼承一個抽象類，必須實現全部抽象方法
接口（interface）：
1：實現接口的必定要實現接口裏定義的全部方法
2：接口能夠實現多重繼承
區別：
1：抽象類和接口都不可以實例化，但能夠定義抽象類和接口類型的引用
2：一個類若是繼承了某個抽象類或者實現了某個接口都須要對其中的抽象方法所有進行實現，不然該類仍然須要被聲明爲抽象類
3：接口比抽象類更加抽象，由於抽象類中能夠定義構造器，能夠有抽象方法和具體方法，而接口中不能定義構造器並且其中的方法所有都是抽象方法
4：抽象類中的成員能夠是private、默認、protected、public的，而接口中的成員全都是public的
5：抽象類中能夠定義成員變量，而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明爲抽象類，而抽象類未必要有抽象方法

6.接口能夠繼承接口，甚至能夠繼承多個接口；類能夠實現多個接口，只能繼承一個類。

5:寫出JDBC操做數據庫的步驟?
1：加載驅動
Class.forName("com.mysql.jdbc.Driver");
2：建立鏈接
Connection con = DriverManager.getConnection ("url", "1111", "1111");
3：建立語句
PreparedStatement ps = con.prepareStatement("select * from user");
4：執行語句
ResultSet rs = ps.executeQuery();
5：處理結果
while(rs.next()) {
rs.get.....（「」）；
}
6：關閉資源
finally {
if(con != null) {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

加載驅動-建立鏈接-建立語句-執行語句-處理結果-關閉資源

6: HashTable和HashMap有什麼區別?

1. HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口
2.主要區別在於HashMap容許空（null）鍵值（key）,因爲非線程安全，效率上可能高Hashtable
3.HashMap容許將null做爲一個entry的key或者value，而Hashtable不容許
4.最大的不一樣是，Hashtable的方法是Synchronize的，而HashMap不是

HashMap線程不安全。HashMap是map接口的子接口，是將鍵映射到值的對象，其中鍵和值都是對象，而且不能包含重複鍵，但能夠包含重複值。HashMap容許包含空鍵和空值，而HashTable不容許空鍵值。

HashTable線程安全。HashMap是HashTable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在於HashMap容許空鍵值，因爲非線程安全，因此效率上可能高於HashTable。

7;建立多線程的方式有幾種?分別是什麼?線程死鎖是如何產生的?如何防止線程死鎖現象?

方式：繼承Thread、實現 Runnable 接口
產生:
- 一個資源每次只能被一個進程使用
- 一個進程因請求發生阻塞時，依然對已得到的資源保持不放
- 進程已經得到資源使用權，可是一直未使用
- 同一個進程，頻繁的獲取資源的優先使用權，一直未釋放
防止：
加鎖順序（線程按照必定的順序加鎖）
加鎖時限（線程嘗試獲取鎖的時候加上必定的時限，超過期限則放棄對該

鎖的請求，並釋放本身佔有的鎖）
死鎖檢測（通常是將全部的鎖存放於map對象中，檢測map中的鎖）

8: String,StringBuffer, StringBuilder 的區別?

1.運行速度快慢爲：StringBuilder > StringBuffer > String
- （String爲字符串常量，而StringBuilder和StringBuffer均爲字符串變量，即String對象一旦建立以後該對象是不可更改的）
2.StringBuilder是線程不安全的，而String、StringBuffer是線程安全的

9: TCP和UDP的區別?哪一個是三次握手協議?

TCP穩定性較高，但效率低。TCP三次握手協議。
UDP通信相反，效率較高，但穩定性較差

10: JSP的經常使用指令有哪些?

三個編譯指令爲：page、include、taglib
七個動做指令爲：jsp:forward、jsp:param、jsp:include、jsp:plugin、

jsp:useBean、jsp:setProperty、jsp:getProperty

11: DI有幾種方式、分別是什麼，你經常使用的是哪一種方式?

1：Setter方法
2：構造器
3：接口注入註解實現注入(經常使用)

12; Mybatis中$和#在xm1中取值有什麼不一樣?

1.mybatis 爲咱們提供了兩種支持動態 sql 的語法：#{} 以及 ${}
2.#方式可以很大程度防止sql注入，$方式沒法防止Sql注入
3.$方式通常用於傳入數據庫對象，例如傳入表名
4.＃{}將傳入的數據都當成一個字符串，會對自動傳入的數據加一個雙引號
5.通常能用#的就別用$

13: Session和Cookie有什麼區別?

Cookie和session作狀態管理

Cookie存在客戶端、session數據放在服務器上
cookie不是很安全，別人能夠分析存放在本地的COOKIE並進行修改
session會在必定時間內保存在服務器上。當訪問增多，會比較佔用你服務器

的性能
單個cookie在客戶端的限制是3K，就是說一個站點在客戶端存放的COOKIE

不能大於3K

14: GET和POST請求的區別?

GET：
1：從服務器上獲取數據，通常不能使用在寫操做接口
2：由URL所限制，GET方式傳輸的數據大小有所限制，傳送的數據量不超過2KB
3：請求的數據會附加在URL以後，以？分隔URL和傳輸數據，多個參數用&鏈接
4：安全性差
POST:
1：向服務器提交數據,通常處理寫業務
2：POST方式傳送的數據量比較大，通常被默認爲沒有限制
3：安全性高
4：請的求的數據內容放置在HTML HEADER中

15:轉發(forward) 和重定向(redirect)的區別?

1：效率上
轉發（forward） > 重定向（redirect）
2：顯示上
重定向（redirect）：顯示新的URL
轉發（forward）：地址欄不變
3：數據上
轉發（forward）：能夠共享request裏面的數據
重定向（redirect）：不能
4：請求次數
重定向（redirect）是兩次
轉發（forward）是一次

16: Hibernate與Mybatis區別?

1：hibernate的擴展性和移植性比mybatis強
2：hibernate不須要寫sql語句，會自動生成，而mybatis則須要寫sql

語句
3：hibernate支持事務、一級緩存、二級緩存、查詢緩存等
4：hibernate本身提供分頁功能，mybatis須要配置分頁插件

17: 列舉struts2常見的組件有哪些?常見的配置標籤有哪些?返回值類型有哪些?

組件：
strutsParperAndExecuteFilter
Action
Result
Interceptor
標籤：
package
action
result
param
interceptor
返回值類型：
dispatcher
redirect
redirectAction
stream
json

18: 用最有效率的方法算出2乘以8等於多少?

2 << 3

19: Spring常見的註解有哪些?

@Autowired--自動裝配
@Component--自動支持自動裝配
@Repository--DAO層實現
@Service--Service層實現
@Controller--Web層實現

28: Debug模式下，快捷鍵有哪些，分別表明什麼?

F5：進入方法內
F6：執行下一步
F7：跳出方法外
F8：執行到下一個斷點

21: Tomcat如何修改端口號，如何清除項目緩存，默認併發量是多少?

端口：server.xml
項目緩存：刪除work文件夾下的文件
併發：150-200

22: final, finally, finalize的區別?

final—修飾符（關鍵字）
若是一個類被聲明爲final，意味着它不能再派生出新的子類，不能做爲父類被繼承。
一個類不能既被聲明爲 abstract的，又被聲明爲final的，被聲明爲final的方法也一樣只能使用，不能重載
finally—異常處理時提供 finally 塊來執行操做
finally塊則是不管異常是否發生，都會執行finally塊的內容
finalize—方法名
finalize() 方法是在垃圾收集器刪除對象以前對這個對象調用的，它是在object類中定義的，全部的類都繼承了它

23:一個漢字幾個字節，一個char類型的變量，能夠儲存一個漢字嗎，爲何能夠或者不能夠?

兩個字節，能夠存儲，前提是漢字必須是Unicode編碼

24:談談Spring AOP的原理?

AOP稱爲面向切面編程
用於處理系統中分佈於各個模塊的橫切關注點，好比事務管理、日誌、緩存

等等實現AOP功能關鍵是採用代理技術，主要分爲靜態代理(AspectJ)和動態代

理，JDK中採用Proxy類產生動態代理的方式爲某個接口生成實現類，若是要

爲某個類生成子類，則能夠用CGLIB。

25:簡要說明SSH框架搭建步驟?

1：Struts2
- 導包
- 加載struts.xml
- 配置web.xml
- filter
   2：Struts2+Spring
- 導中間包、Spring包
- 增長Spring的配置文件Applicationcontext.xml
- 配置web.xml
- context和監聽
   3：Hibernate
- 導包
- 增長hibernate的配置文件hibernate.hbm.cfg和表的映射文件
- 配置數據庫的方言和鏈接、加載映射文件
   4：Hibernate+Spring
- 導中間包
- 在spring的配置文件中加載hibernate的配置信息

26:簡要說明SSM框架搭建步驟?

1: Spring
- 導包
- 增長Spring的配置文件Applicationcontext.xml
- 配置web.xml
2：springMVC
- 導包
- 增長springMVC的配置文件context-dispatcher.xml
- 配置web.xml
3：mybatis
- 導包
- 增長mybatis的配置文件mybatis-config.xml
- 將mybatis的配置文件在spring和springMVC中進行引用和配置

27:多線程中run和start方法有什麼區別?

Thread的start纔是正在開啓線程;Run只是調用了一個普通方法，並無啓動另外一個線程，程序仍是會按照順序執行相應的代碼。Start則表示，從新開啓一個線程，沒必要等待其餘線程運行完，只要獲得cup就能夠運行該線程。

28:靜態變量和實例變量有什麼區別?

靜態變量前面要加static，實例變量不用。實例變量屬於對象的屬性，必須建立了實例對象，才能夠被使用，靜態變量不屬於某個實例對象，而是屬於類，也叫類變量，不用建立任何實例對象就會被使用。

29:先後臺數據交互的方式有哪些?

json、file、xml、jsonp等

30:字節流和字符流有什麼區別?

字節流：按字節讀寫
字符流：按字符
一般在處理文本時優先使用字符流，其餘的用字節流

字節流在操做時自己不會用到緩衝區（內存），是文件自己直接操做的，而字符

流在操做時使用了緩衝區，經過緩衝區再操做文件

31: Redis支持哪些數據類型的存儲?

string、list、set、zset、hash

32: Java如何調用Redis進行數據操做，並列舉增刪改查操做?

1.導包

2. Jedis jd = new Jedis(IP);

3. jd.ping();//PONG

33: Nosql主要支持哪兩種數據存儲系統?

key-value---Redis
文檔存儲-----MongoDB

34: MongoDB的體系邏輯結構，主要有什麼組成?

文檔(document)、集合(collection)、數據庫(database)

35: Redis和MongoDB分別應用於哪些應用場景?

Redis：數據量較小的更性能操做和運算上

MongoDB:主要解決海量數據的訪問效率問題

36: Java如何連接MongoDB,寫出邏輯代碼?

導包

//創建鏈接
MongoClient mc = new MongoClient("192.168.168.220", 27017); MongoDatabase db = mc.getDatabase("db1");//數據庫名稱

37:如何給張表增長一個字段，寫出sq1語句?

alter table 表名 add 字段類型 NOT NULL Default 0;

38: ==與equals有什麼區別?

==：比較兩個數據內存地址是否相同

equals：比較兩個數據值是否同樣

39: ++i與i++的區別?

++i:先賦值，後運算

i++：先運算，後賦值

40: List和Map有什麼區別?

list：
- 鏈表
- 有序
- 繼承Collection(set也是)
- 能夠有重複的對象值，可是對象下標不能重複
Map：
- key-value
- 無序
- 鍵不能有重複的值能夠用

41: Integer與int的區別?

int 是基本數據類型，初值爲0。Integer是int的包裝類，初值爲null
Integer緩存：注意拆箱和裝箱（-128-127之間）
原始類型：boolean，char，byte，short，int，long，float，double
包裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

42:分別寫出oracle、mysq1的分頁關鍵詞?

oracle：rownum關鍵詞、row_number()函數
mysql：limit 0,5 / limit 5;

43:談談你對MVC的理解?

MVC：是一個框架設計模式，其中M（模型）、V（視圖）、C（控制器）
視圖：視圖向用戶顯示相關的數據，並接受用戶的輸入。視圖不進行任何業

務邏輯處理。如：jsp、html等
模型：表示業務數據和業務處理。屬於數據模型，如:entity、jdbc、

hibernate、mybatis等
控制器：接收、響應用戶請求，servlet、action、controller等

44、若是equals方法比較爲true,那麼它們的Hashcode值必定相同嗎?若是hashcode相同，那麼equals方法比較一定爲true嗎?

不必定相同；必定

45:簡述servlet生命週期?

經過調用 init () 方法進行初始化；調用 service() 方法來處理客戶端的請求；經過調用 destroy() 方法終止（結束）Servlet 是由 JVM 的垃圾回收器進行垃圾回收的；

46:進程和線程的區別是什麼?

- 進程是資源的分配和調度的一個獨立單元，而線程是CPU調度的基本單元
- 同一個進程中能夠包括多個線程
- 進程結束後它擁有的全部線程都將銷燬，而線程的結束不會影響同個進程中的其餘線程的結束
- 線程共享整個進程的資源（寄存器、堆棧、上下文），一個進行至少包括一個線程
- 進程的建立調用fork或者vfork，而線程的建立調用pthread_create
- 線程中執行時通常都要進行同步和互斥，由於他們共享同一進程的全部資源

47:進程的幾種狀態分別是什麼?

就緒狀態：
當進程已分配到除CPU之外的全部必要的資源，只要得到處理機即可當即執行，這時的進程狀態稱爲就緒狀態。
運行狀態：
當進程已得到處理機，其程序正在處理機上執行，此時的進程狀態稱爲運行狀態。
阻塞狀態：
正在運行的進程，因爲等待某個事件發生而沒法執行時，便放棄處理機而處於阻塞狀態。引發進程阻塞的事件可有多種，例如，等待I/O完成、申請緩衝區不能知足、等待信件(信號)等。
狀態轉換：
就緒→運行：處於就緒狀態的進程，當進程調度程序爲之分配了處理機後，該進程便由就緒狀態轉變成運行狀態。
運行→就緒：處於運行狀態的進程在其運行過程當中，因分配給它的一個時間片已用完而不得不讓出處理機，因而進程從運行狀態轉變成就緒狀態。
運行→阻塞：正在運行的進程因等待某種事件發生而沒法繼續運行時，便從運行狀態變成阻塞狀態。
阻塞→就緒：處於阻塞狀態的進程，若其等待的事件已經發生，因而進程由阻塞狀態轉變爲就緒狀態。

48: JDK和JRE的關係區別是什麼?

JDK是Java的開發工具，JDK包含JRE。
JRE只是Java程序的運行環境，它最核心的內容就是JVM（Java虛擬機）

及核心類庫。

49: SpringMVC運行原理是什麼?

客戶端請求提交到DispatcherServlet
2.由DispatcherServlet控制器查詢一個或多個HandlerMapping，找到

處理請求的Controller
3.DispatcherServlet將請求提交到Controller
4.Controller調用業務邏輯處理後，返回ModelAndView
5.DispatcherServlet查詢一個或多個ViewResoler視圖解析器，找到

ModelAndView指定的視圖
6.視圖負責將結果顯示到客戶端
DispatcherServlet是整個Spring MVC的核心。它負責接收HTTP請求

組織協調Spring MVC的各個組成部分

50：用戶在瀏覽器中輸入URL以後，發什麼了什麼?寫出請求和響應的流程

1：域名解析
2：TCP三次握手
3：瀏覽器向服務器發送http請求
4：瀏覽器發送請求頭信息
5：服務器處理請求
6：服務器作出應答
7：服務器發送應答頭信息
8：服務器發送數據
9：TCP鏈接關閉

51:響應結果狀態碼有哪些，並給出中文含義?

1**：信息性狀態碼
2**：成功狀態碼
200：請求正常成功
204：指示請求成功但沒有返回新信息
206：指示服務器已完成對資源的部分 GET 請求
3**：重定向狀態碼
301：永久性重定向
302：臨時性重定向
304：服務器端容許請求訪問資源，但未知足條件
4**：客戶端錯誤狀態碼
400：請求報文中存在語法錯誤
401：發送的請求須要有經過HTTP認證的認證信息
403：對請求資源的訪問被服務器拒絕了
404：服務器上沒法找到請求的資源
5**：服務器錯誤狀態碼
500：服務器端在執行請求時發生了錯誤
503：服務器暫時處於超負載或正在進行停機維護，如今沒法處理請求

52: 什麼是ORM?

對象關係映射（Object Relational Mapping，簡稱ORM）
爲了解決面向對象與關係數據庫存在的互不匹配的現象的技術，ORM是經過使用描述對象和數據庫之間映射的元數據(元數據通常採用XML格式)，將程序中的對象自動持久化到關係數據庫中，Java典型的ORM中間件有:Hibernate,ibatis,speedframework,mybatis

53:什麼是IOC?

(Inversion of Control,簡稱IOC)，即控制反轉，是一種設計模式，是spring的核心。能夠解決代碼耦合，由IOC容器來管理對象的生命週期、依賴關係等。

54:jsp的做用域有哪些?

page：當前頁面有效
request：一次會話請求有效
session：瀏覽器進程，只要瀏覽器不關閉，則一直有效
application：服務器只要運行，則有效

55: sleep和wait 有什麼區別?

sleep：
1：屬於Thread類，表示讓一個線程進入睡眠狀態，等待必定的時間以後，自動醒來進入到可運行狀態，不會立刻進入運行狀態
2：sleep方法沒有釋放鎖
3：sleep必須捕獲異常
wait：
1：屬於Object，一旦一個對象調用了wait方法，必需要採用notify()和notifyAll()方法喚醒該進程
2：wait方法釋放了鎖
3：wait不須要捕獲異常

56: Java 中的final關鍵字有哪些用法?

1：修飾類：表示該類不能被繼承
2：修飾方法：表示方法不能被重寫
3：修飾變量：表示變量只能一次賦值之後值不能被修改（常量）

57: Error和Exception有什麼區別?何時須要捕獲異常，何時須要拋出異常?

1:Error表示系統級的錯誤和程序沒必要處理的異常,有可能恢復，可是恢復比較困難的嚴重問題。
2：Exception表示須要捕捉或者須要程序進行處理的異常，是一種設計或實現問題；也就是說，它表示若是程序運行正常，從不會發生的狀況
異常處理的原則：
1：System.out.println是高代價的。調用System.out.println會下降系統吞吐量
2：在生產環境中別用異常的printStackTrace()方法。
3：若是你不能處理異常，不要捕獲該異常
4：若是要捕獲，應在離異常源近的地方捕獲它
5：捕獲的異常必定要作處理
6：能夠自定義異常
7：就近原則

58:寫出冒泡排序的程序代碼?

59:數據庫集羣模式下，如何保證主從數據庫的數據一致性?

以mysq1數據庫爲例進行說明配置步驟？

1：開啓全部服務器的二進制文件
2：開啓全部從服務的IO和SQL線程
3：配置主從鏈接的用戶信息和主從信息
4：開啓3306端口號

60: 簡述JAVA中I/O和NIO的區別?

NIO:是一種new IO，其目的是爲了實現高速IO的代碼，將IO操做並轉換爲操做系統，屬於非阻塞型，java.nio.*，是以塊（緩衝區）的形式就行數據的傳輸。
IO：是以流的方式就行數據的傳輸，屬於阻塞型，影響程序的性能
傳統阻塞IO，若是你要read/write( byte[10M])一個10M的文件，一旦調用了read/write( byte[10M])這個方法，就得等10M所有read/write，方法底層纔會返回。
非阻塞線程，調用read/write( byte[10M])方法當即返回，固然這並不能表明10M已經read/write完成，你須要檢測這個byte[10M]的緩衝區。

61:簡述單例模式的特徵和應用場景?

單例模式（Singleton），也叫單子模式，是一種經常使用的軟件設計模式。在應用這個模式時，單例對象的類必須保證只有一個實例存在。
單例模式只容許建立一個對象，所以節省內存，加快對象訪問速度
單例模式要素：
a.私有構造方法
b.私有靜態引用指向本身實例
c.以本身實例爲返回值的公有靜態方法
餓漢式：單例實例在類裝載時就構建，急切初始化。（預先加載法）
優勢
1.線程安全
2.在類加載的同時已經建立好一個靜態對象，調用時反應速度快缺點
資源效率不高，可能getInstance()永遠不會執行到，但執行該類的其餘靜態方法或者加載了該類（class.forName)，那麼這個實例仍然初始化
懶漢式：單例實例在第一次被使用時構建，延遲初始化。
應用場景：
- 須要頻繁實例化而後銷燬的對象
- 建立對象時耗時過多或者耗資源過多，但又常常用到的對象
- 有狀態的工具類對象
- 頻繁訪問數據庫或文件的對象
- 網站計數器，通常是採用單例模式實現
- 因爲配置文件通常都是共享資源，即web應用的配置對象的讀取，通常採用單例模式來實現。如：spring的配置文件的讀取等
- 多線程的線程池的設計通常也是採用單例模式
- 數據庫鏈接池的設計

62:寫出將1000個存在重複手機號的號碼池去重的JAVA代碼?

63:Java接口的修飾符有哪些?

public、final、abstract

64:Java支持的數據類型有哪些?什麼是自動拆裝

8種基本數據類型：
byte 8位取值範圍 -2^7 ~ 2^7 -1
short 16位取值範圍 -2^15 ~ 2^15 - 1
char 16位取值範圍 0 ~ 2 ^16 - 1
boolean 位數不明確取值範圍 true false
int 32位取值範圍 -2^31 ~ 2^31 - 1
long 64位取值範圍 -2^63 ~ 2^ 63 - 1
float 32位取值範圍 1.4e-45 ~ 3.40e38
double 64位取值範圍 4.9e-324 ~ 1.79e308
注意：
須要注意的是，String不是基本數據類型，而是引用類型
在jdk1.5中引入了自動拆裝箱的新特性，自動拆裝箱，是指基本數據類型和引用數據類型之間的自動轉換
基本類型轉換成包裝類型，稱爲裝箱
Integer intObjct = new Integer(2); //裝箱
//Integer intObjct = 2 //自動裝箱
//自動裝箱，若是一個基本類型值出如今須要對象的環境中，會自動裝箱
如Integer 和 int 能夠自動轉換； Float和float能夠自動轉換

65:Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

round方法，他表示「四捨五入」，算法爲Math.floor(x+0.5),即將原來的數字加上0.5後再向下取整
十二、-11

66:寫一單實例類要求精簡，清晰? (單例拋式)

餓漢式單例：
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
懶漢式單例：
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static synchronized Singleton getInstance(){
if (instance == null)
instance ＝ new Singleton();
return instance;
}
}

67:構造器(constructor)是否可被重寫(override)是否可被重載?是否可被繼承？

構造器不能被繼承，所以不能重寫Override，但能夠被重載Overload

68:JSP和Servlet有哪些相同點和不一樣點，他們之間的聯繫是什麼？

- jsp本質就是servlet
- jsp應用於頁面顯示，servlet應用於邏輯控制
- setvlet中沒有內置對象，jsp中的內置對象都是必須經過HttpServletRequest對象，HttpServletResponse對象及HttpServlet對象獲得

69:簡述synchronized和java.util.concurrent.locks.Lock的異同？

- Lock能完成幾乎全部synchronized的功能，並有一些後者不具有的功能，如鎖投票、定時鎖等候、可中斷鎖等候等
- synchronized 是Java內置的關鍵字，Lock 則是JDK 5中出現的一個包
- synchronized 同步的代碼塊能夠由JVM自動釋放；Lock 須要程序員在finally塊中手工釋放

70:解析xml和exce1分別使用什麼技術?

xml-dom4j
excel-poi、jxl

71:如何發佈spring boot項目，簡述步驟?

發佈JAR包、發佈WAR包、部署到自動化容器中

72:什麼是java序列化，如何實現java序列化?

概念：
序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化（將對象轉換成二進制）。能夠對流化後的對象進行讀寫操做，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流進行讀寫操做時所引起的問題
序列化：把Java對象轉換爲字節序列的過程。
反序列化：把字節序列恢復爲Java對象的過程。
實現：
將須要被序列化的類實現Serializable接口
注意：
被關鍵字static、transient修飾的變量不能被序列化。在被序列化後，transient修飾的變量會被設爲初始值。如int型的是0、對象型的是null.

73:在JAVA中，如何跳出當前的多重嵌套循環?

用break; return 方法。

74:面向對象的特徵有哪些方面?

- 抽象：
抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。抽象並不打算了解所有問題，而只是選擇其中的一部分，暫時不用部分細節。抽象包括兩個方面，一是過程抽象，二是數據抽象。
- 繼承：
繼承是一種聯結類的層次模型，而且容許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類能夠從現有的類中派生，這個過程稱爲類繼承。新類繼承了原始類的特性，新類稱爲原始類的派生類（子類），而原始類稱爲新類的基類（父類）。派生類能夠從它的基類那裏繼承方法和實例變量，而且類能夠修改或增長新的方法使之更適合特殊的須要。
- 封裝：
封裝是把過程和數據包圍起來，對數據的訪問只能經過已定義的界面。面向對象計算始於這個基本概念，即現實世界能夠被描繪成一系列徹底自治、封裝的對象，這些對象經過一個受保護的接口訪問其餘對象。
- 多態性：
多態性是指容許不一樣類的對象對同一消息做出響應。多態性包括參數化多態性和包含多態性。多態性語言具備靈活、抽象、行爲共享、代碼共享的優點，很好的解決了應用程序函數同名問題。

75: Collection和Collections的區別?

Collection是集合類的上級接口
繼承與他的接口主要有Set 和List.
Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各類集合的搜索、排序、線程安全化等操做。

76:同步和異步有何異同，在什麼狀況下分別使用他們?舉例說明？

若是數據將在線程間共享。例如正在寫的數據之後可能被另外一個線程讀到，或者正在讀的數據可能已經被另外一個線程寫過了，那麼這些數據就是共享數據，必須進行同步存取。
當應用程序在對象上調用了一個須要花費很長時間來執行的方法，而且不但願讓程序等待方法的返回時，就應該使用異步編程，在不少狀況下采用異步途徑每每更有效率

77:abstract class和interface有什麼區別?

78:GC是什麼?爲何要有GC?

GC是垃圾收集的意思（Gabage Collection）,內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰，
Java提供的GC功能能夠自動監測對象是否超過做用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操做方法

79:請說出你所知道的線程同步的方法?

wait():使一個線程處於等待狀態，而且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException異常。 notify():喚醒一個處於等待狀態的線程，注意的是在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM肯定喚醒哪一個線程，並且不是按優先級。
Allnotity():喚醒全部處入等待狀態的線程，注意並非給全部喚醒線程一個對象的鎖，而是讓它們競爭。

80:JSP的內置對象及方法?

request表示HttpServletRequest對象。它包含了有關瀏覽器請求的信息，而且提供了幾個用於獲取cookie, header, 和session數據的有用的方法。
response表示HttpServletResponse對象，並提供了幾個用於設置送回瀏覽器的響應的方法（如cookies,頭信息等）
out對象是javax.jsp.JspWriter的一個實例，並提供了幾個方法使你能用於向瀏覽器回送輸出結果。
pageContext表示一個javax.servlet.jsp.PageContext對象。它是用於方便存取各類範圍的名字空間、servlet相關的對象的API，而且包裝了通用的servlet相關功能的方法。 session表示一個請求的javax.servlet.http.HttpSession對象。
Session能夠存貯用戶的狀態信息 applicaton 表示一個javax.servle.ServletContext對象。這有助於查找有關servlet引擎和servlet環境的信息 config表示一個javax.servlet.ServletConfig對象。該對象用於存取servlet實例的初始化參數。
page表示從該頁面產生的一個servlet實例

81:如何現實servlet的單線程模式?

<%@ page isThreadSafe=」false」%>

82:面間對象傳遞的方法?

request，session，application，cookie等

83:Request對象的主要方法?

setAttribute(String name,Object)：設置名字爲name的request的參數值
getAttribute(String name)：返回由name指定的屬性值
getAttributeNames()：返回request對象全部屬性的名字集合，結果是一個枚舉的實例
getCookies()：返回客戶端的全部Cookie對象，結果是一個Cookie數組
getCharacterEncoding()：返回請求中的字符編碼方式
getContentLength()：返回請求的Body的長度
getHeader(String name)：得到HTTP協議定義的文件頭信息
getHeaders(String name)：返回指定名字的request Header的全部值，結果是一個枚舉的實例
getHeaderNames()：返回因此request Header的名字，結果是一個枚舉的實例
getInputStream()：返回請求的輸入流，用於得到請求中的數據 getMethod()：得到客戶端向服務器端傳送數據的方法
getParameter(String name)：得到客戶端傳送給服務器端的有name指定的參數值
getParameterNames()：得到客戶端傳送給服務器端的全部參數的名字，結果是一個枚舉的實例
getParameterValues(String name)：得到有name指定的參數的全部值
getProtocol()：獲取客戶端向服務器端傳送數據所依據的協議名稱
getQueryString()：得到查詢字符串
getRequestURI()：獲取發出請求字符串的客戶端地址
getRemoteAddr()：獲取客戶端的IP地址
getRemoteHost()：獲取客戶端的名字
getSession([Boolean create])：返回和請求相關
Session getServerName()：獲取服務器的名字
getServletPath()：獲取客戶端所請求的腳本文件的路徑
getServerPort()：獲取服務器的端口號
removeAttribute(String name)：刪除請求中的一個屬性

84:J2ee經常使用的設計模式?說明工廠模式?

Java中的23種設計模式：
Factory（工廠模式）， Builder（建造模式），
Factory Method（工廠方法模式）， Prototype（原始模型模式），Singleton（單例模式）， Facade（門面模式），
Adapter（適配器模式）， Bridge（橋樑模式），
Composite（合成模式）， Decorator（裝飾模式），
Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解釋器模式），
Visitor（訪問者模式）， Iterator（迭代子模式），
Mediator（調停者模式）， Memento（備忘錄模式），
Observer（觀察者模式）， State（狀態模式），
Strategy（策略模式）， Template Method（模板方法模式），
Chain Of Responsibleity（責任鏈模式）
工廠模式：工廠模式是一種常常被使用到的模式，
根據工廠模式實現的類能夠根據提供的數據生成一組類中某一個類的實例，
一般這一組類有一個公共的抽象父類而且實現了相同的方法，可是這些方法針對不一樣的數據進行了不一樣的操做。
首先須要定義一個基類，該類的子類經過不一樣的方法實現了基類中的方法。
而後須要定義一個工廠類，工廠類能夠根據條件生成不一樣的子類實例。
當獲得子類的實例後，開發人員能夠調用基類中的方法而沒必要考慮到底返回的是哪個子類的實例。

85:List、Map、Set三個接口，存取元素時，各有什麼特色?

List 以特定次序來持有元素，可有重複元素。
Set 沒法擁有重複元素,內部排序。
Map 保存key-value值，value可多值。

86:如何對數據庫作優化?

1：數據庫設計
數據庫表：字段類型、字段長度、註釋、字段命名規範
數據庫索引：外鍵、關聯字段、查詢頻率比較高的字段、
若是數據表字段>20，則最多支持16個索引
若是數據表字段<20，則根據查詢頻率字段來定
數據庫視圖：至關於一張臨時表，業務中，儘可能少使用
數據庫引擎：根據業務，選擇對應的表引擎技術
數據庫存儲過程：儘可能少用
數據庫字符：UTF-八、或者和頁面字符保持一致
數據庫監聽器/觸發器：通常用於調度任務或者備份還原
2：業務調用的sql語句優化
xml：
儘可能少關聯表，效率最高關聯4張表，若是多於4張表，則須要開啓兩個連接事務，可是這兩個事務，必須在一個service當中。
若是是查詢語句，則不建議使用*
若是是查詢語句，where條件後面，最好使用索引字段進行關聯
3：數據庫服務器的搭建（集羣）
主從配置：
讀寫分離：
自動化（容器）：

87:如何對JVM進行性能調優?

88:如何實現集羣模式下，session共享?

一：Tomcat自己配置
1：登陸成功以後，將session信息存放到redis中，利用攔截器來過濾查找session（推薦）
2：配置tomcat文件server.xml
<Engine name="Catalina" defaultHost="localhost" jvmRoute="8081">
<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
若是尚未session信息同步，則須要在項目的啓動容器web.xml中，在display-name標籤下面，添加<distributable/>
二：使用redis服務器

89: 程序員若是想換行，應該怎麼處理?

回車

90:公司若是想換一個燈泡，請問須要幾個java工程師?

91: Hibernate一級緩存和二級緩存的區別?

一、一級緩存是session獨享，默認開啓，無需配置

二、二級緩存是session共享，須要在配置文件中開啓，能夠指定緩存區域塊

92: Hibernate有幾種查詢方式?

HQL語句查詢、Criteria查詢、NativeSQL查詢

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

1、下列說法正確的是( )

A、java的數組能夠隨時改變大小

B、String字符串的長度和大小都是不可變的

C、boolean類型變量默認初始值爲true（false）

D、Java虛擬機是實現跨平臺的基礎

2、下面代碼運行結果爲:( A )

public static void main(String[] args){

int x = 1, y = 1, z = 1;

if(x--==1&&y++==1 ||z++= =1) {

System.out.println(「x=」+x+」,y=」+y+」,z=」+z;);

}

A: x=0,y=2,z=1 B: x=1,y=2,z=1

C: 沒有輸出 D:x=0,y=2,z=2

3、下列沒有語法編譯錯誤的是：( )

A. public static void main(String[] args){

byte b1 = 1;

byte b2 = 2;

byte b = b1+b2;

}

B. public static void main(String[] args){

int n = 100;

while(n>0){

System.out.println(n);

}

C. public static void main(String[] args){

int n;

for(int i = 0;i<10;i++){

n+= i ;

}

D. public static void main(String[] args){

int n = 100;

for(;;){

}

System.out.println(n);

}

4、如下程序的輸出結果爲（C）

public class Test{

public static void main (String[] args){

int[] a = {1,2,3,4,5};

int[] b = change(a);

b[1] = 7;

System.out.println(a[1]);

}

public static int[] change(int[] a){

a[1] = 6;

return a ;

}

A、編譯錯誤 B、運行出錯 C、6 D、7

5、對於構造函數,下列敘述不正確的是（C）

A、構造函數是類的特殊函數，他的方法名必須與類名相同

B、構造函數沒有返回值類型

C、一個類能夠有多個構造函數

D、構造函數在類加載時調用

6、給定java代碼以下：

class Parent{

int i=2;

public Parent() {

System.out.println("parent");

}

class Child extends Parent{

int i=5;

public Child() {

System.out.println("child");

}

public class Test {

public static void main(String[] args) {

Parent p = new Child();

System.out.println(p.i);

}

運行編譯後，輸出結果爲( )

A. child 2 B. child 5 C.parent child 2 D.parent child 5

7、如下程序的輸出結果爲：（）

class ClassA{

int value;

}

public class TestClassA{

public static void main(String[] args){

int value = 10;

changeInt(value);

System.out.println(value);

ClassA ca = new ClassA();

ca.value = 10;

changeObject(ca);

System.out.println(ca.value);

}

public static void changeInt(int value){

++value;

}

public static void changeObject(ClassA ca){

ca.value++;

}

A.編譯不經過 B.10,11 C. 10,10 D. 11,11

8、閱讀如下代碼，能正確刪除全部」java」的是: ( B)

public class Test1 {

public static void main(String[] args) {

List<String> list = new ArrayList<>();

list.add("aa");

list.add("java");

list.add("bb");

list.add("java");

}

A、 for(int i=0;i<list.size();i++){

if("java".equals(list.get(i))){

list.remove(i);

}

B、for(int i=list.size()-1;i>=0;i--){

if("java".equals(list.get(i))){

list.remove(i);

}

C、list.remove(「java」);

D、list.removeAll(「java」);

9、下面程序的輸出結果爲( )

public class Test {

public static String outPut="";

public static void foo(int i){

try {

if(i==1)

throw new Exception();

outPut+="1";

} catch (Exception e) {

outPut+="2";

return;

}finally{

outPut+="3";

}

outPut+="4";

}

public static void main(String[] args) {

foo(0);

System.out.println(outPut);

foo(1);

System.out.println(outPut);

}

A、134 13423 B、1 134 C、134 34 D、134 134134

10、下面程序的輸出結果爲( )

class T1{

int i=0;

public void Test1(){

System.out.println(i);

}

public void Test2(){

System.out.println(i);

}

class T2 extends T1{

int i=2;

public void Test2(){

System.out.println(i);

}

public class TestCase {

public static void main(String[] args) {

T1 test = new T2();

test.Test1();

test.Test2();

System.out.println(test.i);

test = (T2)test;

System.out.println(test.i);

}

A、0 0 0 0 B、0 2 0 0 C、0 2 2 2 D、編譯不能經過

2、問答題(每題5分,共60分)

1、描述你所理解的java中抽象類和接口的概念

2、簡述面向對象的特徵以及做用

3、HashMap和HashTable有什麼區別,ArrayList和LinkedList?

4、攔截器和過濾器的應用場景是什麼,有什麼區別

攔截器和過濾器的區別：

一、過濾器是依賴於Servlet容器，攔截器不依賴於容器

二、過濾器是能夠攔截全部請求，攔截器只針對Action起做用

三、過濾器只在容器初始化執行一次，攔截器能夠屢次執行

四、過濾器不能訪問值棧中的對象，攔截器能夠訪問值棧中的對象

五、過濾器底層實現：回調

攔截器底層實現：反射

5、如何理解設計模式,用代碼寫出一種你最熟悉的設計模式

6、cookie和session的做用,區別以及應用場景,分別用圖畫出工做原理？

cookie和Session

狀態管理:

web應用程序是基於HTTP協議的，而HTTP協議是無狀態的協議，無狀態也就是說一次請求，一次響應以後即斷開鏈接，而同一個用戶的下一次請求須要從新創建鏈接，但在有時候服務器須要判斷是否爲同一個用戶的屢次操做，因此這些時候須要將用戶的屢次請求當作說一個總體來看待，而且將屢次交互涉及到的數據進行保存下來

狀態：交互產生的數據

管理：屢次交互對數據的修改

實現狀態常見的有兩種方式

cookie：瀏覽器客戶端狀態管理，將狀態保存在瀏覽器客戶端

session：服務器狀態(數據)管理，將狀態保存在服務器

Cookie：實現原理

一、瀏覽器客戶端第一次訪問服務器端返回響應數據時，響應數據包中以Set-Cookie消息頭方式給瀏覽器返回cookie信息

Set-Cookie：name=張三

Set-Cookie：count =10；

二、瀏覽器接受服務器端的響應數據包以後，解析響應數據包，獲取cookie信息，保存在客戶端

三、客戶端在後續每一次訪問時，須要攜帶保存cookie，以cookie請求消息頭方式發給服務器

cookie：name=張三，count=10

四、服務器接受請求以後，獲取請求數據包中cookie信息進行操做，完成HTTP狀態管理

Session

一、客戶端發送第一次請求，服務器端會建立一個session對象，把相關的數據存儲到session中，並給該對象分配一個32位的惟一id，通常稱之爲JSESSIONID

二、在服務器第一次給客戶端返回響應時，把JESSIONID以Set-Cookie消息頭方式帶回給瀏覽器客戶端

Set-Cookie：JESSIONID=xxxx

三、在客戶端接受到響應數據包以後，解析出JESSIONID以cookie形式存儲在瀏覽器客戶端

四、在後續瀏覽器客戶端每一次發送請求時，以Cookie消息頭方式把JESSIONID發送給服務器

Cookie：JESSIONID=xxxx

五、服務器獲取JESSIONID後，根據JESSION去找相應的session 對象，完成狀態管理

7、什麼是MVC,說下你對MVC的理解？

8、struts2和springmvc比較有什麼共同點和不一樣點,分別畫出執行流程圖

9、什麼是IOC和AOP,底層實現原理分別是什麼？

IOC：Inversion of Control 控制反轉

改變對象的建立方式，由最初的new方式建立對象，轉變爲由spring容器去建立和管理。下降對象之間的耦合度；IOC是整個spring框架的核心，spring其餘全部功能都是基於IOC基礎之上完成的。

DI：Denpency Injection 依賴注入

一、DI做用是維護對象之間的關係，將一塊兒工做具備關係的對象經過構造器或者set方法傳入值創建關係。

二、IOC是一種思想，DI是實現IOC思想的途徑

AOP：Aspect Oriented Programming 面向切面編程

將一個系統中公用的業務邏輯進行提取出來，單獨封裝成一個組件(切面)，而後再以配置的方式做用到系統中，實現程序的可插拔性，提升代碼複用，提高系統性能。

AOP底層實現原理

動態代理模式：能夠根據一個類去動態的生成另一個類，代理類會擁有委託類的API方法。

10、Hibernate對象有哪些狀態,怎麼轉換

Hibernate對象有三種狀態，分爲：

一、臨時態：內存中有對象，數據庫沒有與之對應的數據，新建的對象也是臨時狀態，持久狀態的對象調用了delete()方法也會變成新建狀態；

二、持久態：內存中有對象，數據庫有與之對應的數據，修改對象的屬性，數據庫中數據也會跟着修改。持久狀態的對象存在於內存的session緩存區域。

2.1>新建狀態調用了save()或者saveOrUpdate()會變成持久狀態

2.2>經過id從數據庫get()或者load()出來的對象也是持久態的對象

2.3>遊離態對象調用了save()或者saveOrUpdate()方法也會變成持久態

三、遊離態

內存中有對象，數據庫中有之對應的數據，可是對象處於離線狀態，修改對象的屬性，數據庫數據不會修改

11、簡述事物隔離級別,傳播特性,髒讀,幻讀,不可重複讀分別是什麼意思？

事務的特性：

一、原子性（Atomicity）二、一致性（Consistency）三、隔離性（Isolation）四、持久性（Durability）

事務的隔離級別：事務的隔離級別也分爲四種，由低到高依次分別爲：read uncommited（讀未提交）、read commited（讀提交）、read repeatable（讀重複）、serializable（序列化），這四個級別能夠逐個解決髒讀、不可重複讀、幻讀這幾類問題。

1.read uncommited：是最低的事務隔離級別，它容許另一個事務能夠看到這個事務未提交的數據。

2.read commited：保證一個事物提交後才能被另一個事務讀取。另一個事務不能讀取該事物未提交的數據。

3.repeatable read：這種事務隔離級別能夠防止髒讀，不可重複讀。可是可能會出現幻象讀。它除了保證一個事務不能被另一個事務讀取未提交的數據以外還避免瞭如下狀況產生（不可重複讀）。

4.serializable：這是花費最高代價但最可靠的事務隔離級別。事務被處理爲順序執行。除了防止髒讀，不可重複讀以外，還避免了幻象讀。

髒讀：指當一個事務正字訪問數據，而且對數據進行了修改，而這種數據尚未提交到數據庫中，這時，另一個事務也訪問這個數據，而後使用了這個數據。由於這個數據尚未提交那麼另一個事務讀取到的這個數據咱們稱之爲髒數據。依據髒數據所作的操做是不正確的。

幻讀：一個事務前後讀取一個範圍的記錄，但兩次讀取的紀錄數不一樣，咱們稱之爲幻象讀（兩次執行同一條 select 語句會出現不一樣的結果，第二次讀會增長一數據行，並無說這兩次執行是在同一個事務中）

不可重複讀：指在一個事務內，屢次讀同一數據。在這個事務尚未執行結束，另一個事務也訪問該同一數據，那麼在第一個事務中的兩次讀取數據之間，因爲第二個事務的修改第一個事務兩次讀到的數據多是不同的，這樣就發生了在一個事物內兩次連續讀到的數據是不同的，這種狀況被稱爲是不可重複讀

Spring事務傳播特性：

事務傳播行爲就是多個事務方法相互調用時，事務如何在這些方法間傳播。spring支持支持7 種事務傳播行爲：

propagation_requierd：若是當前沒有事務，就新建一個事務，若是已存在一個，加入到這個事務中，這是最多見的選擇

propagation_supports：支持當前事務，若是沒有當前事務，就以非事務方法執行。

propagation_mandatory：使用當前事務，若是沒有當前事務，就拋出異常。propagation_required_new：新建事務，若是當前存在事務，把當前事務掛起。propagation_not_supported：以非事務方式執行操做，若是當前存在事務，就把當前事務掛起。把當前事務掛起。

propagation_never：以非事務方式執行操做，若是當前事務存在則拋出異常。propagation_nested：若是當前存在事務，則在嵌套事務內執行。若是當前沒有事務，則執行與propagation_required相似的操做相似的操做

Spring 默認的事務傳播行爲是默認的事務傳播行爲是 PROPAGATION_REQUIRED，它適合於絕大多數的情，它適合於絕大多數的狀況。假設 ServiveX#methodX() 都工做在事務環境下（即都被 Spring 事務加強了），假設程序中存在以下的調用鏈： Service1#method1()->Service2#method2()>Service3#method3()，那麼這，那麼這 3 個服務類的 3 個方法經過 Spring 的事務傳播機制都工做在同一個事務中

12、有哪些方式能夠提升數據庫的查詢效率？

1.創建適當的索引

2.避免在索引上使用計算

3.避免在索引列上使用NOT

4.避免在索引上使用IS NULL 和 IS NOT NULL

5.避免沒必要要的行和列

6．Select 子句中避免使用 *

7.在IN後面值的列表中，將出現最頻繁的值放在最前面，出現最少的放在最後，減小判斷次數。

8.使用batch處理

9.注意Union和Union all的區別

10.Where子句中的鏈接順序

11.DISTINCT的使用：注意，在數據量大的時候，儘可能不要使用，它同UNION同樣會使查詢變慢。由於Oracle須要對後面的全部字段進行排序，消耗性能。

13、有2個空水壺,容積是5升和6升,怎樣才能利用這2個空水壺從水池中取出3升的水？

將6升水倒入5升的，6升剩下1升；把1升水放入到5升壺中，再用6升壺水倒入放有1升水的5升壺，6升壺剩餘2升；把這2升水在倒入5升壺，再用6升壺倒入5升壺，6升的壺就剩餘3升水；

SSH、SSM框架測試題

--將答案寫在答題紙上

1、Struts2的執行流程是什麼

struts2執行流程(重點）

一、瀏覽器向服務器發起請求

二、請求首先會被提交到web.xml中定義的前端過濾器filter中

三、前端過濾器解析請求路徑，在根據struts.xml文件中的配置，決定將這個請求交給哪個action進行處理，而且指定交由哪個業務方法進行處理

四、業務方法處理完請求以後，會給前端過濾器返回一個字符串

五、前端過濾器拿到字符串以後在根據struts.xml中result配置找到相應的頁面而後在進行返回

2、值棧和OGNL做用分別是什麼？

一、值棧是什麼

Struts2中的數據中心，主要存儲與當前Action相關的數據和信息

--當前action對象

--action中定義的屬性(有set／get方法)

--action中定義的域對象：request，session，application

二、值棧的做用

Action向頁面傳輸值的緩存區

三、值棧到存值區域

root區（list區域）：以棧結構形式存儲當前Action中的屬性以及直接往棧中push的元素

context區（map區域）：主要存儲與當前Action相關的域對象信息

request，session，application

四、OGNL

Struts2中定義的一種表達式語言，主要用於能夠從值棧中取值

4.一、引入Struts2的標籤庫

4.二、從root區域取值

<s:property value="屬性名"/>

靠近棧頂到同名會被先取出來，而後就再也不往下查詢

4.三、從context區域取值

<s:property value="#域對象.key值"/>

3、Struts中JSP如何給Action傳值

一、在Action中經過ServletActionContext獲取到request對象，而後調用request.getParameter("key值")

二、屬性注入

2.一、請求參數key值（通常是表單name值），必須和action中定義的屬性名保持一致

2.二、action中屬性提供set/get方法。

三、域模型傳值

針對表單中請求參數較多

3.一、建立一個實體類，根據表單中提交項定義屬性，屬性要提供set/get方法

3.二、在action中定義一個實體類對象屬性，屬性提供set/get方法

3.三、表單中的提交項name屬性中爲action實體對象名.實體類屬性名

如：name="user.username"

name="user.password"

4、攔截器的做用,以及攔截器和過濾器之間的區別?

Struts2中定義的對Action進行動態攔截的對象，攔截器中的方法會在Action調用先後都會執行，也能夠經過動態設置來阻止Action執行。

攔截器的做用：封裝代碼通用邏輯，以便於重複利用，如：登錄驗證，日誌記錄，權限控制；並且攔截器能夠經過動態配置來使用，提供系統靈活性，實現解耦合。

攔截器和過濾器的區別：

一、過濾器是依賴於Servlet容器，攔截器不依賴於容器

二、過濾器是能夠攔截全部請求，攔截器只針對Action起做用

三、過濾器只在容器初始化執行一次，攔截器能夠屢次執行

四、過濾器不能訪問值棧中的對象，攔截器能夠訪問值棧中的對象

五、過濾器底層實現：回調

攔截器底層實現：反射

5、IOC是什麼,底層如何實現的,IOC與DI之間關係

IOC：Inversion of Control 控制反轉；改變對象的建立方式，由最初的new方式建立對象，轉變爲由spring容器去建立和管理，下降對象之間的耦合度。IOC是整個spring框架的核心，spring其餘功能都是基於IOC基礎上完成的。

DI:Denpency Injection 依賴注入，DI的做用是維護對象之間的關係，將一塊兒工做具備關係的對象經過構造器或者set方法傳入值創建關係。

IOC是一種思想，DI是實現IOC思想的途徑

6、AOP做用是什麼,底層如何實如今哪些地方會用到,分別簡述切面切入點和通知

Aspect Oriented Programming 面向切面編程

將一個系統中公用的業務邏輯進行提取出來，單獨封裝成一個組件(切面)，

而後再以配置的方式做用到系統中，實現程序的可插拔性，提升代碼複用，

提高系統性能。

2、AOP底層實現原理

動態代理模式：能夠根據一個類去動態的生成另一個類，代理類會擁有

委託類的API方法。

JDK動態代理(只支持接口注入)

CGLIB動態代理(能夠支持普通類注入)

3、AOP和OOP區別

一、AOP是以OOP爲基礎

二、OOP側重於對象的封裝，AOP側重於共通業務邏輯的封裝

4、AOP使用方式

一、切面：Aspect

系統中共通業務邏輯的封裝，會在某個時刻或者階段共通調用，強調

調用時機相同，如：事務處理，異常處理，日誌，安全驗證，權限驗證

二、切入點：PointCut

切入點目標：給誰追加共通處理

在spring中提供切入點表達式(正則表達式)

1>名稱限定表達式(切入到方法)

語法：execution(修飾符？返回值類型|* 方法名|*(參數列表|..))

2>類型限定表達式(切入到某一個類)

語法：within(類型)

三、通知advice

何時調用共通的業務邏輯

主要用於指定切面做用到切入點上的時機

在spring中提供了五種類型通知

1>前置通知-->目標方法調用前 @Before

2>後置通知-->目標方法調用後 @AfterReturning

3>異常通知-->目標方法產生異常後調用 @AfterThrowing

4>最終通知-->目標方法進行finally調用 @After

5>環繞通知-->目標方法調用先後都會執行 @Around

環繞通知=前置通知+後置通知

7、什麼是動態代理模式

8、什麼是spring容器

在Spring框架中，全部的Java類和JavaBean對象都會被看成是一個bean組件，這些bean組件都是由spring容器負責管理和建立以及維護這些對象之間的關係。

9、spring如何管理Bean對象

一、管理對象的實例化(最經常使用)

構造器構建對象

靜態工廠構建對象

實例工廠構建對象

二、管理對象的做用域

scope="singleton"默認，單例模式，每次調用getBean()返回同一個對象

scope=「prototype」每次調用getBean()返回一個新的對象

三、管理對象的生命週期

init-method=「」bean組件的初始化方法，

在bean組件實例化完成後自動調用，

destroy-method=""bean組件銷燬方法，單例bean組件在容器關閉時調用

四、延遲實例化對象

在spring容器中全部的單例bean默認在容器啓動時構建對象

lazy-init=「true」將單例對象實例化時機延遲到調用getBean()方法時調用

lazy-init="false"默認值，容器啓動構建單例對象

10、什麼是Restful,如何編寫一個Restful風格的springMvC項目

一、Restful

表現層狀態轉移，是一個軟件設計風格，主要是用於對網絡上的資源進行統必定位以及規定統一操做的方式

二、網絡上的資源(核心)

1>網絡上的全部數據均可以抽象爲資源，Restful能夠對資源進行標識

2>不管以任何方式來操做這個資源都不會影響資源標識

三、Restful優勢

1>下降程序複雜性

2>提升程序的可伸縮性

四、SpringMVC對Restful的支持

1>統一規定網絡上資源的標識

2>統一規定訪問資源的方式

五、如何編寫Restful風格的SpringMVC應用

1>將前端過濾器中請求路徑url-pattern改成/

DispatcherServlet當攔截到請求以後，會將請求拿到映射器中作匹配，匹配上了進入處理器，匹配不上之間返回404，不會去找靜態頁面

解決問題：將*.do改成/以後，webContent目錄下HTML/css/js/image等等靜態資源沒法訪問

<mvc:resources location="" mapping=""/>

<mvc:default-servlet-handler/>

<!-- 對請求URL進行判斷，訪問靜態資源的交給Servlet容器處理，其餘的交給映射器處理

靜態資源必須在WebContent目錄下

-->

2>導入SpringMVC對Ajax的支持包，藉助Ajax客戶端向服務器發送DELETE，PUT請求

3>在Controller中經過@RequestMapping註解，添加要處理的請求URL模板和Http請求的動做類型

4>利用@PathVariable註解將URL上的變量映射處處理方法的參數上

11、用過哪些數據庫鏈接池,有什麼區別

一開源數據鏈接池
1 dbcp
dbcp多是使用最多的開源鏈接池，緣由大概是由於配置方便，並且不少開源和tomcat應用例子都是使用的這個鏈接池吧。
這個鏈接池能夠設置最大和最小鏈接，鏈接等待時間等，基本功能都有。這個鏈接池的配置參見附件壓縮包中的:dbcp.xml
使用評價：在具體項目應用中，發現此鏈接池的持續運行的穩定性仍是能夠，不過速度稍慢，在大併發量的壓力下穩定性
有所降低，此外不提供鏈接池監控

2 c3p0
c3p0是另一個開源的鏈接池，在業界也是比較有名的，這個鏈接池能夠設置最大和最小鏈接，鏈接等待時間等，基本功能都有。
這個鏈接池的配置參見附件壓縮包中的:c3p0.xml。
使用評價：在具體項目應用中，發現此鏈接池的持續運行的穩定性至關不錯，在大併發量的壓力下穩定性也有必定保證，
此外不提供鏈接池監控。

12、MyBatis中${}和#{}有什麼區別？

一、#先編譯，而後在傳值，傳的值都是字符串;$直接拼接字符串

二、$會形成SQL注入，#不會

三、傳入表名和列名能夠用$

四、傳入值的時候必須使用#，不要使用$

13、Spring中AutoWired和Resource之間區別是什麼?

@AutoWired:spring框架自帶註解

先按照類型進行匹配，若是存在多個匹配的類型會報錯

@Resource：JavaEE中註解

推薦使用，解耦合；按照名稱進行注入，查看spring容器中是否有bean對象的id值和引用名同樣，

若是按照名稱查找不到bean組件，就按照類型注入。

若是在容器中有多個匹配，能夠強制按照名稱注入。

@Autowired

@Qualifier("匹配的id值")或者@Resource(name="id值")；

14、Hibernate中延遲加載是什麼,如何實現,如何取消？

延遲加載：lazy load 懶加載

在儘量晚的狀況下，真正須要使用到數據的時候，纔會向數據庫發送sql語句執行查詢，加載

數據到內存中，避免了無謂的性能開銷。

load()延遲加載：不發送SQL語句，而默認返回一個代理對象，只保存對象的ID值。

get()取消延遲加載：發送SQL語句，可是隻會查詢當前對象的完整信息，若是當前對象還有關

聯的集合數據或者對象，默認都是延遲加載，不會發送SQL語句去查詢其關聯的對象或集合。

15、Hibernate的二級緩存和MyBatis二級緩存區別？

Hibernate和Mybatis的二級緩存除了採用系統默認的緩存機制外，均可以經過實現你本身的緩存或爲其餘第三方緩存方案，建立適配器來徹底覆蓋緩存行爲。

不一樣點：Hibernate的二級緩存配置在SessionFactory生成的配置文件中進行詳細配置；MyBatis的二級緩存配置都是在每一個具體的表-對象映射中進行詳細配置，這樣針對不一樣的表能夠自定義不一樣的緩存機制。而且Mybatis能夠在命名空間中共享相同的緩存配置和實例，經過Cache-ref來實現。

二者比較：由於Hibernate對查詢對象有着良好的管理機制，用戶無需關心SQL。因此在使用二級緩存時若是出現髒數據，系統會報出錯誤並提示。

而MyBatis在這一方面，使用二級緩存時須要特別當心。若是不能徹底肯定數據更新操做的波及範圍，避免Cache的盲目使用。不然，髒數據的出現會給系統的正常運行帶來很大的隱患。

Hibernate與MyBatis均可以是經過SessionFactoryBuider由XML配置文件生成SessionFactory，而後由SessionFactory 生成Session，最後由Session來開啓執行事務和SQL語句。

而MyBatis的優點是MyBatis能夠進行更爲細緻的SQL優化，能夠減小查詢字段，而且容易掌握。

Hibernate的優點是DAO層開發比MyBatis簡單，Mybatis須要維護SQL和結果映射。數據庫移植性很好，MyBatis的數據庫移植性很差，不一樣的數據庫須要寫不一樣SQL。有更好的二級緩存機制，能夠使用第三方緩存。MyBatis自己提供的緩存機制不佳。

16、Hibernate和MyBatis中分別是如何實現表之間的關聯查詢？

Hibernate：建立關聯映射，在映射文件中的加入維持關係的外鍵名稱

Mybatis：建立關聯映射，在映射文件中添加多方集合屬性名

17、Spring如何管理事物,事物的傳播特性和隔離級別有哪些？

Spring並不直接管理事務，而是提供了多種事務管理器，他們將事務管理的職責委託給Hibernate或者JTA等持久化機制所提供的相關平臺框架的事務來實現。

事物的傳播特性：

一、原子性：指事物包含全部的操做要麼徹底成功，要麼徹底失敗，事物的操做若是成功就必需要徹底應用到數據庫，若是失敗就不能對數據庫有任何的影響

二、一致性：指事物必須使數據庫從一個一致性變換到另外一個一致性，也就是說一個事物執行以前和執行以後都必須處於一個一致性狀態。

三、隔離性：是當多個用戶一塊兒訪問數據庫時，操做同一個數據時，數據庫爲每個用戶開啓事物，每一個用戶不被其餘用戶的事物影響干擾，多個併發事物之間要相互隔離。

四、持久性：指一個事物一旦被提交了，那麼數據庫的改變就是永久性的。即使是在系統遇到故障的狀況下也不會丟失提交事物的操做。

隔離級別：

一、Serializable（串行化）：可避免髒讀，不可重複讀，幻讀的發生。

二、Repeatable read(可重複讀)：可避免髒讀、不可重複讀的發生。

三、Read committed(讀已提交)：可避免髒讀的發生。

四、Read uncommitted(讀未提交)：最低級別，任何狀況都沒法保證。

最高級別的事Serializable級別，最低的是Read uncommitted級別。Mysql數據庫中默認的隔離級別爲Repeatable read（可重複讀）

18、Struts如何實現文件上傳下載.如何限制上傳文件的大小和類型？

一、建立一個文件上傳表單；表單提交方式爲post，表單編碼ectype=‘multipart/form-data'

限制文件上傳大小

單個action：<param name="maximumSize">52428800</param>

整個項目設置：<constant name="struts.multipart.maxSize" value="2097152000"></constant>

19、Hibernate中對象的狀態有哪些,他們之間是如何轉換

一、臨時態（瞬時態）：內存中有對象，數據庫中沒有與之對應的數據，新建的對象是臨時狀態，持久態的對象調用了delete()方法也會變成新建狀態。

二、持久態：內存中有對象，數據庫中有與之對應的數據，修改對象的屬性，數據庫中數據也會發生改變。持久狀態的對象存在於內存的session緩存區域。

新建狀態調用了sava()或者saveOrUpdate()會變成持久狀態。

經過id從數據庫get()或者load()出來的對象也是持久狀態對象

遊離態對象調用save()或者saveOrUpdate()方法也會變成持久狀態

三、遊離態：內存中有對象，數據庫有之對應的數據，可是對象處於離線狀態，修改對象數據庫中數據不會修改。

Session關閉

清空session緩存

從session中剔除某個持久態對象

20、SpringMvc中的執行流程是什麼,與Struts有什麼區別？

一、頁面向服務器發起請求，頁面被提交到前端控制器

二、前端控制器接受到請求後調用處理器映射器HandlerMapping，映射器根據請求路徑和映射規則找到相應的處理器Handler

三、前端控制器會根據映射器找到相應的處理器類型調用對應的設配器，適配器在調用處理器的業務方法

四、處理器中業務方法處理請求流程，處理完成以後會返回一個ModelAndView對象給處理器適配器

五、處理器適配器再將ModelAndView對象返回給前端控制器

六、前端控制器拿到ModelAndView對象以後取出其中的視圖名稱，在調用試圖解析器找到相應的頁面

七、在取出ModelAndView對象以後取出其中的視圖名稱，在調用視圖解析器找到相應的頁面

八、將JSP響應頁面返回給客戶端

21、SpringMvc適配器映射器和適配器處理做用分別是什麼？他們之間有什麼關係？

適配器映射器：根據請求路徑以及映射規則找到對應的handler處理器

適配器：根據映射找到的處理器類型，調用不一樣的適配器，適配器去調用處理器中方法；

註解的映射器和適配器要配對使用

22、視圖解析器的做用是什麼？

前端控制器取出ModelAndView對象中的視圖名稱，在根據試圖解析器中配置找到相應的試圖頁面

23、SpringMvc如何防止中文亂碼問題？

一、自定義過濾器實現Filter接口，在相應的業務方法中對中文進行處理

二、使用spring框架自帶的過濾器CharacterEncodingFilter

24、Struts2中如何給前端頁面返回一個JSON字符串

用於向請求發起端返回一個JSON類型的字符串

<result-type name="json" class="org.apache.struts2.json.JSONResult"/>

一、引入一個插件： struts2-json-plugin-2.1.8.jar

二、package的extends必須繼承json-default

三、result類型

四、在Action中定義的只要提供了set/get方法都會以json格式進行返回

五、若是隻想返回Action中部分數據，將須要返回的數據存入到map中

</result>

25、Hibernate中get和load方法有什麼區別？

一、load()方法啓用延遲加載機制來進行查詢，若是隻調用load方法會返回一個代理對象，對象中只保存了id，不會向數據庫發送sql語句，只有當訪問了對象的非id屬性時，纔會向數據庫發送sql語句；

二、get()方法只要調用了就會向數據庫發送sql語句，查詢完成後將對象信息返回來

注：根據id查不到對象：load方法會返回ObjectNotFoundException，get返回null；

26、如何編寫HQL語句,他與SQL語句有什麼異同點？

hql格式：from + 類名 + 類對象 + where + 對象的屬性

sql是面向數據庫表查詢，格式：from + 表名 + where + 表中字段

HQL是一種面向對象的查詢語言，面向Java實體類，與SQL語句沒有關係，可是和SQL語句有相同的語法結構；

異同：

SQL面向數據庫查詢，HQL面向Java實體類查詢

HQL中不支持SELECT*的寫法。

SQL不支持除了分組函數（聚合函數，組函數）之外的其餘函數。

HQL語句不支持表的鏈接查詢。

佔位符使用，下標從0開始；

27、在SSH整合中如何實現分頁查詢,如何使用二級緩存？

28、列舉出Spring中經常使用註解

普通bean組件：@Component

三個衍生註解：@Repository @Service @Controller

管理bean對象生命週期註解：@PostConstruct 初始化方法 @PreDestory 銷燬方法

管理bean對象做用域註解：@Scope

DI依賴注入：普通值注入：@Value

引用類型值的輸入：@AutoWired（spring自帶）@Resource（JavaEE自帶）

@Qualifier

29、SpringMvc中處理器和JSP頁面之間怎樣傳值

JSP頁面傳值給Controller處理器：

一、在方法中添加HTTPServletRequest對象

二、在方法中添加參數接受jsp傳過來的值

1．請求參數key和方法參數名一致，直接將值傳給參數

2.請求參數key和方法參數名不一致，利用@RequestParam（）註解

三、使用實體類對象接受請求參數

1．建立實體類，實體類屬性名和請求參數key名稱一致

2.在業務方法添加實體對象做爲參數，經過實體接受請求參數

Controller處理器傳值給JSP頁面：

一、在方法中添加HttpServletRequest對象或者session對象

二、在業務方法中添加Model對象或者ModelMap對象，實質上是將值存在request中

三、在參數前添加@ModelAttribute

30、Ajax與SpringMvc之間怎樣進行數據交互

Ajax:異步提交，頁面無刷新

一、引入SpringMvc與Ajax交互核心開發包

jackson-annotations-2.9.2.jar

jackson-core-2.9.2.jar

jackson-databind-2.9.2.jar

二、SpringMvc怎麼傳值給Ajax

再返回值類前面或方法上加註解@ResponseBody，這樣返回的數據就不會走視圖解析器，

而是直接返回前端Ajax，前端Ajax會將拿到的數據解析爲與JS相對應的類型

String-->string

boolean-->boolean

bean對象-->object(JSON對象)

List-->object(Array)

map-->object(JSON對象）

三、Ajax怎麼提交值給SpringMvc

一、提交普通請求實體字符串類型到springmvc，springmvc能夠直接接受

key1 = varlue&key2 = value2&....

二、提交JSON字符串到spring，須要在方法參數中加@RequestBody註解

'{"key1":value1,"key2":value2....}'

三、怎樣將表單中數據序列化爲JSON字符串

1.導入js/jquery.serializeJson-min.js

2.將表單中數據序列化成json對象

var requestData = $("form").serialize();

3.把json對象序列化成json字符串

var jsObj = JSON.stringify(jsonObj);

31、SpringMvc如何處理靜態資源文件

32、SpringMvc中攔截器如何編寫,它與Struts中攔截器有什麼區別？

寫一個類實現HandlerInterceptor接口

重寫接口中攔截方法：

preHandler 請求進入處理器以前調用

afterCompletion 處理器執行完請求以後調用

postHandle 響應返回給瀏覽器以前調用

33、SpringMvc對異常的處理方式有哪些？

一、try{}catch{}

二、全局異常處理器（處理全部controller拋出的異常）

添加全局異常處理器，統一處理項目中異常

三、局部異常處理器（只能處理當前處理器中的異常）：

在當前的處理器中定義一個處理器異常的方法，在方法中添加Exception參數接受異常

在處理方法上添加@ExceptionHandler註解

34、SpringMvc如何返回重定向與轉發類型視圖

一、轉發到一個JSP頁面

返回值String：return「視圖名」；

35、Struts2與SpringMvc有什麼異同點？

一、Struts2是類級別的攔截，一個類對應一個request上下文，SpringMVC是方法級別的攔截，一個方法對應一個request上下文，而方法同時又跟一個url對應,因此說從架構自己上SpringMVC就容易實現restful url,而struts2的架構實現起來要費勁，由於Struts2中Action的一個方法能夠對應一個url，而其類屬性卻被全部方法共享，這也就沒法用註解或其餘方式標識其所屬方法了。

二、由上邊緣由，SpringMVC的方法之間基本上獨立的，獨享request response數據，請求數據經過參數獲取，處理結果經過ModelMap交回給框架，方法之間不共享變量，而Struts2搞的就比較亂，雖然方法之間也是獨立的，但其全部Action變量是共享的，這不會影響程序運行，卻給咱們編碼讀程序時帶來麻煩，每次來了請求就建立一個Action，一個Action對象對應一個request上下文。
三、因爲Struts2須要針對每一個request進行封裝，把request，session等servlet生命週期的變量封裝成一個一個Map，供給每一個Action使用，並保證線程安全，因此在原則上，是比較耗費內存的。

四、攔截器實現機制上，Struts2有以本身的interceptor機制，SpringMVC用的是獨立的AOP方式，這樣致使Struts2的配置文件量仍是比SpringMVC大。

五、SpringMVC的入口是servlet，而Struts2是filter（這裏要指出，filter和servlet是不一樣的。之前認爲filter是servlet的一種特殊），這就致使了兩者的機制不一樣，這裏就牽涉到servlet和filter的區別了。

六、SpringMVC集成了Ajax，使用很是方便，只需一個註解@ResponseBody就能夠實現，而後直接返回響應文本便可，而Struts2攔截器集成了Ajax，在Action中處理時通常必須安裝插件或者本身寫代碼集成進去，使用起來也相對不方便。

七、SpringMVC驗證支持JSR303，處理起來相對更加靈活方便，而Struts2驗證比較繁瑣，感受太煩亂。

八、Spring MVC和Spring是無縫的。從這個項目的管理和安全上也比Struts2高（固然Struts2也能夠經過不一樣的目錄結構和相關配置作到SpringMVC同樣的效果，可是須要xml配置的地方很多）。

九、設計思想上，Struts2更加符合OOP的編程思想， SpringMVC就比較謹慎，在servlet上擴展。

十、SpringMVC開發效率和性能高於Struts2。
十一、SpringMVC能夠認爲已經100%零配置。

36、Hibernate與MyBatis有什麼異同點

（1）Hibernate與MyBatis都是經過SessionFactoryBuider由XML配置文件生成SessionFactory，由SessionFactory 生成Session，由Session來開啓執行事務和SQL語句。

（2）Hibernate和MyBatis都支持JDBC（Java DataBase Connectivity，java數據庫鏈接）和JTA（Java Transaction API，Java事務API（Application Programming Interface，應用程序編程接口））事務處理。

注：jdbc和jta的主要做用是加強數據訪問能力。

（3）基於ORM（Object Relational Mapping，對象關係映射）思想解決了entity和數據庫的映射問題

不一樣點：

（1）sql方面：mybaits經過mapper.xml維護映射結果，程序員手動編寫sql相比hibernate自動生成hql（hibernate sql）更加靈活，sql調優更加容易（hibernate由於更好的封裝性，開發效率提升的同時，sql語句調優要更費力，固然能夠手動修改sql來優化，可是同時也會影響開發效率）；hibernate的hql數據庫移植性更好，體如今強壯性。hibernate在級聯刪除的時候效率低；數據量大，表多的時候，基於關係操做會變得複雜。

（2）緩存方面：mybatis和hibernate均可以使用第三方緩存，而hibernate相比maybatis有更好的二級緩存機制。