面試題: !=!=未看12 略多 sql語句練習很是有用

剛纔看到的，先轉載過來，沒準之後用到……javascript

面試總結 css

2013年8月6日：



問題2：Hibernate的核心接口有哪些？
　
Hibernate的核心接口一共有5個，分別爲 :Session、SessionFactory、Transaction、Query和Configuration。 criteria
　　這5個核心接口在任何開發中都會用到。經過這些接口，不只能夠對持久化對象進行存取，還可以進行事務控制。
　
問題3：Hibernate的緩存有哪些？
　
Session是一級緩存，SessionFactry是二級緩存。
SessionFactory是Hibernate的概念，對應一個數據存儲源（如MySql，SQLServer，Oracle）
看你項目中用的哪一個數據庫，能夠有多個， 在XML文件中配置，由Configuration建立
SessionFactory能夠建立Session，Session用來控制事務以及增刪改查操做
SessionFactory是線程安全的，多線程能夠同時訪問它，建立一次就行
Session是 線程不安全的，表明對數據庫一次操做。通常每一次對數據庫的操做都要建立一個Session，用以後關閉
　
一、內部緩存存在Hibernate中又叫一級緩存，屬於應用事務級緩存
二、二級緩存：
　　a) 應用級緩存
　　b) 分佈式緩存，好比使用Memcached可做爲Hibernate二級分佈式緩存
　　條件：數據不會被第三方修改、數據大小在可接受範圍、數據更新頻率低、同一數據被系統頻繁使用、非關鍵數據
　　c) 第三方緩存的實現
　
　問題4：Hibernate中get和load有什麼區別？
　
不存在對應記錄時表現不同
load返回的是代理對象(javassist.jar生成二進制碼)，等到真正用到對象的內容纔會發出SQL語句
get直接從數據庫加載，不會延遲
get不支持懶加載，load支持
get查詢數據庫不存在的記錄時返回null ，load就報異常了
　
　問題5：什麼是Session？
　
Session 是客戶端與服務器之間的會話，用來保存用戶的信息。
在編程裏是會話的意思
Session 對象存儲特定用戶會話所需的信息。這樣，當用戶在應用程序的 Web 頁之間跳轉時，存儲在 Session 對象中的變量將不會丟失，而是在整個用戶會話中一直存在下去
當用戶請求來自應用程序的 Web 頁時，若是該用戶尚未會話，則 Web 服務器將自動建立一個 Session 對象。當會話過時或被放棄後，服務器將終止該會話
　
問題6：Session和Cookie區別？

Session是服務器端緩存，Cookie是客戶端緩存。
Cookie機制採用的是在客戶端保持狀態的方案，而Session機制採用的是在服務器端保持狀態的方案
　
2013年8月7日：天懋數碼、圖創科技

問題1：書籍表，借書表，查詢借書表每一本書的最新借書時間

書籍表 Book 表結構：主鍵ID、書名Name
借書表 Lend 表結構：主鍵ID、外鍵BookID、借書時間Time
要求精確到秒

/* 查詢lend表，經過bookId分組，查出每組中時間最大的，時間最大的表明最新的*/
SELECT max(l.time)
FROM lend as l
GROUP BY l.bookId;

/* 查詢book表和lend表 */
SELECT b.name as "書名", l.time as "最新借出時間"
FROM book as b , lend as l
WHERE l.bookId = b.id
AND
l.time IN
(
　　SELECT max(l.time)
　　FROM lend as l
　　GROUP BY l.bookId
);

問題2：WebService相關

概念：
　　Web Service 是一項新技術，能使得運行在不一樣機器上的不一樣應用無須藉助附加的、專門的第三方軟件或硬件，就可相互交換數據或集成。依據Web Service 規範實施的應用之間，不管它們所使用的語言、平臺或內部協議是什麼，均可以相互交換數據。
　　通俗的講，Web Service 就是一個部署在Web 服務器上的一個應用程序，它向外界暴露出一個可以經過Web 進行調用的API。
　　這就是說，你可以用編程的方法經過Web 來調用這個應用程序。咱們把調用這個Web Service 的應用程序叫作客戶端，發佈這個web 服務的機器稱爲Web Service 服務器。

優點：
異構平臺的互通性
更普遍的軟件複用
成本低、可讀性強、應用範圍廣
迅捷的軟件發行方式

WSDL：WebService服務描述語言
　　獲取WEB的發佈信息是經過wsimport來解析wsdl文件獲得Java類來實現的。不管是獲取發佈的服務，仍是調用發佈的服務，都須要參考wsdl文件

CXF框架概念介紹
　　Apache CXF 是一個開源的Services框架，CXF 幫助您來構建和開發 Services。
　　這些 Services 能夠支持多種協議，好比：SOAP1.1/1.2、POST/HTTP、RESTful、HTTP， CXF大大簡化了Service，能夠自然地和 Spring 進行無縫集成。

問題3：Lucene相關

對索引庫的操做能夠分爲兩種： 管理與查詢

管理索引庫使用IndexWriter，從索引庫中查詢使用IndexSearcher。
　　Lucene的數據結構爲Document文檔與Field字段
　　Document表明一條數據，Field表明數據中的一個屬性。
　　一個Document中有多個Field，Field的值爲String型，由於Lucene只處理文本
　　咱們只須要把在咱們的程序中的對象轉成Document，就能夠交給Lucene管理了，搜索的結果中的數據列表也是Document的集合

中文分詞器之一：IKAnalyzer
格式器對象Formatter
索引庫數據查看器(lukeall-1.0.0.jar)

IndexSearcher：是用來在創建好的索引上進行搜索
QueryParser：QueryParser 是查詢操做的解析類, 要告訴QueryParser對哪一個字段進行查詢, 用什麼樣的分詞器,進行分詞,最後返回的是一個Query對象, 交給IndexSearcher作查詢操做
Term：是搜索的基本單元, Term對象有兩個String類型的域組成：字段的名稱和字段的值, 被分詞創建索引的Field就是Term
TopDocs:
int totalHits Expert: The total number of hits for the query.
ScoreDoc[] scoreDocs Expert: The top hits for the query

建立索引API分析
Directory: 類表明一個Lucene索引的位置,FSDirectory:它表示一個存儲在文件系統中的索引的位置
Analyzer類是一個抽象類, 它有多個實現,在一個文檔被入索引庫以前，首先須要對文檔內容進行分詞處理,針對不一樣的語言和應用須要選擇適合的 Analyzer。Analyzer 把分詞後的內容交給 IndexWriter 來創建索引
IndexWriter：是建立索引和維護索引的中心組件, 這個類建立一個新的索引而且添加文檔到一個已有的索引中。IndexWriter只負責索引庫的更新(刪、更新、插入),不負責查詢
Document：由多個字段(Field)組成，一個Field表明與這個文檔相關的元數據。如做者、標題、主題等等，分別作爲文檔的字段索引和存儲。add(Fieldable field)添加一個字段(Field)到Document

Jar包至少有：
 lucene-core-3.0.1.jar（核心包）
 contrib\analyzers\common\lucene-analyzers-3.0.1.jar（分詞器）
 contrib\highlighter\lucene-highlighter-3.0.1.jar（高亮）
 contrib\memory\lucene-memory-3.0.1.jar（高亮）

全文檢索與數據查詢的區別
相關度排序：查出的結果沒有相關度排序，不知道我想要的結果在哪一頁。咱們在使用百度搜索時，通常不須要翻頁，爲何？由於百度作了相關度排序：爲每一條結果打一個分數，這條結果越符合搜索條件，得分就越高，叫作相關度得分，結果列表會按照這個分數由高到低排列，因此第1頁的結果就是咱們最想要的結果
查詢的方式: 全文檢索的速度大大快於SQL的like搜索的速度。這是由於查詢方式不一樣形成的，以查字典舉例：數據庫的like就是一頁一頁的翻，一行一行的找，而全文檢索是先查目錄，獲得結果所在的頁碼，再直接翻到這一頁
定位不同：一個更側重高效、安全的存儲、一個是側重準確、方便的搜索

問題4：要求在不容許引入第三個變量的狀況下交換 var a=1; var b=2;

方法一：
a=a+b; b=a-b; a=a-b;
輸出a,b能夠發現兩值已經交換

方法二：
a=a^b; b=a^b; a=a^b;

問題5：使用正則表達式驗證郵箱

　　正則表達式(regular expression, 經常縮寫爲RegExp) 是一種用特殊符號編寫的模式，描述一個或多個文本字符串。使用正則表達式匹配文本的模式，這樣腳本就能夠輕鬆的識別和操做文本。
　　其實，正則表達式是值得你們花時間學習的。正則表達式不只在JavaScript 中有用，在其餘許多地方也能夠使用正則表達式，例如其餘編程語言（好比Perl,Java,C#,Python 和PHP ），Apache 配置文件以及BBEdit 和TextMate 等文本編輯器。甚至Adobe Dreamweaver 和Microsoft Word( 在必定程度上) 使用正則表達式也能夠實現更強大的搜索和替換。

下面是一個驗證電子郵件的正則表達式：
var re = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/ ;

下面咱們開始剖析這個正則表達式：
re 是一個變量, 用來存儲右邊的正則表達式，在JavaScript中，聲明變量使用Var 關鍵字。
正則表達式的閱讀順序是從左向右的
正則表達式老是以( / ) 開頭和結尾，斜槓之間的全部內容都是正則表達式的組成部分
脫字符( ^ ) 表示咱們要使用這個表達式來檢查以特定字符串開頭的字符串。若是去掉脫字符，那麼即便字符串開頭有一堆垃圾字符，電子郵件地址也可能被認爲是有效的。
表達式\w 表示任意單一字符，包括a~z 、A~Z 、0~9 或下劃線。電子郵件必須這些字符之一開頭
加號+ 表示咱們要尋找前面條目的一次或屢次出現
圓括號( ) 表示一個組，這意味着後面要引用圓括號中的全部內容，因此如今將它們放在一個組中
方括號[ ] 用來表示能夠出現其中的任意一個字符。在這個示例中，方括號內包含字符\.- 。咱們但願容許用戶輸入點號或連字符，可是點號對於正則表達式有特殊的意義，因此須要在它前面加上反斜槓\, 在特殊字符前加反斜槓表示「對字符轉義」，經轉義後的字符表示其自己意義。由於有方括號，輸入字符串在這個位置能夠有一個點號或一個連字符，可是兩種不能同時存在
問號？表示前面的條目能夠出現一次或不出現。因此電子郵件地址的第一部分中能夠有一個點號或一個連字符，也能夠沒有
在？後面，再次使用\w+ ，表示點號或連字符後面必須有其餘字符
在（）後面出現的* 號，表示前面的條目能夠出現零次或屢次。因此圓括號中的內容能夠出現零次或屢次
@ 字符表明其自己，沒有任何其餘意義，這個字符位於電子郵件地址和域名之間
@ 字符後再次出現\w+ ，表示@ 後必須出現字符。在此以後，再次出現([\.-]?\w+)*, 表示電子郵件地址的後綴中容許出現點號或連字符
而後，在一對圓括號中創建另外一個組(\.\w{2,3}), 表示咱們但願找到一個點號，後面跟一些字符。在這個示例中，花括號中的數字表示前面的條目能夠出現2 到3 次。在這個組的後面是一個+ 號，表示前面的條目（這個組）必須出現一次或屢次。這會匹配.com 或.edu 之類的，也與ox.ac.uk 匹配
最後，正則表達式的末尾是一個美圓符號$ ，表示匹配的字符串必須在這裏結束。斜槓結束正則表達式

問題6：不使用正則表達式驗證郵箱

<script type="text/javascript">
document.getElementById('email').onblur = function() {
var value = this.value;
if (typeof value == 'undefined') { //未定義
alert('Email不能爲空');
return false;
} else if (value.trim() == '') { //空值
alert('Email不能爲空');
return false;
} else if (value.indexOf('@') == -1) { //不包含@
alert('Email必須包含@，如abc@qq.com');
return false;
} else if (value.indexOf('.') == -1) { //不包含.
alert('Email必須包含.，如abc@qq.com');
return false;
} else { //包含@與.
//以@或.開頭@qq.com 和 .@qq.com非法
if (value.indexOf('@') == 0 || value.indexOf('.') == 0) {
alert('Email只能以字母開頭');
return false;
} else if (value.lastIndexOf('@') == value.length - 1
|| value.lastIndexOf('.') == value.length - 1) {
//以@或.結束 a@qq.com@ 和a@qq.com.非法
alert('Email只能以字母結束');
return false;
} else { //包含@與.且不以它們結束
var count_at = 0;
//多個@ a@b@qq.com非法
if (value.indexOf('@') != value.lastIndexOf('@')) {
alert('Email只能包含一個@，如abc@qq.com');
return false;
}
var beforeAt = value.substr(0, value.indexOf('@'));
if (beforeAt.indexOf('.') != -1) { //a.b@qq.com 非法
alert('Email的@前必須所有爲字母');
return false;
}

//刪除@，.替換@，反正替換後按.分隔時a@.拼接，致使@.之間沒法斷定爲空
value = value.replace('@', '.');
var splits = value.split('.'); //按.分隔
var a_z = 'abcdefghijklmnopqrstuvwxyz'; //僅字母
for ( var i in splits) {
　　//對點分隔後的字符進行單字切割並匹配a-z
if (splits[i] == '') {
alert('Email的@.或..不能鏈接');
return false;
}
var words = splits[i].split(""); //單字切割
for ( var w in words) { //對每一個單字進行驗證
if (a_z.indexOf(words[w].toLowerCase()) == -1) {
alert('Email只能包含字母！');
return false;
}}}}}
return true; }
</script>

2013年8月8日：圖創科技、進易通訊技術

問題1：使用A、B、C三個線程，有序的輸出ABCABCABC循環十次
class A implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
try {
synchronized (a) {
synchronized (b) {
System.out.print("A");
b.notify();
}
if (i < 9) {
a.wait();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

class B implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
try {
synchronized (b) {
synchronized (c) {
System.out.print("B");
c.notify();
}
if (i < 9) {
b.wait();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

class C implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
try {
synchronized (c) {
synchronized (a) {
System.out.print("C");
a.notify();
}
if (i < 9) {
c.wait();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

public static Object a = new Object();
public static Object b = new Object();
public static Object c = new Object();

public static void main(String[] args) throws Exception {
TestThread t = new TestThread();

Thread a = new Thread(t.new A());
Thread b = new Thread(t.new B());
Thread c = new Thread(t.new C());

a.start();
Thread.sleep(1);
b.start();
Thread.sleep(1);
c.start();
}

問題2：讀取文本信息，讀取指定信息，好比「姓名：陳小影」裏的陳小影，以及統計數據

　　用緩衝流的readline()，一次讀一行，而後截取冒號後面的，再加上字符串截取就好了subString()，最後再拼起來。
　　
代碼：
InputStreamReader read = new InputStreamReader(new FileInputStream(file), "UTF-8");
BufferedReader reader = new BufferedReader(read);

代碼：
public static void main(String[] args) throws IOException
{
FileReader is = new FileReader("D:/input.txt.txt");
BufferedReader br = new BufferedReader(is);
StringBuffer buffer = new StringBuffer();
String test = "";

while((test = br.readLine()) != null){
int num = numString(test,"java");
PrintWriter os = new PrintWriter ("D:/result.txt.txt");
buffer.append("input.txt文件中，包含");
buffer.append(num);
buffer.append("個java字符串");
os.write(buffer.toString());
os.close();
}
}

public static int numString(String s , String str) {
int i = 0 ; //指定的開始搜索的索引
int index = 0 ; //查找到的第一個索引
int num = 0 ; //字符串出現的次數

while(index != -1) {
//indexOf(String str, int fromIndex)
//返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
index = s.indexOf(str,i) ;
if(index != -1)
num ++ ;
i = index + str.length() ;
}
return num ;
}
}

問題3：JSP的九大內置對象和四個做用域

九大內置對象：
request 請求對象　用戶端請求，此請求會包含來自GET/POST請求的參數做用域 Request
response 響應對象網頁傳回用戶端的迴應做用域 Page
pageContext 頁面上下文對象網頁的屬性在這裏管理做用域 Page
session 會話對象與請求有關的會話期做用域 Session
application 應用程序對象 servlet正在執行的內容做用域 Application
out 輸出對象用來傳送回應的輸出做用域 Page
config 配置對象 servlet的構架部件做用域 Page
page 頁面對象 JSP網頁自己做用域 Page
exception 例外對象針對錯誤網頁，未捕捉的例外做用域 page

四個做用域：page、request、session、application
Page 範圍是當前頁面
Request 範圍是當前請求週期（從請求發起到服務器處理結束，返回響應的整個過程）
Session 範圍是當前會話（用戶打開瀏覽器開始，到用戶關閉瀏覽器而且會話失效的整個過程）
Application 範圍是整個應用，從應用啓動到應用結束

問題4：FileWriter和PrintWriter有什麼區別？

在寫文件時我認爲：
PrintWriter out = new PrintWriter(
new BufferedWriter(
new FileWriter(filename)));
比較好點

PrintWriter 提供print系方法
BufferedWriter 提供緩衝，用以加速
FileWriter 用於寫文件

FileWriter類/FileReader類：
　　用於對字符文件的讀寫的便捷的結點流類
　　使用時最好用BufferedReader/BufferedWriter對其進行包裝。

PrintStream類（如System.out）：
　　格式化打印輸出字節數據的流，該類提供的print[ln]()方法可格式化打印輸出各類類型的數據（包括類對象）
　　它使用平臺的默認字符編碼將全部字符都轉換爲字節打印輸出（寫入）

在須要寫入字符而不是寫入字節的狀況下，應該使用PrintWriter類

問題5：簡述JSP和Servlet的關係？

JSP---Java Server Pages
　　 擁有Servlet的特性與優勢(自己就是一個Servlet)
　　 直接在HTML中內嵌JSP代碼
　　 只有當客戶端第一次請求JSP時，才須要將其轉換、編譯Servlet代碼

優勢:
優良的性能優於CGI，PHP，ASP
平臺無關性操做系統無關，Web服務器無關
可擴展性標籤庫Tag的擴展機制，簡化頁面開發——Taglib uri

Servlet是在Web服務器上的Java程序，它提供服務，由它來傳遞給你html的格式
Servlet是服務器小小的Java應用程序
用來完成B/S架構下，客戶端請求的響應處理
平臺獨立，性能優良，能以線程方式運行
Servlet API爲Servlet提供了統一的編程接口
Servlet通常在容器中運行（必須部署在Servlet容器，才能響應客戶端的請求，對外提供服務，要對外統一接口，由容器來調用）

JSP在被第1次訪問的時候會被轉義編譯成類Servlet也能夠說JSP就是一個Servlet

2者的區別： JSP是Html中內嵌Java代碼；Servlet把Html代碼和Java代碼分離開
JSP側重與顯示；Servlet側重與控制邏輯

問題6：簡述JAVA設計模式的概念?

　　設計模式（Design Pattern）是一套被反覆使用、多數人知曉的、通過分類編目的、代碼設計經驗的總結。使用設計模式是爲了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。
　　
　　毫無疑問，設計模式於己於他人於系統都是多贏的，設計模式使代碼編制真正工程化，設計模式是軟件工程的基石，如同大廈的一塊塊磚石同樣。

問題7：經常使用的數據庫優化方法有哪些?

創建索引
導出歷史數據    分表
按期整理索引(sp_msforeachtable 'dbcc dbreindex("?")' )
少用like，查詢前檢查條件是否是完整，若是完整就用 = 替代like查詢，不要不檢查條件完整不完整所有用like來

問題8：什麼是動態遊標?什麼是靜態遊標?

　　靜態遊標是以遊標打開時刻的當時狀態顯示結果集的遊標。靜態遊標在遊標打開時不反映對基礎數據進行的更新、刪除或插入。有時稱它們爲快照遊標。

　　動態遊標是能夠在遊標打開時反映對基礎數據進行的修改的遊標。用戶所作的更新、刪除和插入在動態遊標中加以反映。

問題9：爲何要用Struts2框架？

它是創建在MVC這種公認的好的模式上的，Struts在M、V和C上都有涉及，但它主要是提供一個好的控制器和一套定製的標籤庫上，也就是說它的着力點在C和V上。所以，它天生就有MVC所帶來的一系列優勢，如：結構井井有條，高可重用性，增長了程序的健壯性和可伸縮性，便於開發與設計分工，提供集中統一的權限控制、校驗、國際化、日誌等等
其次，它是個開源項目獲得了包括它的發明者Craig R.McClanahan在內的一些程序大師和高手持續而細心的呵護，而且經受了實戰的檢驗，使其功能愈來愈強大，體系也日臻完善
是它對其餘技術和框架顯示出很好的融合性

問題10：Struts2的工做原理？

Struts2框架由3個部分組成：
　　 核心控制器FilterDispatcher、業務控制器和用戶實現的業務邏輯組件。
　　在這3個部分裏，Struts 2框架提供了核心控制器FilterDispatcher，而用戶須要實現業務控制器和業務邏輯組件。

一、核心控制器：FilterDispatcher
　　 FilterDispatcher是Struts2框架的核心控制器，該控制器做爲一個Filter運行在Web應用中， 它負責攔截全部的用戶請求，當用戶請求到達時，該Filter會過濾用戶請求。若是用戶請求以action結尾，該請求將被轉入Struts2框架處理。
　　Struts2框架得到了*.action請求後，將根據*.action請求的 前面部分決定調用哪一個業務邏輯組件。例如，對於login.action請求，Struts2調用名爲login的Action來處理該請求。
　　Struts2應用中的Action都被定義在struts.xml文件中，在該文件中定義Action時，定義了 該Action的name屬性和class屬性，其中name屬性決定了 該Action處理哪一個用戶請求，而class屬性決定了該Action的實現類。
　　Struts2用於處理用戶請求的Action實例，並非用戶實現的業務控制器，而是Action代理。由於用戶實現的業務控制器並無與Servlet API耦合，顯然沒法處理用戶請求。而Struts2框架提供了系列攔截器，該系列攔截器負責將HttpServletRequest請求中的請求參數解析出來，傳入到Action中，並回調Action 的execute方法來處理用戶請求。

二、一個請求在Struts2框架中的處理大概分爲如下幾個步驟：
客戶端初始化一個指向Servlet容器（例如Tomcat）的請求 ,即HttpServletRequest請求
這個請求通過一系列的過濾器（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

在上述過程當中全部的對象（Action，Results，Interceptors，等）都是經過ObjectFactory來建立的。

問題11：Hibernate的工做原理？

讀取並解析hibernate.cfg.xml配置文件
讀取並解析映射信息，建立SessionFactory
打開Sesssion
建立事務Transaction
持久化操做
提交事務
關閉Session
關閉SesstionFactory

問題12：爲何要用Hibernate？

對JDBC訪問數據庫的代碼作了封裝，大大簡化了數據訪問層繁瑣的重複性代碼
Hibernate是一個基於JDBC的主流持久化框架，是一個優秀的ORM實現。他很大程度的 簡化DAO層的編碼工做
Hibernate 使用Java反射機制，而不是字節碼加強程序來實現透明性
Hibernate的性能很是好，由於它是個輕量級框架。映射的靈活性很出色。它支持各類關係數據庫，從一對一到多對多的各類複雜關係

問題13：Hibernate如何實現延遲加載？

　　當Hibernate在查詢數據的時候，數據並無存在與內存中，當程序真正對數據的操做時，對象才存在與內存中，就實現了延遲加載， 他節省了服務器的內存開銷，從而提升了服務器的性能。

問題14：Hibernate中怎樣實現類之間的關係?(如：一對多、多對多的關係)

　　類與類之間的關係主要體如今表與表之間的關係進行操做，它們都是對對象進行操做，咱們程序中把全部的表與類都映射在一塊兒，它們經過配置文件中的many-to-one、one-to-many、many-to-many

問題15：Spring的工做原理？

IoC(Inversion of control): 控制反轉
概念：控制權由對象自己轉向容器，由容器 根據配置文件去建立實例並建立各個實例之間的依賴關係
核心：bean工廠，在Spring中，bean工廠建立的各個實例稱做bean

AOP(Aspect-Oriented Programming): 面向切面編程

一、代理的兩種方式：
靜態代理：
 針對每一個具體類分別編寫代理類
 針對一個接口編寫一個代理類
動態代理：
　　針對一個切面編寫一個InvocationHandler，而後借用JDK反射包中的Proxy類爲各類接口動態生成相應的代理類
　　
二、AOP的主要原理：動態代理

Spring的工做原理
　　Spring 已經用過一段時間了，感受Spring是個很不錯的框架。內部最核心的就是IOC了， 動態注入，讓一個對象的建立不用new了，能夠自動的生產，這其實就是利用Java裏的反射
　　反射其實就是在運行時動態的去建立、調用對象，Spring就是在運行時，跟XMLSpring的配置文件來動態的建立對象，以及調用對象裏的方法
　　Spring還有一個核心就是AOP這個就是面向切面編程，能夠爲某一類對象進行監督和控制（也就是在調用這類對象的具體方法的先後去調用你指定的模塊）從而達到對一個模塊擴充的功能，這些都是經過配置類達到的
　　
Spring的目的：
　　就是讓對象與對象（模塊與模塊）之間的關係沒有經過代碼來關聯，都是經過 配置類說明管理的（Spring根據這些配置內部經過反射去動態的組裝對象），要記住：Spring是一個容器，凡是在容器裏的對象纔會有Spring所提供的這些服務和功能
　　Spring裏用的最經典的一個設計模式就是：模板方法模式。（這裏我都不介紹了，是一個很經常使用的設計模式）Spring裏的配置是不少的，很難都記住，可是Spring裏的精華也無非就是以上的兩點，把以上兩點跟理解了也就基本上掌握Spring。

問題16：SpringMVC的工做原理？

Spring的MVC框架主要由 DispatcherServlet、處理器映射、處理器、視圖解析器、視圖組成

整個處理過程從一個HTTP請求開始：
DispatcherServlet接收到請求後，根據對應配置文件中配置的處理器映射，找到對應的處理器映射項（HandlerMapping），根據配置的映射規則，找到對應的處理器（Handler）
調用相應處理器中的處理方法，處理該請求，處理器處理結束後會將一個ModelAndView類型的數據傳給DispatcherServlet，這其中包含了處理結果的視圖和視圖中要使用的數據
DispatcherServlet根據獲得的ModelAndView中的視圖對象，找到一個合適的ViewResolver（視圖解析器），根據視圖解析器的配置，DispatcherServlet將視圖要顯示的數據傳給對應的視圖，最後給瀏覽器構造一個HTTP響應

DispatcherServlet是整個Spring MVC的核心，它負責接收HTTP請求組織協調Spring MVC的各個組成部分
其主要工做有如下三項：
截獲符合特定格式的URL請求
初始化DispatcherServlet 上下文對應的WebApplicationContext，並將其與業務層、持久化層的WebApplicationContext創建關聯
初始化Spring MVC的各個組成組件，並裝配到DispatcherServlet中

問題17：SendRedirect 和Foward區別

一、請求次數不一樣，這是最本質的區別
　　在Foward方式下，在執行當前JSP對象或者Servlet對象的過程當中去調用目標文件對應的對象，至關於方法調用，把request和response對象做爲參數傳遞到目標文件對應的對象，當前文件和目標文件的執行是在用戶發送的一次請求中完成的。
　　在redirect方式下，用於首先請求了當前文件，當前文件把目標文件的地址返回給了客戶端，客戶端再次發送請求，請求目標文件，其實是發送了兩次請求。

二、傳值方式不一樣
　　在Foward方式下，當前文件和目標文件屬於同一次請求，共享request對象，因此能夠使用request對象傳值。
　　在redirect方式下，當前文件和目標文件屬於不一樣的請求，每次請求會單首創建request和response對象，這樣就不能使用request對象來傳值。
　　在MVC模式下，一般在控制器中調用模型獲得數據，而後保存到request中，而後Foward到目標文件，目標文件從request中獲取須要的信息。若是使用sendRedirect方式在控制器和視圖之間傳遞信息，須要使用在目標文件以後加上「？名字=值」的方式傳遞。

三、客戶端在地址欄中看到的地址不同
　　對於Foward，在地址欄中看到的是第1個文件的名字。
　　對於sendRedirect，在地址欄中看到的是第2個文件的地址。
　　有時候會影響目標文件中的相對路徑，例如當前文件是aa文件夾中的a.jsp，目標文件是bb文件夾中的b.jsp，在b.jsp中要訪問一個圖片，使用相對路徑，直接寫face.jpg，這個文件與b.jsp放在一塊兒。若是採用forward方式，地址欄中是a.jsp，這樣系統會在aa文件夾中找face.jpg，這時候就會出錯。

問題19：簡述JavaWeb中Model2及軟件分層架構的好處

Model2（JSP+Servlet+JavaBean）具備組件化的優勢從而更易於實現對大規模系統的開發和管理，職責劃分清晰。

優勢：
　　分層式結構究竟其優點何在？Martin Fowler在《Patterns of Enterprise Application Architecture》一書中給出了答案：
一、開發人員能夠只關注整個結構中的其中某一層
二、能夠很容易的用新的實現來替換原有層次的實現
三、能夠下降層與層之間的依賴
四、有利於標準化
五、利於各層邏輯的複用

歸納來講，分層式設計能夠達至以下目的：分散關注、鬆散耦合、邏輯複用、標準定義

缺點:
　　「金無足赤，人無完人」，分層式結構也不可避免具備一些缺陷
一、下降了系統的性能，這是不言而喻的。若是不採用分層式結構，不少業務能夠直接造訪數據庫，以此獲取相應的數據，現在卻必須經過中間層來完成
二、有時會致使級聯的修改，這種修改尤爲體如今自上而下的方向。若是在表示層中須要增長一個功能，爲保證其設計符合分層式結構，可能須要在相應的業務邏輯層和數據訪問層中都增長相應的代碼。
　　關於第一個缺點，徹底能夠經過系統的緩存機制來減少對性能的影響。第二個缺點，我想只能經過採用一些設計模式來獲得改善吧。
　　
問題20：說說Session分話的原理，Session與Cookie的關係及區別

服務器上經過Session來分別不一樣的用戶Session ID
任何鏈接到服務器上的用戶， 服務器都會位之分配惟一的一個不會重複的Session ID
Session ID是由服務器統一管理的，人爲不能控制

Session在服務器上2個基本操做:
　　Session.setAttribute(String key,Object obj)以鍵值對的方式存儲數據
　　Session.getAttribute(String key)根據鍵獲取數據
　　
Session是服務器端緩存，Cookie是客戶端緩存
Cookie機制採用的是在客戶端保持狀態的方案，而Session機制採用的是在服務器端保持狀態的方案

問題21：Cookie中的值可否包含各類特殊字符及中文字符？若是不能，那應該如何處理？

　　當Cookie中包含有等號、空格、分號等特殊字符時，可能會致使數據丟失、或者不能解析的錯誤，一個較好的解決辦法就是：在將Cookie值寫入客戶端瀏覽器以前，首先進行URLEncode編碼，讀取Cookie時，進行URLDecode便可。

問題22：JDBC和Hibernate的比較？

　　 JDBC與Hibernate在性能上相比，JDBC靈活性有優點。而Hibernate在易學性，易用性上有些優點。當用到不少複雜的多表聯查和複雜的數據庫操做時，JDBC有優點 。

相同點：
二者都是 JAVA的數據庫操做中間件
二者對於數據庫進行直接操做的對象都不是線程安全的， 都須要及時關閉
二者均可以對數據庫的 更新操做進行顯式的事務處理

不一樣點：
使用的SQL語言不一樣：JDBC使用的是基於關係型數據庫的標準SQL語言， Hibernate使用的是HQL(Hibernate query language)語言
操做的對象不一樣：JDBC操做的是數據，將數據經過SQL語句直接傳送到數據庫中執行， Hibernate操做的是持久化對象，由底層持久化對象的數據更新到數據庫中。
數據狀態不一樣： JDBC操做的數據是「瞬時」的，變量的值沒法與數據庫中的值保持一致，而 Hibernate操做的數據是可持久的，即持久化對象的數據屬性的值是能夠跟數據庫中的值保持一致的。

Hibernate與JDBC哪一個好？各自的優勢和缺點:
一、 內存消耗：採用JDBC的無疑是最省內存的，Hibernate的次之
二、運行效率：若是JDBC的代碼寫的很是優化，那麼JDBC架構運行效率最高，可是實際項目中，這一點幾乎作不到，這須要程序員很是精通JDBC，運用Batch語句，調整PreapredStatement的Batch Size和Fetch Size等參數，以及在必要的狀況下采用結果集cache等等。而通常狀況下程序員是作不到這一點的。 所以Hibernate架構表現出最快的運行效率
三、開發效率：在大的項目，特別是持久層關係映射很複雜的狀況下，Hibernate效率高的驚人，JDBC次之

延遲加載是罪魁禍首，所謂「成也蕭何，敗也蕭何」
有時發現查詢速度很慢， 檢查才發現是我沒有啓用延遲加載，形成遞歸的數據都被加載進來了
若是加上了延遲加載，那麼許多頁面將沒法使用，必須在程序裏進行代碼級別的遞歸的延遲加載數據的讀取

1 用HQL來寫查詢語句，這是最高效的辦法（推薦）
2 用JDBC，脫離了Hibernate範疇，緩存方面和樂觀所方面會出現不一致，並且語句變得繁瑣了（不推薦）
3 將前臺要用到的實體，獨立設計成單獨的類，沒有任何關聯，都是單表， 用到的只是Hibernate的封裝以及簡單的OR映射
4 在大數據量系統中都會遇到相似的問題， 個人解決方法是少用一對多關聯映射或者不用一對多關聯，設置關聯少的數據表，用SQL語句作關聯的查詢，Hibernate中映射的配置 Lazy都爲False

2013年8月9日：微遊科技、三六五世界科技

問題1：有一個1001個元素的數組a[n],每一個元素都在1到1000這些整數中取值,其中只有一個數得復,而且數組中每一個元素只能被訪問一次,設計一個算法找出這個數字.說明:每一個元素只能被訪問一次,就像執行int v=a[1],v變量和a[1]元素不能再訪問.求高手指教

一共有1001個數，其中1000個數是從1到1000取值的（並且取完一遍），另一個數是重複數，那就用這1001個數的和，與前頭那個1000數的等差數列相減，便得出那個重複數了.
for （int num=0,i=0;i<1001;i++）{num+=a【i】-i;} i從0開始，因此減的是1到1000的和。

　　int[] arr = new int[1001];// 定義一個可以存儲1001個元素的數組。
int sum = 0;// 定義一個變量用於存儲arr數組元素裏面的全部總和。
int sum1 = 0;// 定義一個變量用於存儲1-1000的總和。

for (int i = 0; i < arr.length; i++) {
sum += arr[i];// 用for循環，遍歷求出集合中全部元素的總和。
}

for (int i = 0; i < 1001; i++) {
sum1 += arr[i];// 用for循環，遍歷求出1-1000中全部元素的總和。
}

int a = sum - sum1;// 假設a爲，arr數組裏面重復的元素！
System.out.println("數組裏面重復的數字爲：" + a);

問題2：瀑布式開發模型和螺旋式開發模型?

瀑布式模型：可行性研究與計劃、需求分析、設計、開發、測試、維護
螺旋式模型：可行性研究報告、需求說明書、設計文檔、程序、測試報告

瀑布式模型要作完上一步才能夠進行下一步，現已淘汰

螺旋模型（Spiral Model）採用一種週期性的方法來進行系統開發，這會致使開發出衆多的中間版本
　　使用它，項目經理在早期就可以爲客戶實證某些概念。該模型是快速原型法，以進化的開發方式爲中心，在每一個項目階段使用瀑布模型法。
　　這種模型的每個週期都包括需求定義、風險分析、工程實現和評審4個階段，由這4個階段進行迭代。軟件開發過程每迭代一次，軟件開發又前進一個層次。

問題3：Spring底層動態代理失效，怎麼實現切面？

　　Spring默認使用JDK動態代理（Proxy），但JDK動態代理是針對接口作代理的。若是類不是實現的接口的時候，就會使用cglib代理。固然，你也能夠在配置文件裏指定使用cglib

JDK代理:只能代理實現了接口的類
cglib代理:不只能夠對實現接口的類進行代理，同時也能夠對類自己生成代理（主要是經過繼承這個類來生成的，因此不要將要代理的類設成final）

問題4：什麼是動態代理？

　　動態代理能夠提供對另外一個對象的訪問，同時隱藏實際對象的具體事實
　　代理通常會實現它所表示的實際對象的接口
　　代理能夠訪問實際對象，可是延遲實現實際對象的部分功能，實際對象實現系統的實際功能，代理對象對客戶隱藏了實際對象。客戶不知道它是與代理打交道仍是與實際對象打交道

問題5：Struts2中的Action爲何是多例的？

Struts2的Action是多實例的並不是單例，也就是每次請求產生一個Action的對象

緣由是：
　　Struts2的Action中包含數據
　　例如你在頁面填寫的數據就會包含在Action的成員變量裏面，若是Action是單實例的話，這些數據在多線程的環境下就會相互影響，例如形成別人填寫的數據被你看到了

　　而Struts1的Action是單實例的
　　由於它的數據保存在Form類中，多線程環境下，Action只負責處理一些邏輯，並無數據，也就是你們把它當作一個工具使用
　　
　　一樣Servlet也是單實例的

問題6：Struts1和Struts2的區別？

Struts1的前端控制器是一個Servlet，名稱爲ActionServlet，Struts2的前端控制器是一個filter，在Struts2.0中叫FilterDispatcher，在Struts2.1中叫 StrutsPrepareAndExecuteFilter
Struts1的action須要繼承Action類，Struts2的action能夠不繼承任何類；Struts1對同一個路徑的全部請求共享一個Action實例，Struts2對同一個路徑的每一個請求分別使用一個獨立Action實例對象，全部對於Struts2的Action不用考慮線程安全問題
在Struts1中使用Actionfom封裝請求參數，在Struts2中直接使用action的屬性來封裝請求參數
Struts1 整合了JSTL，所以使用JSTL/EL。這種EL有基本對象圖遍歷，可是對集合和索引屬性的支持很弱。
Struts2能夠使用JSTL，可是也支持一個更強大和靈活的表達式語言－－Object Graph Notation Language (OGNL)對象導航語言
Struts 1使用標準JSP機制把對象綁定到頁面中來訪問
Struts 2 使用ValueStack值棧技術，使taglib可以訪問值而不須要把你的頁面（view）和對象綁定起來
Struts 1 ActionForm 屬性一般都是String類型。Struts1使用Commons-Beanutils進行類型轉換
Struts2 使用OGNL進行類型轉換，提供基本和經常使用對象的轉換器
Struts 1支持在ActionForm的validate方法中手動校驗，或者經過Commons Validator的擴展來校驗。
Struts2支持經過validate方法和XWork校驗框架來進行校驗。
執行流程
Struts1
JSP發起HTTPRequest請求Servlet捕獲struts.xmlnamespace+ActionNameAction填充表單setXxx()action.execute()「success」Result設置Request屬性跳轉目標頁
Struts2
Action(JSP發起HTTPRequest請求，被過濾器捕獲)FilterDispatcherstruts.xmlnamespace+ActionNamenew Action填充表單setXxx()action.execute()「success」Result設置Request屬性跳轉目標頁

問題7：MySQL和Oracle的分頁查詢語句？

MySQL：
第一個參數指定返回的第一行在全部數據中的位置，從0開始（注意不是1），第二個參數指定最多返回行數
SELECT * FROM table LIMIT 5,10; #返回第6-15行數據
SELECT * FROM table LIMIT 5; #返回前5行
SELECT * FROM table LIMIT 0,5; #返回前5行

Oracle：
第1種：
SELECT * FROM
(
SELECT A.*, ROWNUM RN
FROM (SELECT * FROM TABLE_NAME) A
WHERE ROWNUM <= 40
)
WHERE RN >= 21

第2種：
SELECT * FROM
(
SELECT A.*, ROWNUM RN
FROM (SELECT * FROM TABLE_NAME) A
)
WHERE RN BETWEEN 21 AND 40

對比這兩種寫法，絕大多數的狀況下，第一個查詢的效率比第二個高得多。

　　這是因爲CBO優化模式下，Oracle能夠將外層的查詢條件推到內層查詢中，以提升內層查詢的執行效率。對於第一個查詢語句，第二層的查詢條件WHERE ROWNUM <= 40就能夠被Oracle推入到內層查詢中，這樣Oracle查詢的結果一旦超過了ROWNUM限制條件，就終止查詢將結果返回了
　　
　　而第二個查詢語句，因爲查詢條件BETWEEN 21 AND 40是存在於查詢的第三層，而Oracle沒法將第三層的查詢條件推到最內層（即便推到最內層也沒有意義，由於最內層查詢不知道RN表明什麼）
　　所以，對於第二個查詢語句，Oracle最內層返回給中間層的是全部知足條件的數據，而中間層返回給最外層的也是全部數據。數據的過濾在最外層完成，顯然這個效率要比第一個查詢低得多
　　
問題8：部署在不一樣Tomcat的兩個項目間如何通訊？

使用WebService技術實現
使用Socket技術實現
使用Http請求技術實現

問題9：請你談談SSH整合？

Struts（表示層）+Spring（業務層）+Hibernate（持久層）

Struts：
　　Struts是一個表示層框架，主要做用是界面展現，接收請求，分發請求
　　在MVC框架中，Struts屬於VC層次，負責界面表現，負責MVC關係的分發
　　
　　View：沿用 JSP，HTTP，Form，Tag，Resourse
　　Controller：ActionServlet，struts-config.xml，Action
Hibernate：
Hibernate是一個持久層框架，它只負責與關係數據庫的操做

Spring：
Spring是一個業務層框架，是一個整合的框架，可以很好地黏合表示層與持久層

問題10：Struts2的數據都在ValueStack中,怎麼保證數據的安全性?ValueStack生命週期多長？

　　由於ValueStack在ActionContext中,而ActionContext在ThreadLocal中,因此能保證數據的安全性
　　 ValueStack的生命週期是一次請求,由於ActionContext把ValueStack放在Request域裏面

問題11：OGNL有什麼優勢？

能夠訪問ValueStack和AcionContext
能夠操做集合對象,很方便的構建各類集合
能夠在 struts.xml訪問action定義的屬性
能夠調用對象的方法
JSTL/EL只能在JSP中使用，而OGNL能夠在更多的View使用

問題12：爲何使用Spring？有什麼優勢？

下降了組件之間的耦合性，實現了軟件各層之間的解耦
能夠使用容器提供的衆多服務，如事務管理，消息服務等
容器提供單例模式支持
容器提供了AOP技術，利用它很容易實現如權限攔截，運行期監控等功能
容器提供了衆多的輔助類，能加快應用的開發
Spring對於主流的應用框架提供了集成支持，如Hibernate，JPA，Struts等
Spring屬於低侵入式設計，代碼的污染極低
獨立於各類應用服務器
Spring的DI機制下降了業務對象替換的複雜性（依賴注入）
十、Spring的高度開放性，並不強制應用徹底依賴於Spring，開發者能夠自由選擇Spring的部分或所有

2013年8月13日：信諾網利

問題1：Spring的AOP是用什麼來實現的？

　　Spring AOP就是用AspectJ來實現的，是依賴關係
　　AspectJ是動態代理的一種實現，而Spring默認使用的就是AspectJ來實現的動態代理，Spring本身的AOP就是使用AspectJ來實現的
　　
AOP：Aspect Oriented Programming(面向切面編程)
利用動態代理實現面向切面編程
Spring實現動態代理配置是有兩種配置文件：
XML文件方式
Annotation方式，使用AspectJ類庫實現的
AspectJ類庫，AspectJ是一個專門用來實現動態代理(AOP編程)的類庫，AspectJ是面向切面編程的框架，Spring使用就是這個類庫實現動態代理的
AspectJ的專業術語：
JoinPoint鏈接點(切入點)
PointCut切入點，當須要定義一個切入點時，則須要使用這個
Aspect切面
Advice切入點的邏輯
Target被代理對象
Weave織入
　　
問題2：單例模式

　　單例模式是設計模式中最簡單的形式之一
　　這一模式的目的是使得類的一個對象成爲系統中的惟一實例，要實現這一點，能夠從客戶端對其進行實例化開始
　　所以須要用一種只容許生成對象類的惟一實例的機制，「阻止」全部想要生成對象的訪問。
　　使用工廠方法來限制實例化過程，這個方法應該是靜態方法（類方法），由於讓類的實例去生成另外一個惟一實例毫無心義

// 第一種形式: 也是經常使用的形式。
public class Singleton {
private static Singleton instance = null;

private Singleton() {
// do something
}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

// 第二種形式:
public class Singleton {
// 在本身內部定義本身的一個實例，只供內部調用
private static Singleton instance = new Singleton();

private Singleton() {
// do something
}

// 這裏提供了一個供外部訪問本class的靜態方法，能夠直接訪問
public static Singleton getInstance() {
return instance;
}
}

// 第三種形式: 雙重鎖的形式。
public class Singleton {
private static Singleton instance = null;

private Singleton() {
// do something
}

public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (null == instance) {
instance = new Singleton();
}
}
}
return instance;
}
}// 這個模式將同步內容下方到if內部，提升了執行的效率，沒必要每次獲取對象時都進行同步，只有第一次才同步，建立了之後就不必了。

問題3：PrepareStatement和Statement的區別？

Statement用於執行靜態SQL語句，在執行時，必須指定一個事先準備好的SQL語句，也就是說SQL語句是靜態的
PrepareStatement是預編譯的SQL語句對象，SQL語句被預編譯並保存在對象中。被封裝的SQL語句表明某一類操做，語句中能夠包含動態參數「?」，在執行時能夠爲「?」動態設置參數值
使用PrepareStatement對象執行SQL時，SQL被數據庫進行解析和編譯，而後被放到命令緩衝區， 每當執行同一個PrepareStatement對象時，它就會被解析一次，但不會被再次編譯。在緩衝區能夠發現預編譯的命令，而且能夠重用。 因此PrepareStatement能夠減小編譯次數提升數據庫性能

一、建立時的區別：
Statement stm=con.createStatement();
PreparedStatement pstm=con.prepareStatement(SQL);
　　執行的時候：
stm.execute(SQL);
pstm.execute();
二、pstm一旦綁定了SQL，此pstm就不能執行其餘的SQL，即只能執行一條SQL命令
　　stm能夠執行多條SQL命令
三、對於執行同構的SQL（只有值不一樣，其餘結構都相同），用pstm的執行效率比較高，對於異構的SQL語句，Statement的執行效率要高
四、當須要外部變量的時候，pstm的執行效率更高

問題4：團隊項目開發中，功能模塊完成後如何和組員集成（整合）測試？

先進行單元測試，單元測試無誤後再進行集成測試

例子：Junit+Ant

這個是屬於軟件測試的範疇，由測試人員作的，分爲功能測試與性能測試

2013年8月14日：21CN世紀龍信息、凱通軟件

問題1：解釋一下什麼是哈希表？

　　 散列表（Hash table，也叫哈希表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構
　　也就是說，它經過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度
　　這個映射函數叫作散列函數，存放記錄的數組叫作散列表

問題2：線程的生命週期

新建就緒（阻塞）運行死亡

新建：其中當用new建立完一個線程對象後，該線程處於新建狀態
就緒：當線程對象調用start()後，該線程處於就緒狀態
運行：若是處於就緒狀態的線程得到CPU時間片，開始執行run方法的線程執行體，該線程處於運行狀態
阻塞：若是線程調用了sleep()或者調用了一個阻塞式IO方法等，該線程處於阻塞狀態
死亡：若是線程的run()執行完成或者拋出一個未捕獲的異常等緣由，該線程處於死亡狀態



問題4：JSP頁面如何實現自定義函數？

首先新建自定函數類，定義public static boolean方法
而後新建tld文件，定義標籤的屬性及格式
JSP頁面引入標籤
注意要放置在WEB-INF目錄下才能夠解析
自定義函數採用${myfn:contains(字符串,字符串)}格式

問題5：你所瞭解的Apache的commons項目所包含的工具？

BeanUtils：提供了對於JavaBean進行各類操做，克隆對象、屬性等等
Betwixt：XML與Java對象之間相互轉換
Codec：處理經常使用的編碼方法的工具類包例如DES、SHA一、MD五、Base64等
Collections：Java集合框架操做
Compress：Java提供文件打包壓縮類庫
Configuration：一個Java應用程序的配置管理類庫
DBCP：提供數據庫鏈接池服務
DbUtils：提供對JDBC的操做封裝來簡化數據查詢和記錄讀取操做
Email：Java發送郵件對JavaMail的封裝
FileUpload：提供文件上傳功能
HttpClient：提供HTTP客戶端與服務器的各類通信操做. 如今已改爲HttpComponents
IO：IO工具的封裝
Lang：Java基本對象方法的工具類包，如：StringUtils,ArrayUtils等等
Logging：提供的是一個Java 的日誌接口
Validator：提供了客戶端和服務器端的數據驗證框架

問題六、如何對SQL語句進行優化？

儘量合理運用索引
少用「*」，好比select * from tableName，只查詢本身須要的數據
使 用LIKE ‘%關鍵字%’模糊查詢時，因爲關鍵字前面用了「%」符號，所以該查詢一定會進行全表查詢，儘可能不要在關鍵字前加「%」符號
儘量減小子查詢的層數
儘量在子查詢中進行數據篩選
儘可能使用數字型字段，一部分開發人員和數據庫管理人員喜歡把包含數值信息的字段設計爲字符型，這會下降查詢和鏈接的性能，並會增長存儲開銷。這是由於引擎在處理查詢和鏈接會逐個比較字符串中每個字符，而對於數字型而言只須要比較一次就夠了。

2013年8月15日：

問題一、你所瞭解的測試技術,並說一下你以爲測試與開發之間的關係

一、按是否查看程序內部結構分爲：
黑盒測試：只關心輸入和輸出的結果
白盒測試：去研究裏面的源代碼和程序結構

二、按是否運行程序分爲：
靜態測試：是指不實際運行被測軟件，而只是靜態地檢查程序代碼、界面或文檔可能
動態測試：是指實際運行被測程序，輸入相應的測試數據，檢查輸出結果和預期結果是否相符的過程

三、按階段劃分：
單元測試：是指對軟件中的最小可測試單元進行檢查和驗證
集成測試：是單元測試的下一階段，是指將經過測試的單元模塊組裝成系統或子系統，再進行測試，重點測試不一樣模塊的接口部門。集成測試就是用來檢查各個單元模塊結合到一塊兒可否協同配合，正常運行
系統測試：指的是將整個軟件系統看作一個總體進行測試，包括對功能、性能，以及軟件所運行的軟硬件環境進行測試。系統測試的主要依據是《系統需求規格說明書》文檔
驗收測試：指的是在系統測試的後期，以用戶測試爲主，或有測試人員等質量保障人員共同參與的測試，它也是軟件正式交給用戶使用的最後一道工序。驗收測試又分爲a測試和beta測試，其中a測試指的是由用戶、測試人員、開發人員等共同參與的內部測試，而beta測試指的是內測後的公測，即徹底交給最終用戶測試

　　軟件開發是生產製造軟件；軟件測試是驗證開發出來軟件的質量
　　類比傳統加工製造企業，軟件開發人員就是生產加工的工人，軟件測試人員就是質檢人員
　　
開發與測試的關係應該是：
沒有軟件開發就沒有測試，軟件開發提供軟件測試的對象
軟件開發和軟件測試都是軟件生命週期中的重要組成部分
軟件開發和軟件測試都是軟件過程當中的重要活動
軟件測試是保證軟件開發產物質量的重要手段

問題二、Oracle裏varchar2的最大長度？

字段類型：Oracle SQL varchar2的最大支持長度爲4000個字節（bytes）
變量類型：Oracle PLSQL varchar2最大支持長度爲32767個字節（緩衝區）

問題三、如何判斷Session過時？

　　request.getSession(boolean)這個方法裏面傳了一個boolean值，這個值若是是true，那麼若是當前的Request的Session不可用，那麼就建立新的會話，若是存在就返回當前的會話。 若是參數是false，那麼在Request的當前會話不存在的時候就返回null
　　
if(request.getSession(false)==null){
　　System.out.println("Session has been invalidated!");
}
else{
　　System.out.println("Session is active!");
}

問題四、Oracle的行列轉換？

姓名科目分數
--- --- ----
太上語文 80
太上數學 70
太上英語 60
喚魔語文 90
喚魔數學 80
喚魔英語 100
轉換爲：
姓名語文數學英語
太上 80 70 60
喚魔 90 80 100

使用Oracle的Decode函數，若是「科目」是「語文」，返回對應科目的分數的綜合，0是缺省值

語句以下：
select 姓名,
sum(decode(科目,'語文', 分數,0)) "語文",
sum(decode(科目,'數學', 分數,0)) "數學",
sum(decode(科目,'英語', 分數,0)) "英語"
from table
group by 姓名;

2013年8月16日：

問題1：Hibernate框架下如何實現分頁？

Hibernate有自帶分頁功能
Query.setFirstResult() //從哪一條條記錄開始
Query.setMaxResults() //但願得到的記錄數

問題2：AJAX的優缺點？

優勢：
局部刷新頁面,減小用戶心理和實際的等待時間,帶來更好的用戶體驗
使用異步方式與服務器通訊，不須要打斷用戶的操做，具備更加迅速的響應能力
減輕服務器的負擔,按需取數據,最大程度的減小冗餘請求
基於XML標準化,並被普遍支持,不需安裝插件等

缺點：
AJAX大量的使用了JavaScript和AJAX引擎，這些取決於瀏覽器的支持。在編寫的時候考慮對瀏覽器的兼容性IE5.0及以上、Mozilla1.0、NetScape7及以上版本才支持，Mozilla雖然也支持AJAX，可是提供XMLHttpRequest的方式不同
AJAX更新頁面內容的時候並無刷新整個頁面，所以，網頁的後退功能是失效的； 有的用戶還常常搞不清楚如今的數據是舊的仍是已經更新過的這個就須要在明顯位置提醒用戶「數據已更新」
對流媒體還有移動設備的支持不太好等，好比手機還有平板電腦

問題三、Hibernate裏配置生成主鍵的方式有哪些？

Increment：
由Hibernate從數據庫中取出主鍵的最大值（每一個Session只取1次），以該值爲基礎，每次增量爲1， 在內存中生成主鍵，不依賴於底層的數據庫，所以能夠跨數據庫
特色：跨數據庫，不適合多進程併發更新數據庫，適合單一進程訪問數據庫，不能用於集羣環境
Hilo：
hilo（高低位方式high low）是Hibernate中最經常使用的一種生成方式，須要一張額外的表保存hi的值。保存hi值的表至少有一條記錄（只與第一條記錄有關），不然會出現錯誤。能夠跨數據庫
特色：跨數據庫，hilo算法生成的標誌只能在一個數據庫中保證惟一
Sehilo：
與hilo相似，經過hi/lo算法實現的主鍵生成機制，只是將hilo中的數據表換成了序列Sequence，須要數據庫中先建立Sequence，適用於支持Sequence的數據庫，如Oracle
特色：與hilo相似，只能在支持序列的數據庫中使用
Identity：
identity由底層數據庫生成標識符。identity是由數據庫本身生成的，但這個主鍵必須設置爲自增加，使用identity的前提條件是底層數據庫支持自動增加字段類型，如DB二、SQL Server、MySQL、Sybase和HypersonicSQL等，Oracle這類沒有自增字段的則不支持
特色：只能用在支持自動增加的字段數據庫中使用，如MySQL
Sequence：
採用數據庫提供的Sequence機制生成主鍵，須要數據庫支持Sequence。如ORACLE、DB、SAP DB、PostgerSQL、McKoi中的SequenceMySQL這種不支持Sequence的數據庫則不行（能夠使用identity）
特色：只能在支持序列的數據庫中使用，如Oracle
Native：
native由Hibernate根據使用的數據庫自行判斷採用identity、hilo、Sequence其中一種做爲主鍵生成方式，靈活性很強若是能支持identity則使用identity，若是支持Sequence則使用Sequence
特色： 根據數據庫自動選擇，項目中若是用到多個數據庫時，能夠使用這種方式，使用時須要設置表的自增字段或創建序列，創建表等
Uuid：
UUID：Universally Unique Identifier，是指在一臺機器上生成的數字，它保證對在同一時空中的全部機器都是惟一的。按照開放軟件基金會(OSF)制定的標準計算，用到了以太網卡地址、納秒級時間、芯片ID碼和許多可能的數字
特色： uuid長度大，佔用空間大，跨數據庫，不用訪問數據庫就生成主鍵值，因此效率高且能保證惟一性，移植很是方便，推薦使用
Assigned：
主鍵由外部程序負責生成，在 save() 以前必須指定一個Hibernate不負責維護主鍵生成，與Hibernate和底層數據庫都無關，能夠跨數據庫。在存儲對象前，必需要使用主鍵的setter方法給主鍵賦值，至於這個值怎麼生成，徹底由本身決定，這種方法應該儘可能避免
特色：能夠跨數據庫，人爲控制主鍵生成，應儘可能避免
Composite-id：複合主鍵，聯合主鍵

2013年8月17日：

問題一、Oracle是否支持Auto_Increment？如不支持如何實現相似功能？

創建一個Sequence序列:
CREATE SEQUENCE Sequence_Name
INCREMENT BY 1 每次加1個
START WITH 1 從1開始計數
NOMAXVALUE 不設置最大值
NOCYCLE ; 一直累加，不循環

創建一個TRIGGER觸發器:
CREATE OR REPLACE TRIGGER Trigger_Name
BEFORE
INSERT
ON Table_Name referencing NEW as NEW FOR EACH ROW 行級觸發，即每行都觸發
DECLARE
begin
　　select Sequence_Name.nextval into:New.increment_column from dual;
end;
/

問題二、建模使用什麼工具？

Rational Rose、Power Designer、StarUML、Enterprise Architect [ˈɑ:kitekt]

問題三、Svn主要做用？Svn的服務如何配置？

主要做用：版本控制管理和代碼服務器， 主要用於團隊開發時對項目代碼的管理

服務配置：
建立版本庫svnadmin create 版本庫路徑
建議註冊到services.msc服務中
命令：sc create/delete svn binPath= 「盤符:\subversion\bin\svnserve.exe –service –r 倉庫目錄」 DisplayName= 「邏輯名」
binPath的值以前必定要加空格

2013年8月19日：凱通軟件

問題一、Java基礎數據類型有哪些？最大長度分別是多少位？多少字節？

整數類型：
Byte 8位 1字節範圍：-128 ~ 127範圍：-27 ~ 27-1
Short 16位 2字節範圍：-32768 ~ 32767 範圍：-215 ~ 215-1
Int 32位4字節範圍：-2,147,483,648 ~ 2,147,483,647 範圍：-231 ~ 231-1
Long 64位8字節範圍：-9,223,372,036,854,775,808~+9,223,372,036,854,775,807 範圍：-263 ~ 263 -1

浮點數型：
Float 32位4字節範圍：-3,40292347E+38 ~ +3,40292347E+38範圍：
Double 64位8字節範圍：-1.79769313486231576E+308 ~ 1.79769313486231576E+308範圍：

其餘類型：
Char 16位2字節（默認Unicode編碼）範圍：‘\u0000′ ~ ‘\uFFFF’ 範圍：
Boolean 1位0.125字節（8分之1字節）範圍：true/false


注意：
Int最經常使用（20億左右），long能夠用在統計世界人口，byte，short用在特殊場合（若是知道存儲在變量中的整數在一個字節範圍內，就應該將變量聲明爲byte）
Double和Float，通常都使用double，double類型，由於double類型比float更精確。須要存儲大量數據才考慮單精度通常使用（float能夠節約內存）

問題二、String有哪些方法？

trim() 去掉起始和結尾的空格
charAt (int index) 返回index所指定的字符
concat(String str) 將兩字符串鏈接
equals() 比較兩個字符串
length() 返回字符串的長度
replace(char old ,char new) 將old用new替代
valueOf() 轉換爲字符串
substring(int1,int2) 取出字符串內第int1位置到int2的字符串

indexOf() 查找字符或者子串第一次出現的地方，lastIndexOf() 查找字符或者子串是後一次出現的地方
startsWith(String str) 測試字符串是否以str開始，endsWith(String str) 測試字符串是否以str結尾
getBytes 將字符串轉換成字節數組返回，toCharArray 將字符串轉換成字符數組
toLowerCase() 將字符串內的字符改寫成小寫，toUpperCase() 將字符串內的字符改寫成大寫

問題三、冒泡排序的代碼？

基本思想：
　　在要排序的一組數中，對當前還未排好序的範圍內的所有數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

實例：


冒泡排序（bubble sort）：冒泡排序，每次兩個相鄰的值進行比較，內層循環結束，最後出現最大值。

/*
冒泡排序，每次兩個相鄰的值進行比較，內層循環結束，最後出現最大值。
內層循環 arr.length-1 避免角標越界
arr.length-x 減小參與比較的數，由於這些數，已是最大值，排在最後，沒有必要參與比較。
*/
public static void bubbleSort(int[] arr){
for(int x=0;x<arr.length;x++){
for(int y=0;y<arr.length-1-x;y++){
if(arr[y]>arr[y+1]){
int temp =arr[y+1];
arr[y+1]=arr[y];
arr[y]=temp;
}}}}

問題四、選擇排序的代碼？

基本思想：
　　在要排序的一組數中，選出最小的一個數與第一個位置的數交換；而後在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二個數和最後一個數比較爲止。

實例：


/*
選擇排序。內循環結束 0角標位出現最小值。只要外層循環的值比內層循環值大，就互換位置。
0角標位的元素，和0角標位之後的每一個元素進行比較，只要比他們大就互換，位置，這樣能夠保證0角標位置值最小。
而後，再進行1角標位置和1角標後的每一個元素進行比較。
依次類推，

*/
public static void selectSort(int[] arr){
for(int x=0;x<arr.length-1;x++){
for(int y=x+1;y<arr.length;y++){
if(arr[x]>arr[y]){
int temp=arr[y];
arr[y]=arr[x];
arr[x]=temp;
}}}}

問題五、inner join、left join、right join、full out join有什麼區別？

left join是以A表的記錄爲基礎的，A能夠當作左表，B能夠當作右表，left join是以左表爲準的.。
換句話說，左表(A)的記錄將會所有表示出來，而右表(B)只會顯示符合搜索條件的記錄(例子中爲: A.aID = B.bID)，B表記錄不足的地方均爲NULL。
範例代碼：
SELECT C.First_Name, C.Last_Name, O.Order_Id FORM Customer AS C　LEFT JOIN Order AS O ON C.Customer_ID = O.Customer_ID

right join和left join的結果恰好相反，此次是以右表(B)爲基礎的，A表不足的地方用NULL填充。
inner join只顯示出了 A.aID = B.bID的記錄，這說明inner join並不以誰爲基礎，它只顯示符合條件的記錄。

Oracle中的使用：
鏈接分爲兩種：內鏈接與外鏈接。

A．內鏈接，即最多見的等值鏈接，例：
SELECT *
FROM TESTA,TESTB
WHERE TESTA.A=TESTB.A
等價於
select * from testa inner join testb on testa.a=testb.a

B.外鏈接分爲左外鏈接，右外鏈接和全外鏈接。
1．左外鏈接 left outer join 或者 left join
左外鏈接就是在等值鏈接的基礎上加上主表中的未匹配數據，例：
SELECT *
FROM TESTA
LEFT OUTER JOIN TESTB
ON TESTA.A=TESTB.A
---------------------其中主表是TESTA。
Oracle 中等價於: (+)是outer join 的意思，能將匹配備件中有空值的記錄也顯示出來，若是沒有這個符號，則不會顯示條件中包含空值的結果。
SELECT *
FROM TESTA,TESTB
WHERE TESTA.A=TESTB.A(+)

三個表作左外鏈接：
SELECT *
FROM TESTA
LEFT OUTER JOIN TESTB
ON TESTA.A=TESTB.A
LEFT OUTER JOIN TESTC
ON TESTA.A=TESTC.A
Oracle 中等價於:
SELECT *
FROM TESTA,TESTB,TESTC
WHERE TESTA.A=TESTB.A(+)
AND TESTA.A=TESTC.A(+)

2．右外鏈接 right outer join 或者 right join，是在等值鏈接的基礎上加上被鏈接表的不匹配數據。
SELECT *
FROM TESTA
RIGHT OUTER JOIN TESTB
ON TESTA.A=TESTB.A
----------------------其中被鏈接表是TESTB
Oracle支持的另外一種寫法：
SELECT *
FROM TESTA,TESTB
WHERE TESTA.A(+)=TESTB.A

3.全外鏈接 full outer join 或者 full join，是在等值鏈接的基礎上將左表和右表的未匹配數據都加上。
SELECT *
FROM TESTA
FULL OUTER JOIN TESTB
ON TESTA.A=TESTB.A
全外鏈接的等價寫法，對同一表先作左鏈接，而後右鏈接：
SELECT TESTA.*,TESTB.*
FROM TESTA
LEFT OUTER JOIN TESTB
ON TESTA.A=TESTB.A
UNION
SELECT TESTA.*,TESTB.*
FROM TESTB
LEFT OUTER JOIN TESTA
ON TESTA.A=TESTB.A

2013年8月20日：

問題一、JS中有哪些數據類型？

Undefined、Null、Boolean、Number、String、Object、Array、Function。
　　JavaScript有三種基本數據類型（字符串、數值、布爾），兩種引用數據類型（對象、數組）和兩種特殊數據類型（Null 、Undefined ）。

問題二、String 和StringBuffer的區別？

　　JAVA平臺提供了兩個類：String和StringBuffer，它們能夠儲存和操做字符串，即包含多個字符的字符數據。
　　String類表示內容不可改變的字符串。而StringBuffer類表示內容能夠被修改的字符串。當你知道字符數據要改變的時候你就能夠使用StringBuffer。
　　典型地，你能夠使用StringBuffers來動態構造字符數據。
　　另外，String實現了equals方法，new String(「abc」).equals(new String(「abc」)的結果爲true,而StringBuffer沒有實現equals方法，因此，new StringBuffer(「abc」).equals(new StringBuffer(「abc」)的結果爲false。

接着要舉一個具體的例子來講明，咱們要把1到100的全部數字拼起來，組成一個串。
　　StringBuffer sbf = new StringBuffer();
for(int i=0;i<100;i++)
{
sbf.append(i);
}
上面的代碼效率很高，由於 只建立了一個StringBuffer對象，而下面的代碼效率很低，由於建立了101個對象。
　　String str = new String();
for(int i=0;i<100;i++)
{
str = str + i;
}
　　在講二者區別時，應把循環的次數搞成10000，而後用endTime-beginTime來比較二者執行的時間差別，最後還要講講StringBuilder與StringBuffer的區別。
　　String覆蓋了equals方法和hashCode方法，而StringBuffer沒有覆蓋equals方法和hashCode方法，因此，將StringBuffer對象存儲進Java集合類中時會出現問題。

問題三、StringBuffer與StringBuilder的區別？

　　StringBuffer和StringBuilder類都表示內容能夠被修改的字符串，StringBuilder是線程不安全的，運行效率高，若是一個字符串變量是在方法裏面定義，這種狀況只可能有一個線程訪問它，不存在不安全的因素了，則用StringBuilder。若是要在類裏面定義成員變量，而且這個類的實例對象會在多線程環境下使用，那麼最好用StringBuffer。
　　
　　String 不可變每次對其操做都會在數據池產生一個新的對象 ，不適合使用在對字符串進行頻繁修改的場景
　　StringBuffer和StringBuilder可變，對其修改不會產生新的對象其二者區別在於StringBuffer線程安全而StringBuilder線程不安全，StringBuilder是線程非安全的效率比StringBuffer高
　　
　　比喻：
　　String是一個商品
　　StringBuffer/StringBuilder是生產這個商品的流水線，
　　StringBuffer速度慢，但（線程）安全性高
　　StringBuilder速度快，但（線程）安全性差

問題四、Threadlocal類的做用？
　　
　　 ThreadLocal的做用和目的：用於實現線程內的數據共享，即對於相同的程序代碼，多個模塊在同一個線程中運行時要共享一份數據，而在另外一個線程中則共享另外一份數據，線程的數據是獨享的。
　　
　　ThreadLocal的實現原理：每一個線程調用全局ThreadLocal的set方法， 就至關於往其內部的Map中增長一條記錄，key是各自的線程，value是各自的線程調用set放進的值。在線程結束時能夠調用ThreadLocal.clear()方法，能夠當即釋放內存。也能夠不調用，線程運行完成以後內存也會被回收。
　　
　　顧名思義它是local variable（線程局部變量）。它的功用很是簡單，就是爲每個使用該變量的線程都提供一個變量值的副本，是每個線程均可以獨立地改變本身的副本，而不會和其它線程的副本衝突。從線程的角度看，就好像每個線程都徹底擁有該變量。
　　
　　它主要由四個方法組成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，該方法是一個protected的方法，顯然是爲了子類重寫而特地實現的。該方法返回當前線程在該線程局部變量的初始值，這個方法是一個延遲調用方法，在一個線程第1次調用get()或者set(Object)時才執行，而且僅執行1次。ThreadLocal中的確實實現直接返回一個null。也是解決線程安全的問題的一種方法。

問題五、Statement、Preparedstatement、的區別？

Statement
|
PreparedStatement
|
CallableStatement

Statement用於執行一條普通的動態SQL語句， PreparedStatement用於執行預編譯好的SQL語句，。他們的繼承關係如上。

Statement 每次執行sql語句，數據庫都要執行sql語句的編譯，最好用於僅執行一次查詢並返回結果的情形，效率高於PreparedStatement.

PreparedStatement是預編譯的，使用PreparedStatement有幾個好處
在執行可變參數的一條SQL時，PreparedStatement比Statement的效率高，由於DBMS預編譯一條SQL固然會比屢次編譯一條SQL的效率要高。
安全性好，有效防止Sql注入等問題。
對於屢次重複執行的語句，使用PreparedStament效率會更高一點，而且在這種狀況下也比較適合使用batch；
代碼的可讀性和可維護性。

CallableStatement接口擴展 PreparedStatement，用來調用存儲過程,它提供了對輸出和輸入/輸出參數的支持。CallableStatement 接口還具備對 PreparedStatement 接口提供的輸入參數的支持。

問題六、把一個字符串類型的日期轉換成Date類型？

字符串轉換爲日期：
　　String brithday = new String("1991-02-02");
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf1.parse(brithday);
System.out.println("將字符串轉化爲時間是" + date);
日期轉換爲字符串：
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyyMMDDHHMMSSmmm ");
System.out.println(sdf2.format(new Date()));

將輸入的字符串轉換爲須要的日期格式：
String myBirthday = new String("19881113");
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyyMMdd");
Date date = sdf3.parse(myBirthday);
String newBirthday = sdf2.format(date);
System.out.println("將輸入的字符串轉換爲須要的日期格式" + newBirthday);

問題七、Spring中加載XML配置文件的方法？

Spring中的幾種容器都支持使用xml裝配bean，包括：
XmlBeanFactory引用資源、 ClassPathXmlApplicationContext編譯路徑
FileSystemXmlApplicationContext用文件系統的路徑、 XmlWebApplicationContext專爲Web工程定製

加載這些容器的配置文件的XML有如下幾種常見的方法：
一、引用資源用XmlBeanFactory（不能實現多個文件相互引用）
Resource resource = new ClassPathResource("appcontext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
從factory中獲取相應資源文件中的bean，可是這種bean讀不到引用了其餘文件中的bean！
二、引用應用上下文用ClassPathXmlApplicationContext
ApplicationContext factory = new ClassPathXmlApplicationContext(
"classpath:applicationContext.xml");
ApplicationContext factory = new ClassPathXmlApplicationContext(
"conf/userConfig.xml"); // src/conf 目錄下的
ApplicationContext factory = new ClassPathXmlApplicationContext(
"file:G:/Test/src/appcontext.xml");
三、用文件系統的路徑引用應用上下文用FileSystemXmlApplicationContext
ApplicationContext factory = new FileSystemXmlApplicationContext(
"src/applicationContext.xml");
ApplicationContext factory = new FileSystemXmlApplicationContext(
"classpath:appcontext.xml");
ApplicationContext factory = new FileSystemXmlApplicationContext(
"file:G:/Test/src/appcontext.xml");
ApplicationContext factory = new FileSystemXmlApplicationContext(
"G:/Test/src/appcontext.xml");
注意：在二、3的加載方式中能夠加載多個配置文件，獲取到ApplicationContext 對象中
String[] configs = { "applicationContext.xml", "user_spring.xml" };
ApplicationContext ctx = new ClassPathXmlApplicationContext(configs);
// ApplicationContext ctx=new FileSystemXmlApplicationContext(configs);
AbstractDao myUserDAO = (AbstractDao) ctx.getBean("userDao");
四、Web工程定製的加載方法 XmlWebApplicationContext
ServletContext servletContext = request.getSession()
.getServletContext();
　ApplicationContext ctx = WebApplicationContextUtils
.getWebApplicationContext(servletContext);
注：web.xml裏面能夠定義兩種參數：
application範圍內的參數，存放在servletcontext中。<context-param>中的參數（能夠指定多個文件）
servlet範圍內的參數，只能在servlet的init()方法中取得， <init-param>中的參數，在init方法中用this.getInitParameter("param1")獲取

要在spring配置多個xml，而且這些文件相互應用的加載方式：
一、在web.xml配置，應用服務去加載
<servlet>
<servlet-name>app</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<context-param>
<param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext*.xml,/WEB-INF/user_spring*.xml</param-value>
</context-param>
<load-on-startup>1</load-on-startup>
</servlet>
二、在/WEB-INF/applicationContext.xml配置應用服務去加載
能夠在applicationContext.xml中用import引入其餘的配置文件
<import resource="user_spring.xml" />

問題八、查詢分組後，每一個分組前幾條記錄？

建表語句：
/* 建立表並初始化數據 */
drop table if exists Orders;
create table Orders(
id int primary key auto_increment,
Company varchar(255),
OrderNumber varchar(255),
);
插入數據：
insert into Orders(Company,OrderNumber, pid) values('IBM','3532',1);
insert into Orders(Company,OrderNumber, pid) values('IBM','4211',1);
insert into Orders(Company,OrderNumber, pid) values('IBM','2342',2);
insert into Orders(Company,OrderNumber, pid) values('IBM','12345',3);
insert into Orders(Company,OrderNumber, pid) values('W3School','45323',1);
insert into Orders(Company,OrderNumber, pid) values('W3School','2356',2);
insert into Orders(Company,OrderNumber, pid) values('Apple','4538',1);
insert into Orders(Company,OrderNumber, pid) values('Apple','4698',2);
insert into Orders(Company,OrderNumber, pid) values('Apple','3234',2);
insert into Orders(Company,OrderNumber, pid) values('Apple','3232',3);
insert into Orders(Company,OrderNumber, pid) values('W3School','6953',3);
insert into Orders(Company,OrderNumber) values('W3School','6953');

查詢語句：/* 查詢Orders表，以Company分組，查出每組中的前兩個記錄 */
SELECT * FROM Orders o WHERE 2 >(SELECT count(*) FROM Orders WHERE Company = o.Company and OrderNumber > o.OrderNumber);

問題九、外部js中如何使用EL表達式？

外部js中的el表達式默認無效，有如下解決方案：
一、把數據保存在隱藏域中，而後由js去調
例如jsp中<input type="hidden" id="data" name="data" value="${xxx.data}">
js中,用getElementById方法
二、若是js非要放入單獨文件中,能夠把js文件命名爲.jsp文件就能夠了，這樣裏面el就能運行，也就是服務器能夠執行這個文件了。無非頁面引用的時候引用jsp就能夠了。
<script src="myjs.jsp" type="text/javascript></script>

EL表達式是在服務端執行的，服務端執行完成後再傳給客戶端的，js是在客戶端執行的，el在js前就被執行了。

把引入的外部js改成jsp文件，而後在jsp頁面中引入<script src="myjs.jsp"></script>

在徹底是js的jsp文件中，在執行的時候會出現亂碼
在頂部加入
<%@page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>可解決亂碼

而後在jsp頁面中引入myjs.jsp,
<script src="myjs.jsp" type="text/javascript"></script>

可是若是js文件有建立html，就會出現錯誤，好比document.createElement('<option>' );即便轉義後
document.createElement('<option>' ); 也沒有效果，在解析的時候，會建立
document.createElement('<html><option>' );使用時候不識別的標識符
能夠直接使用document.createElement('option')

火狐不支持select.options.appendChild(option),IE支持
select.appendChild(option) IE和Firefox都支持

火狐不支持option.innerText="test",
爲兼容改寫爲option.innerHTML="test"

問題十、給你一張表查詢同一IP的登陸次數，以及登陸次數大於10次的IP？
給的參數是 id datetime url session_id ip

select 記錄, count(記錄) from 表 where 記錄=表.記錄 group by 記錄 having count(記錄)>10

select count(ip),ip from table group by ip having count(ip)>10;

問題十一、<jsp:include>和<%@include file=""%>有什麼區別？

動態：<jsp:include page="">--動做，運行時包含，先處理後包含
父頁面和包含進來的頁面單獨編譯，單獨翻譯成servlet後，在前臺拼成一個HTML頁面。
a.能自動區分被包含文件是靜態仍是動態；
b.若是被包含文件是靜態文件，處理方式跟第1種方式同樣，
若是是動態文件，則各自處理完以後把結果包含進來發給客戶端。

靜態：<%@include file=""%>--指令，編譯時包含，先包含後處理
父頁面和包含進來的頁面，代碼合併後，才一塊兒翻譯成servlet，反饋到前臺，造成一個HTML頁面。
a.無論被包含文件是靜態仍是動態，直接將頁面中的所有內容包含進來；
b.執行時先將包含進來的內容一塊兒處理完以後再將全部的內容發給客戶端。

2013年8月22日：嘉瑤軟件

問題一、使用JavaScript動態添加刪除表格行？

<script type="text/javascript">
//動態增長和刪除表格行的內容
document.getElementById("addID").onclick = function(){
var tbodyElement = document.getElementById("tbodyID");
//建立tr元素
var trElement = document.createElement("tr");
//建立td元素
var td1Element = document.createElement("td");
var td2Element = document.createElement("td");
var td3Element = document.createElement("td");
　　//建立刪除按鈕
var delInputElement = document.createElement("input");
delInputElement.type = "button";
delInputElement.value = "刪除";

td3Element.appendChild(delInputElement);
//爲刪除按鈕添加單擊事件
delInputElement.onclick = function(){
//this表示刪除按鈕
//父.removeChild(子);
//this.parentNode.parentNode.parentNode.removeChild(this.parentNode.parentNode);
tbodyElement.removeChild(trElement);
}
//將td元素添加到tr元素中
trElement.appendChild(td1Element);
trElement.appendChild(td2Element);
trElement.appendChild(td3Element);
//將tr元素添加到tbody元素中
tbodyElement.appendChild(trElement);
}
function trim(message){ //去空格，正則表達式
return message.replace(/^\s*$/,"");
}
</script>

問題二、什麼叫面向接口編程？有什麼好處？

　　在系統分析和架構中，分清層次和依賴關係，每一個層次不是直接向其上層提供服務（即不是直接實例化在上層中），而是經過定義一組接口，僅向上層暴露其接口功能，上層對於下層僅僅是接口依賴，而不依賴具體類。

　　這樣作的好處是顯而易見的，首先對系統靈活性大有好處。當下層須要改變時，只要接口及接口功能不變，則上層不用作任何修改。甚至能夠在不改動上層代碼時將下層整個替換掉，就像咱們將一個WD的60G硬盤換成一個希捷的160G的硬盤，計算機其餘地方不用作任何改動，而是把原硬盤拔下來、新硬盤插上就好了，由於計算機其餘部分不依賴具體硬盤，而只依賴一個IDE接口，只要硬盤實現了這個接口，就能夠替換上去。從這裏看，程序中的接口和現實中的接口極爲類似，因此我一直認爲，接口（interface）這個詞用的真是神似！
　　
使用接口的另外一個好處就是不一樣部件或層次的開發人員能夠並行開工，就像造硬盤的不用等造CPU的，也不用等造顯示器的，只要接口一致，設計合理，徹底能夠並行進行開發，從而提升效率。

問題三、事務的概念？開發中如何使用事務？

事務指邏輯上的一組操做，組成這組操做的各個單元，要麼所有成功，要麼所有失敗。

MySQL數據庫開啓事務命令：
start transaction 開啓事務
rollback 回滾事務
commit 提交事務
savepoint 設置回滾點
rollback to savepoint 回滾到指定的回滾點

問題四、遞歸算法題：一個整數，大於0，不用循環和本地變量，按照n，2n，4n，8n的順序遞增，當值大於10000時，把值按照指定順序輸出來。先順序後逆序

public static void main(String[] args) throws Exception {
doubleNum(512);
}

public static void doubleNum(int n) {
System.out.println(n);
if (n <= 10000)
doubleNum(n * 2);
System.out.println(n);
}

問題五、兩個div 並排放到同一個div上面？

第一步：
中間兩個div 設置的寬度加起來等於1000px,
第二步：
中間兩個div 分別加樣式 style="float:left;"

例如：
<div style="width:1000px;height:500px;background: black;">
<div style="background: blue;width: 500px;height:500px;float:left;"></div>
<div style="background: blue;width: 500px;height:500px;float:left;"></div>

問題六、一個表有birthday字段類型爲date，讓你查出年齡？

SELECT name,(year(now())-year(birthday)) AS age FROM Student;

問題七、智力題：一個房間有三個燈泡，開關在房間外面，你只能進房間一次，找出燈泡和開關的對應關係

先開第1個開關，開較長時間再關掉，而後開第2個開關，立刻進有燈泡的房間。
若是是亮的，是第2個開關。
若是是暗的，就摸一摸，熱的就是第1個開關，冷的就是第3個開關。

2013年8月23日：

問題一、操做表格的奇數行、偶數行變色的函數？

<script type="text/javascript" src="WEB-INF/jquery-1.7.min.js">
</script>

<script type="text/javascript" language="javascript">
$(document).ready(function(){
$("table tr:eq(0)").attr("style","background: #C00;"); //首行
$("table tr:odd").attr("style","background:#09F;"); //奇數行
$("table tr:even").attr("style","background: #C00;"); //偶數行
//或者經過添加css，以下
$("table tr:eq(0)").css("background-color","pink"); //首行
$("table tr:odd").css("background-color","blue"); //索引號爲奇數的
$("table tr:even").css("background-color","yellow"); //索引號爲偶數的
});
　　</script>

問題二、 JSON與XML的區別？

　　 相同之處兩個都是存放數據的。要說不一樣，那就是存數據的方式不同，xml數據寫在xml文件中，而json須要程序添加數據，xml是一個特殊的數據文件必須符合必定的規則

格式不一樣， XML是標籤式的：aaa bbb，JSON是鍵值對形式的：book:{ name:aaa, writter:bbb }，JSON更加輕量級，XML開始使用比較早，並且很嚴謹，二者都有普遍應用，不過如今比較推薦JSON。

問題三、JDBC的使用過程？

簡易流程：
一、加載驅動二、獲取鏈接三、SQL語句執行者四、執行SQL 五、釋放資源後開啓的先關閉

建立一個以JDBC鏈接數據庫的程序，包含7個步驟：
一、加載JDBC驅動程序：
在鏈接數據庫以前， 首先要加載想要鏈接的數據庫的驅動到JVM（Java虛擬機），這經過java.lang.Class 類的靜態方法forName(String className)實現。
//加載MySql的驅動類
Class.forName("com.mysql.jdbc.Driver");
成功加載後，會將Driver類的實例註冊到DriverManager類中。
二、提供JDBC鏈接的URL
例如：（MySql的鏈接URL）
jdbc:mysql://localhost:3306/test
三、 建立數據庫的鏈接
　　要鏈接數據庫，須要向java.sql.DriverManager請求並得到Connection對象，該對象就表明一個數據庫的鏈接。
　　使用DriverManager的getConnectin(String url, String username,String password )方法傳入指定的欲鏈接的數據庫的路徑、數據庫的用戶名和密碼來得到。
例如：// 鏈接MySql數據庫，用戶名和密碼都是root
String url = "jdbc:mysql://localhost:3306/test";
String username = "root";
String password = "root";
Connection con = DriverManager.getConnection(url, username, password);
四、 建立一個Statement
要執行SQL語句，必須得到java.sql.Statement實例，Statement實例分爲如下3種類型：
　　一、執行靜態SQL語句。一般經過Statement實例實現。
　　二、執行動態SQL語句。一般經過PreparedStatement實例實現。
　　三、執行數據庫存儲過程。一般經過CallableStatement實例實現。
具體的實現方式：
　　Statement stmt = con.createStatement();
PreparedStatement pstmt = con.prepareStatement(sql);
CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}");
五、 執行SQL語句
Statement接口提供了三種執行SQL語句的方法：executeQuery 、executeUpdate和execute
　　一、executeQuery(String sqlString)：執行查詢數據庫的SQL語句， 返回一個結果集（ResultSet）對象。
　　二、executeUpdate(String sqlString)：用於執行INSERT、UPDATE或DELETE語句以及SQL DDL語句，如：CREATE TABLE和DROP TABLE等，返回影響行數int。
　　三、execute(sqlString):用於執行返回多個結果集、多個更新計數或兩者組合的語句。
具體實現的代碼：
ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;
int rows = stmt.executeUpdate("INSERT INTO ...") ;
boolean flag = stmt.execute(String sql) ;
六、處理結果，兩種狀況：
一、執行更新返回的是本次操做影響到的記錄數。
二、執行查詢返回的結果是一個ResultSet對象。
ResultSet包含符合SQL語句中條件的全部行，而且它經過一套get方法提供了對這些行中數據的訪問。
使用結果集（ResultSet）對象的訪問方法獲取數據：
while (rs.next()) {
String name = rs.getString("name");
String pass = rs.getString(1); // 此方法比較高效
}
（列是從左到右編號的，而且從列1開始）
七、 關閉JDBC對象
操做完成之後要把全部使用的JDBC對象全都關閉，以釋放JDBC資源，關閉順序和聲明順序相反：
　　一、關閉記錄集
　　二、關閉聲明
　　三、關閉鏈接對象
rs.close();
stmt.close();
conn.close();

問題四、Tomcat的默認端口號是多少，如何更改端口號？

8080是Tomcat服務器的默認的端口號。
咱們能夠經過修改Tomcat服務器的conf目錄下的主配置文件server.xml來更改。
用記事本打開server.xml文件，找到以下部分:修改port的值便可
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />

問題五、List與Set有什麼區別？

Set List都繼承 Colltction。

List接口與其實現類是容量可變的列表，可按索引訪問集合中的元素，是有序的集合。
Set是一種不包含重複元素的Collection,也就是說 Set中只能有一個null元素。

List和Set是兩個接口，其定義的數據類型都有本身的特色
List是順序結構，能夠是數組也能夠是鏈表，Set就是集合，跟數學裏的集合定義樣，無重複（沒有任何兩個對象的equals方法是true）。

問題六、說出JAVA中一些經常使用的類，包，接口，請各舉5個？

類:Object、String、Integer、System、file、FileInputStream、FileOutputStream
包:lang包、io包、util包、sql包、date包、swt包
接口: List、Map、Iterator、Connection、Writer、Reader、InputStream、OutPutStream
v
問題七、常見的異常有哪些，舉幾個，並說出它們是如何出現的呢？

NullPointException空指針異常
IOException輸入輸出流異常
ClassNotFoundException類型轉換異常
ArrayIndexOutOfBoundsException下標越界異常
NumberFormatException數字格式化異常
FileNotFoundException文件未找到異常
SQLException操做數據庫異常
NoSuchMethodException方法未找到異常

問題九、int和Integer有什麼區別，Integer下有哪些經常使用方法？

　　int是Java提供的8種基礎數據類型之一。Java爲每一個原始類型提供了包裝類，Integer是java爲int提供的包裝類。
　　int的默認值爲0，而Integer的默認值爲null，即Integer能夠區分出未賦值和值爲0的區別，int則沒法表達出未賦值的狀況。
　　例如，要想表達出沒有參加考試和考試成績爲0的區別，則只能使用Integer。
　　在JSP開發中，Integer的默認爲null，因此用EL表達式在文本框中顯示時，值爲空白字符串，而int默認的默認值爲0，因此用EL表達式在文本框中顯示時，結果爲0，因此，int不適合做爲web層的表單數據的類型。
　　在Hibernate中，若是將OID定義爲Integer類型，那麼Hibernate就 能夠根據其值是否爲null而判斷一個對象是不是臨時的，若是將OID定義爲了int類型，還須要在hbm映射文件中設置其unsaved-value屬性爲0。
　　另外，Integer提供了多個與整數相關的操做方法，例如， 將一個字符串轉換成整數，Integer中還定義了表示整數的最大值和最小值的常量。



問題十一、面向對象的特徵有哪些？解釋一下每個？

　　封裝指的是將對象的狀態信息隱藏在對象內部，不容許外部程序直接訪問對象內部信息，而是經過該類所提供的方法來實現對內部信息的操做和訪問。
　　封裝實際上有兩個方面的含義：把該隱藏的（對象的屬性和實現細節）隱藏起來，把該暴露的（方法）暴露出來。這兩個方面都須要經過使用Java提供的訪問控制符來實現。
　　
　　繼承是面向對象實現軟件複用的重要手段，當子類繼承父類後，子類做爲一種特殊的父類，將直接得到父類的屬性和方法。Java的繼承具備單繼承的特色，每一個子類只有一個直接父類。
　　
　　多態指的是子類對象能夠直接賦給父類變量，但運行時依然表現子類的行爲特徵，這意味着同一個類別的對象在運行時可能表現出不一樣的行爲特徵。
　　只有子類重寫了父類的方法。使用父類類型建立的引用變量，所賦的值爲子類類型建立的實例（對象）時，用這個新建的對象調用子類重寫父類的方法纔會出現多態。
　　也就是說多態有3個條件：一、繼承二、重寫(子類重寫父類繼承的方法) 三、父類引用指向子類對象

好處：
封裝：安全
繼承：重用
多態：靈活

問題十二、方法的重寫和重載？

重寫父類的方法
方法的重寫要遵循「兩同兩小一大」規則：

　　「兩同」即方法名相同、形參列表相同，「兩小」指子類方法返回值類型應比父類方法返回值類型更小或相等，子類方法聲明拋出的異常應比父類方法聲明拋出的異常類更小或相等。
　　「一大」指的是子類方法的訪問權限應比父類方法更大或相等，尤爲須要指出的是，覆蓋方法和被覆蓋方法要麼都是類方法，要麼都是實例方法，不能一個是類方法，一個是實例方法。

　　當子類覆蓋了父類的方法後，子類的對象將沒法訪問父類中被覆蓋的方法，但能夠在子類方法中調用父類中被覆蓋的方法。
若是要在子類中調用父類中被覆蓋的實例方法，能夠使用super。
若是要在子類中調用父類中被覆蓋的類方法，使用父類類名來調用。
　　 若是父類方法具備private訪問權限，則該方法對其子類是隱藏的，所以其子類沒法訪問該方法，也就沒法重寫該方法。

二、方法的重寫與方法的重載不一樣，方法的重載要遵循「兩同，一個不一樣」規則：

「兩同」即同一個類中、方法名相同，「一個不一樣」即形參列表不一樣。

Java容許同一個類裏定義多個同名的方法，只要形參列表不一樣便可。若是同一個類中包含了兩個或兩個以上的方法名相同，但參數列表不一樣，則被稱爲方法重載。至於方法的其餘部分，如方法返回值類型、修飾符等，與方法重載沒有任何關係。

注意：
參數列表順序不一樣：（String x,int y）和（int x,String y）不會報錯
參數列表類型相同變量名不一樣：（int x,int y）和（int y,int x）編譯器會報錯
沒法經過返回值類型不一樣來進行重載

問題1三、第1我的10，第2個比第1我的大2歲，依次遞推，請用遞歸方式計算出第8我的多大？

　　public static int calAge(int n) {
if (1 == n)
return 10;
return calAge(n - 1) + 2;
}

public static void main(String[] args) {
System.out.println("第八個屌絲的年齡是：" + calAge(8));
}
n=3的話，
第一次：3-1 10+2+2
第二次：3-2 10+2
第三次：返回10 往上回去算


問題1四、一口井,深10米.一個蝸牛從井底往上爬. 白天爬3米,晚上掉2米.問幾天能爬出來？

第一天高度=3-2=1米
次日高度=1+3-2=2米
第三天高度=2+3-2=3米
第四天高度=3+3-2=4米
第五天高度=4+3-2=5米
以此類推...
第8天高度=7+3=10米，已經爬出來了。
因此：8天爬出來。注意：這裏是一口氣爬出來，若是爬不出來的話須要再加1天

2013年8月24日：

問題一、String s="a"+"b"+"c" 建立了幾個對象？

就建立了1個
String s = "a" + "b" + "c" + "d" + "e";
賦值符號右邊的"a"、"b"、"c"、"d"、"e"都是常量
對於常量，編譯時就直接存儲它們的字面值而不是它們的引用
在編譯時就直接講它們鏈接的結果提取出來變成了"abcde"
該語句在class文件中就至關於String s = "abcde"
而後當JVM執行到這一句的時候，就在String pool裏找
若是沒有這個字符串，就會產生一個

問題二、Spring事務管理的7種傳播行爲和4種隔離級別？

REQUIRED： 業務方法須要在一個事務中運行。若是方法運行時，已經處在一個事務中，那麼加入到該事務，不然爲本身建立一個新的事務。
   REQUIRES_NEW： 屬性代表無論是否存在事務，業務方法總會爲本身發起一個新的事務。若是方法已經運行在一個事務中，則原有事務會被掛起，新的事務會被建立，直到方法執行結束，新事務纔算結束，原先的事務纔會恢復執行。
NOT_SUPPORTED： 聲明方法不須要事務。若是方法沒有關聯到一個事務，容器不會爲它開啓事務。若是方法在一個事務中被調用，該事務會被掛起，在方法調用結束後，原先的事務便會恢復執行。

SUPPORTS： 這一事務屬性代表，若是業務方法在某個事務範圍內被調用，則方法成爲該事務的一部分。若是業務方法在事務範圍外被調用，則方法在沒有事務的環境下執行。

MANDATORY： 該屬性指定業務方法只能在一個已經存在的事務中執行，業務方法不能發起本身的事務。若是業務方法在沒有事務的環境下調用，容器就會拋出例外。


NEVER： 指定業務方法絕對不能在事務範圍內執行。若是業務方法在某個事務中執行，容器會拋出例外，只有業務方法沒有關聯到任何事務，才能正常執行。

NESTED： 若是一個活動的事務存在，則運行在一個嵌套的事務中. 若是沒有活動事務, 則按REQUIRED屬性執行。它使用了一個單獨的事務，這個事務擁有多個能夠回滾的保存點。內部事務的回滾不會對外部事務形成影響。它只對DataSourceTransactionManager事務管理器起效

事務隔離級別：

　　數據庫系統提供了四種事務隔離級別供用戶選擇。不一樣的隔離級別採用不一樣的鎖類型來實現，在四種隔離級別中，Serializable的隔離級別最高，ReadUncommited的隔離級別最低。
　　大多數據庫默認的隔離級別爲ReadCommited，如SqlServer、Oracle，固然也有少部分數據庫默認的隔離級別爲RepeatableRead，如Mysql。

ReadUncommited：讀未提交數據(會出現髒讀,不可重複讀和幻讀)
ReadCommited：讀已提交數據(會出現不可重複讀和幻讀)
RepeatableRead：可重複讀(會出現幻讀)
Serializable：串行化

髒讀：一個事務讀取到另外一事務 未提交的更新新據。
不可重複讀：在同一事務中，屢次讀取同一數據返回的結果有所不一樣。換句話說就是，後續讀取能夠讀到另外一事務已提交的更新數據。相反，「可重複讀」在同一事務中屢次讀取數據時，可以保證所讀數據同樣，也就是，後續讀取不能讀到 另外一事務已提交的更新數據。
幻讀：一個事務讀取到另外一事務已 提交的insert數據。

問題三、AJAX的原理？

　　AJAX的原理簡單來講經過XmlHttpRequest對象來向服務器發異步請求，從服務器得到數據，而後用JavaScript來操做DOM而更新頁面。這其中最關鍵的一步就是從服務器得到請求數據。要清楚這個過程和原理，咱們必須對 XMLHttpRequest有所瞭解。
　　XMLHttpRequest是AJAX的核心機制，它是在IE5中首先引入的，是一種支持異步請求的技術。簡單的說，也就是JavaScript能夠及時向服務器提出請求和處理響應，而不阻塞用戶。達到無刷新的效果。
　　因此咱們先從XMLHttpRequest講起，來看看它的工做原理。首先，咱們先來看看XMLHttpRequest這個對象的屬性。
它的屬性有：
　　onReadyStateChange 每次狀態改變所觸發事件的事件處理程序
　　responseText 從服務器進程返回數據的字符串形式
　　responseXML 從服務器進程返回的DOM兼容的文檔數據對象
status 從服務器返回的數字代碼，好比常見的404（未找到）和200（已就緒）
　　status Text 伴隨狀態碼的字符串信息
　　readyState 對象狀態值

　　0 (未初始化) 對象已創建，可是還沒有初始化（還沒有調用open方法）
　　1 (初始化) 對象已創建，還沒有調用send方法
　　2 (發送數據) send方法已調用，可是當前的狀態及http頭未知
　　3 (數據傳送中) 已接收部分數據，由於響應及http頭不全，這時經過responseBody和responseText獲取部分數據會出現錯誤
　　4 (完成) 數據接收完畢，此時能夠經過經過responseXml和responseText獲取完整的迴應數據

　　函數首先檢查XMLHttpRequest的總體狀態而且保證它已經完成（readyStatus=4），即數據已經發送完畢。而後根據服務器的設定詢問請求狀態，若是一切已經就緒（status=200），那麼就執行下面須要的操做。

對於XmlHttpRequest的兩個方法，open和send，其中open方法指定了：
　　a、向服務器提交數據的類型，即post仍是get。
　　b、請求的url地址和傳遞的參數。
　　c、傳輸方式，false爲同步，true爲異步。默認爲true。若是是異步通訊方式(true)，客戶機就不等待服務器的響應；若是是同步方式(false)，客戶機就要等到服務器返回消息後纔去執行其餘操做。咱們須要根據實際須要來指定同步方式，在某些頁面中，可能會發出多個請求，甚至是有組織有計劃有隊形大規模的高強度的request，然後一個是會覆蓋前一個的，這個時候固然要指定同步方式。
Send方法用來發送請求。

知道了XMLHttpRequest的工做流程，咱們能夠看出，XMLHttpRequest是徹底用來向服務器發出一個請求的，它的做用也侷限於此，但它的做用是整個AJAX實現的關鍵，由於AJAX無非是兩個過程，發出請求和響應請求。而且它徹底是一種客戶端的技術。而XMLHttpRequest正是處理了服務器端和客戶端通訊的問題因此纔會如此的重要。
　　如今，咱們對AJAX的原理大概能夠有一個瞭解了。咱們能夠把服務器端當作一個數據接口，它返回的是一個純文本流，固然，這個文本流能夠是XML格式，能夠是Html，能夠是JavaScript代碼，也能夠只是一個字符串。這時候，XMLHttpRequest向服務器端請求這個頁面，服務器端將文本的結果寫入頁面，這和普通的web開發流程是同樣的，不一樣的是，客戶端在異步獲取這個結果後，不是直接顯示在頁面，而是先由JavaScript來處理，而後再顯示在頁面。

問題四、字符串比較題？

　　String hello = "hello";
String hel = "hel";
String lo = "lo";
// 在"+"兩邊都是常量字符串，則將兩個字符串合併而且在String Pool中查找"hello"
// 並返回在String Pool中的內存地址正好也是hello變量的內存地址，因此第一句代碼會輸出true。
System.out.println(hello == "hel" + "lo");// true
System.out.println("hello" == "hel" + "lo");// true
// 若是在"+"兩邊有一邊是引用類型變量，Java會將合併成一個字符串而且在堆棧中建立一個
// 新的對象而且返回內存地址，因此這句代碼是輸出false。
System.out.println(hello == hel + "lo"); // false
System.out.println(hello == hel + lo); // false


問題五、說說什麼是分佈式和集羣？

　　 分佈式強調同一個業務被分拆成不一樣的子業務，被部署在不一樣的服務器上（多是性能的問題，也多是安全的問題，也多是模塊對服務器的需求不一樣的問題將業務進行分解）， 服務器能夠跨域也能夠同域。

　　 而集羣偏重平行處理，一臺服務器不能提供足夠的能力，而採用多臺服務器並行處理一個問題。

　　 集羣是指全部的設備共同完成相同的功能，每個設備的功能都是完整的，可是在外界看來是一個設備。
　　分佈式是全部的設備集結後，共同組成一個體系，相互之間協同工做，同時又各自完成本身的相應的工做，可是全部的功能不是在一個設備上，而是由不一樣的設備完成，可是由一個設備做爲統一的接入點和協調點。

問題六、說說你對HTTP協議的瞭解？

　　HTTP協議主要有用於作客戶端瀏覽器和Web服務器之間的一個通信規則(TCP/IP)。該協議主要規定的是傳輸HTML（超文本）的格式，其中包含了不少的消息頭信息，能夠幫助底層的Socket進行識別具體的信息，那麼對於開發者而言，若是掌握了HTTP協議的基本通訊規則有利於後期的JavaEE開發。
　　
　　默認的瀏覽器是沒法進行協議的通訊內容查看的，所以咱們瀏覽器上須要安裝一個額外的插件：HTTP Watch。
　　
　　
HTTP協議有1.0和1.1版本：
HTTP1.0的協議主要用於對每一次請求創建新的鏈接。這樣會致使鏈接的次數過於頻繁，致使速度下降。
HTTP1.1能夠使得客戶端創建必定時間範圍內的持續鏈接。

請求分析
瀏覽器在發送請求的時候，會默認給請求進行封裝，給一個請求上面添加HTTP協議相關的頭信息。常見的信息以下：
GET /books/java.html HTTP/1.1 請求行
Accept: */* 請求頭
Accept-Language: en-us
Connection: Keep-Alive
Host: localhost
Referer: http://localhost/links.asp
User-Agent: Mozilla/4.0
Accept-Encoding: gzip, deflate
空白行
請求行：
GET /books/java.html HTTP/1.1
請求方式請求的資源請求使用的協議和版本
請求方式：HTML表單、GET和POST
GET請求方式最大的特色是會將參數綁定在URL地址欄的後面進行傳遞，所以傳遞的數據是有限的且是明文的。
POST請求方式，該方式會將參數指定在請求體中進行傳遞。
常見的請求頭分析：瀏覽器生成出來的信息，該信息想要通知服務器一些信息。
Accept: */* 通知服務器瀏覽器能夠接受的數據類型
Accept-Language: en-us 通知服務器瀏覽器使用的語言
Connection: Keep-Alive 通知服務器在特定時間內保持鏈接
Host: localhost 通知服務器瀏覽器使用的主機
Referer: http://localhost/links.asp 通知服務器該請求來自於哪個頁面防盜鏈
User-Agent: Mozilla/4.0 通知服務器瀏覽器的版本
Accept-Encoding: gzip, deflate 通知服務器瀏覽器能夠接受的編碼格式

響應分析
瀏覽器給服務器發送了一個消息，那麼服務器必定會給瀏覽器返回一個響應消息。
HTTP/1.1 200 OK 響應行
Server: Apache-Coyote/1.1 響應頭
Accept-Ranges: bytes
ETag: W/"272-1351567272000"
Last-Modified: Tue, 30 Oct 2012 03:21:12 GMT
Content-Type: text/html
Content-Length: 272
Date: Tue, 30 Oct 2012 06:27:26 GMT
空白行
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>….</html> 響應體
HTTP/1.1 200 OK 響應行
響應的協議版本響應的狀態碼對響應碼的具體描述
常見的響應碼：
200 響應成功
302 繼續細化您的請求
404 請求資源沒法找到
500 服務器錯誤
Location: http://www.it315.org/index.jsp 通知瀏覽器須要細化的請求地址
Server:apache tomcat 通知瀏覽器服務器使用的服務器型號
Content-Encoding: gzip 通知瀏覽器服務器發送的數據類型
Content-Length: 80 通知瀏覽器壓縮數據的大小
Content-Language: zh-cn 通知瀏覽器服務器發送數據的語言
Content-Type: text/html; charset=GB2312 通知瀏覽器服務器發送數據的內容類型、編碼
Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT
通知瀏覽器請求的資源最後一個修改的時間
Refresh: 1;url=http://www.it315.org 通知瀏覽器定時刷新
Content-Disposition: attachment; filename=aaa.zip 通知瀏覽器內容的處理方式(下載)
Transfer-Encoding: chunked 通知瀏覽器數據以數據塊的方式逐一發送
Set-Cookie:SS=Q0=5Lb_nQ; path=/search 通知瀏覽器須要存儲Cookie數據
Expires: -1 通知瀏覽器不要緩存當前的頁面
Cache-Control: no-cache
Pragma: no-cache
Connection: close/Keep-Alive 通知瀏覽器保持或關閉鏈接
Date: Tue, 11 Jul 2000 18:23:51 GMT 通知瀏覽器服務器處理請求的時間

問題七、說說你對TCP和UDP協議的瞭解？

TCP
Transmission Control Protocol （傳輸控制協議）
特色：
　　面向鏈接、可靠、效率稍低
　　經過三次握手，創建鏈接，造成傳輸數據的通道。在鏈接中進行大數據量傳輸
例如：
由於TCP協議可以發現丟失的傳輸數據並從新發送，因此適合文件傳輸，接收郵件

一、第一次握手：客戶端發送SYN包（SYN=1，令ack=0，隨機產生一個值給seg，seg=X）給服務器端請求鏈接，客戶端進入SYN_SENT，等待服務器端確認。html

二、第二次握手：服務器端接收SYN包，由SYN=1知道客戶端請求鏈接，服務器端發送SYN+ACK包（SYN=ACK=1，ack=X+1，隨機產生一個值給seg，seg=Y）給客戶端確認鏈接請求，服務器端進入SYN_RCVD狀態。前端

三、第三次握手：客戶端收到服務器的SYN+ACK包後，檢查ack是否爲X+1，ACK標誌是否爲1，若是正確，發送ACK包（ACK標誌置爲1，令ack=Y+1），並將該數據包發送給服務器端；服務器端檢查ack是否爲Y+1，ACK標誌是否爲1，若是正確則創建鏈接，客戶端與服務器端進入ESTABLISHED狀態，完成三次握手，能夠開始傳輸數據了！java

UDP
User Datagram Protocol (用戶數據報協議)
特色：
　　無鏈接、不可靠、速度快
　　將數據及源和目的封裝成數據包中，不須要創建鏈接。每一個數據報的大小在限制在64k內
例如：
UDP協議不能保證傳輸沒有丟失
　　視頻通話，即時通訊，IP電話 (VoIP)電話


UDP須要學習使用的類:
DatagramSocket
DatagramPacket
須要創建發送端，接收端。
創建數據包。將數據存儲在數據包中.
調用Socket的發送接收方法。
關閉Socket。
發送端與接收端是兩個獨立的運行程序。

UDP發送：
第一步:建立Socket
須要建立Socket, 發送端不須要指定ip地址和端口, 使用本機地址發送, 會自動找到未使用的端口。
須要使用DatagramSocket此類表示用來發送和接收數據報包的套接字。
java.lang.Object
java.net.DatagramSocket
能夠經過構造函數建立該Socket對象
DatagramSocket socket = new DatagramSocket();
第二步:建立數據包
發送時須要建立數據包如何建立數據包？使用DatagramPacket
java.lang.Object
java.net.DatagramPacket 此類表示數據報包。
建立數據包時須要經過構造函數指定發送的數據（字節數組），數據長度（數組長度），接受方的IP地址（InteAddress類），接受方端口號(port)。
構造函數：
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
構造數據報包，用來將長度爲 length 的包發送到指定主機上的指定端口號。
第三步:發送數據
有了Socket 有了數據，如何發送數據包？使用Socket的send方法將數據包發送出去
void send(DatagramPacket p)
今後套接字發送數據報包。

第四步:關閉Socket
使用Socket的close方法關閉。
void close()
關閉此數據報套接字。
注意: 在發送端，要在數據包對象中明確目的地IP及端口。

UDP接收
第一步:須要建立Socket,
　　接收時必須指定端口號.
DatagramSocket socket = new DatagramSocket(8888);
第二步:建立數據包,
　　接收時也須要建立數據包, 用來存儲數據. 須要一個字節數組.
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
　　接收數據
第三步:接收數據
使用DatagramSocket 的receive方法接收數據.該方法須要指定數據包.
socket.receive(packet);
第四步: 從數據包中獲取數據
byte[] data = packet.getData();
第五步:獲取數據長度
int len = packet.getLength();
第六步:獲取發送端ip地址
packet.getInetAddress().getHostAddress();
第七步:獲取發送端端口號
packet.getPort();
第八步:關閉socket
socket.close();
注意: 在接收端，要指定監聽的端口。

TCP客戶端
第一步:建立客戶端Socket
　　須要指定鏈接到服務器的地址和端口號, 並嘗試鏈接
客戶端須要明確服務器的ip地址以及端口，這樣才能夠去試着創建鏈接，若是鏈接失敗，會出現異常。
Socket socket = new Socket("192.168.1.220", 8888);
第二步:鏈接成功獲取輸入輸出流
　　鏈接成功，說明客戶端與服務端創建了通道，那麼經過IO流就能夠進行數據的傳輸，而Socket對象已經提供了輸入流和輸出流對象，通getInputStream(),getOutputStream()獲取便可。
socket.getInputStream();
socket.getOuputStream();
第三步: 將數據寫出到服務端
使用字節輸出流的write() 方法
第四步:關閉socket
調用close方法
鏈接成功以後獲取輸入輸出流
socket.getInputStream();
socket.getOuputStream();
獲取流以後就能夠經過輸入輸出流發送和讀取數據了, 客戶端的輸入流鏈接服務端輸出流, 客戶端輸出流鏈接服務端輸入流
客戶端案例:
public class TcpClient {
public static void main(String[] args) throws IOException, IOException {
System.out.println("客戶端啓動...");
// 建立客戶端
Socket socket = new Socket("127.0.0.1", 50000);
// 與服務端創建鏈接,獲取輸入輸出流
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
// 將數據寫出到服務端
System.out.println("客戶端發送數據...");
out.write("Tcp,你好我是客戶端...".getBytes());
// 關閉socket
out.close();
}
}


TCP服務端
第一步: 建立服務端
ServerSocket, 須要指定端口號. 客戶端鏈接的就是這個端口.
java.lang.Object
java.net.ServerSocket
建立ServerSocket
ServerSocket serverSocket = new ServierSocket(8888);
第二步:和客戶端創建鏈接
經過accept方法
Socket accept()
偵聽並接受到此套接字的鏈接。
該方法會偵聽是否有客戶端鏈接,若是有創建鏈接,並獲取客戶端的Socket
也就是說服務端建立以後能夠獲取客戶端鏈接, 返回一個Socket對象, 這個Socket就是和客戶端鏈接的Socket
Socket socket = serverSocket.accept();
第三步: 接受客戶端的數據,獲取客戶端的數據
服務端獲取這個socket的輸入輸出流, 就能夠和客戶端發送接收數據了socket.getInputStream();
socket.getOutputStream();
第四步:獲取客戶端的ip地址和端口號
使用服務端獲取的Socket 獲取ip地址和端口.
InetAddress getInetAddress()
返回套接字鏈接的地址。

int getPort()
返回此套接字鏈接到的遠程端口。

第五步:關閉客戶端和服務端
在服務端中分別調用close方法.

2013年8月27日：

問題一、jQuery中AJAX發送請求的方法，get請求和post請求有什麼區別？

get是從服務器獲取數據，post是向服務器發送數據
get是小數據量傳輸，post是大數據量傳輸
get請求的參數隊列會在是經過url地址傳輸，在url地址上就能看到傳輸的參數，post看不到
get安全性低，post安全性高，但get的執行效率比post高
若是是傳輸機密信息建議用post
若是是數據查詢建議用get

問題二、Mysql和Oracle數據庫的區別？

Oracle是付費的，安全性能更高，通常銀行系統這種安全性要求很高的系統都是用Oracle
Oracle對權限的管理很是細緻，作的很是好，大概有159種權限，Mysql只有27種
主鍵，Oracle不能夠實現自增，Mysql能夠實現自增，Oracle須要新建序列實現，SEQ_USER_Id.nextval
Oracle的分頁方法和Mysql的分頁方法比起來很是麻煩，Oracle須要用到個子查詢，Mysql用一個limit方法搞定，並且分頁時，Mysql的遊標從0開始，Oracle從1開始
Mysql屬於中型數據庫，Oracle屬於大型數據庫，但並非說Mysql不能支撐大型應用，而是從功能上來看，Oracle擁有更豐富和完善的功能，不過通常咱們也是使用他的一部分經常使用功能，而這一部分功能Mysql也是具有的
在程序員的角度上來講，Mysql比Oracle更加簡單一些
在細節的使用上來講Mysql在字符串上能夠用單引號也能夠用雙引號，Oracle則必須使用單引號

問題三、簡述Struts2框架？

　　Struts2是基於JSP和Servlet的一個開源web應用框架，使用MVC設計模式，結構清晰，使程序員能夠只關注業務邏輯，還具備豐富的標籤庫能夠使用。
　　
Struts2工做流程:
客戶端發送請求
根據web.xml，請求被FileDispatcher接收
根據struts.xml的配置，找到須要調用的Action類，經過IOC方式將值注入給Action，Action調用業務邏輯組件處理業務邏輯。若是有配置攔截器，這一步還包含了攔截器
Action執行完畢，根據struts.xml中的配置找到對應的Result，並跳轉到相應頁面
響應到客戶端瀏覽器

問題四、簡述AOP用什麼技術實現的?

動態代理技術實現的，若是用JDK實現動態代理，須要利用Proxy類和InvocationHandler接口

問題五、IOC和new有什麼區別？

　　IOC便是控制反轉也叫依賴注入，他是經過IOC容器來生成對象，控制對象的生命週期，同時IOC把零散的部件組成了一個總體，從而達到疏散耦合的效果，咱們能夠利用Spring的配置，來讓IOC決定給咱們注入的是一個已有對象，仍是新建一個對象。
　　而new是每次拿到的都是一個新的對象，同時也不便於管理。

問題六、什麼是綁定變量？

　　變量綁定就是使用PreparedStatment對SQL語句進行一個預編譯，其中有一些咱們須要爲其指定的參數，咱們會在稍後爲數據庫指定這些參數的值，綁定變量的好處能夠防止SQL注入，避免sql語句的硬解析。
　　查詢一般只是由於改變WHERE子句中的內容而產生不一樣的結果。爲了在這種狀況下避免硬解析，須要使用綁定變量(bind variable)。它是用戶放入查詢中的佔位符，它會告訴Oracle"我會隨後爲這個變量提供一個值，如今須要生成一個方案，但我實際執行語句的時候，我會爲您提供應該使用的實際值"。
例如：
select * from emp where ename='KING'; //不使用綁定變量
select * from emp where ename=:bv; //使用綁定變量

問題七、delete、truncate、drop的異同？

相同點:
truncate和不帶where子句的delete, 以及drop都會刪除表內的數據
drop，truncate都是DDL(數據定義語言)語句，執行後會自動提交

不一樣點：
truncate和 delete只刪除數據不刪除表的結構(定義)
drop語句將刪除表的結構被依賴的約束(constrain),觸發器(trigger),索引(index)；
依賴於該表的存儲過程/函數將保留,可是變爲invalid無效狀態

delete語句是DML，這個操做會放到rollback segement回滾段中，事務提交以後才生效；若是有相應的trigger，執行的時候將被觸發
truncate,drop是DDL，操做當即生效，原數據不放到rollback segment中，不能回滾，操做不觸發trigger

速度，通常來講：drop > truncate > delete

delete是DML語句，不會自動提交
drop，truncate都是DDL(數據定義語言)語句，執行後會自動提交

問題八、IOC和工廠模式的區別？

使用Spring框架中IOC能獲得與工廠模式一樣的效果，並且編碼更加簡潔、靈活和方便。
除非從新編譯，不然沒法對「產品的實現類」進行替換，必須從新編譯工廠類來達到所要求的改變，但這樣將使得本來能夠取得的易用性將大大下降
沒法在單例和原型之間切換產品對象實例產生的模式
沒法透明地爲不一樣的產品組件類提供多種不一樣形式的實現。這是開發者在應用工廠模式時比較頭疼的一個問題，由於工廠模式中的工廠類要求每一個產品組件類都必須聽從在產品接口中定義的方法和結構特徵。一個接口經常意味着一個生成工廠，當接口爲多個時，將會出現許多不一樣的工廠類。

2013年8月28日：萬迅電腦軟件

問題一、JSP經Tomcat編譯後的.class文件位置？



　　Tomcat將JSP編譯成Servlet後的文件存放在\work\Catalina目錄下，例如jsp文件\webapps\hh\h.jsp，編譯後路徑爲：
　　\work\Catalina\localhost\hh\org\apache\jsp\h_jsp.java
　　
　　 Servlet文件和.class文件都在同一目錄下，文件名通常會被更改，更名規則爲: index.jsp會改爲index_jsp.class，以此類推。

問題二、Session默認過時時間如何修改？

　　程序中Session都有一個默認的過時時間，其中Tomcat中的默認時間爲30分鐘，根據須要咱們能夠去手動設置Session的過時時間，如下是設置Session的過時時間的三個方法：

一、在Tomcatconfconf/web.xm中的<session-config>中設置：
<session-config>
<session-timeout>30</session-timeout>
</session-config>
二、在項目的web.xml中定義：
<session-config>
<session-timeout>20</session-timeout>
</session-config>
　　注：20則設置過時時間爲20分鐘
3.在程序中定義：
　　session.setMaxInactiveInterval(30*60);

問題三、請講述有四種會話跟蹤技術？

隱藏表單域、URL重寫、Cookie、Session

隱藏表單域：
將會話ID添加到HTML表單元素中提交到服務器，此表單元素並不在客戶端顯示<input hidden>
URL 重寫：
URL(統一資源定位符)是Web上特定頁面的地址，URL重寫的技術就是在URL結尾添加一個附加數據以標識該會話，把會話ID經過URL的信息傳遞過去，以便在服務器端進行識別不一樣的用戶
Cookie：
Cookie是Web服務器發送給客戶端的一小段信息，客戶端請求時能夠讀取該信息發送到服務器端，進而進行用戶的識別。對於客戶端的每次請求，服務器都會將Cookie發送到客戶端,在客戶端能夠進行保存,以便下次使用
客戶端能夠採用兩種方式來保存這個Cookie對象，一種方式是保存在客戶端內存中，稱爲臨時Cookie，瀏覽器關閉後這個Cookie對象將消失。另一種方式是保存在客戶機的磁盤上，稱爲永久Cookie。之後客戶端只要訪問該網站，就會將這個Cookie再次發送到服務器上，前提是這個Cookie在有效期內。這樣就實現了對客戶的跟蹤
Cookie是能夠被禁止的
Session：
使用setAttribute(String str,Object obj)方法將對象捆綁到一個會話（在會話中能夠保存任意類型的對象，但由於會話可能被序列化，最好讓會話對象實現 java.io.Serializable接口
使用getArrtibute(String str)方法從一個會話中檢索對象
使用removeAttribute(String str)方法從一個會話中銷燬對象
使用setMaxInactiveInteral()方法設置會話的有效期，默認爲30分鐘（在web.xml中配置）
使用invalidate()方法將會話全部捆綁的對象解縛。

問題四、若是不用Spring如何實現AOP和IOC功能？

說到底，IOC就是反射，實例化指定類；AOP就是攔截，一系列的過濾器
IOC：工廠模式經過讀取配置文件建立實例結合反射使用，在配置文件裏面配置要實例化的對象的全路徑

AOP：意爲面向切面的編程，能夠爲某一類對象進行監督和控制，也就是調用你這個對象的方法前或者方法後，去調用你指定的模塊從而達到一個對模塊擴充的功能，通常用來作權限控制和日誌記錄等等，不用AOP的話，Struts2的攔截器也能夠實現，不用Struts2，也能夠直接用過濾器

補充：
　　AOP（Aspect-Oriented Programming，面向切面的編程），它是能夠經過預編譯方式和運行期動態代理實如今不修改源代碼的狀況下給程序動態統一添加功能的一種技術。它是一種新的方法論，它是對傳統OOP編程的一種補充。

　　IoC，（Inverse of Control）控制反轉，其包含兩個內容：其一是控制，其二是反轉。在程序中，被調用類的選擇控制權從調用它的類中移除，轉交給第三方裁決，它是一種設計模式，經過Java反射技術實現。


問題五、寫出你所知道JSP內置對象的方法？

Request對象：
　　客戶端的請求信息被封裝在Request對象中，經過它才能瞭解到客戶的需求，而後作出響應。它是HttpServletRequest類的實例

getSession 獲取當前的會話
setAttribute(String key,Object obj) 將一個對象綁定到request中指定的name屬性
getAttribute(String name) 該方法返回由name指定的屬性值，若是指定的屬性值不存在，則返回null
getParameter(String name)
　　該方法用於得到客戶端傳送給服務器端的參數，該參數有name指定，一般是表單中的參數
setCharacterEncoding(String type)重載正文中使用的字符編碼
　　注：在用request.getParameter()獲取中文數據前，要先用request.setCharacterEncoding("utf-8");設定字符編碼，若是不設定則有可能出現亂碼！

Response對象
　　Response對象包含了響應客戶請求的有關信息，但在JSP中不多直接用到它。它是HttpServletResponse類的實例

addCookie(Cookie cook) 添加一個Cookie對象，用來保存客戶端的用戶信息
sendRedirect(java.lang.String location) 從新定向客戶端的請求
addHeader(String name,String value) 添加Http響應頭信息
　　該Header信息將傳達到客戶端，若是已經存在同名的則會覆蓋
setHeader(String name,String value) 設置指定名字的Http響應頭的值，若存在則會覆蓋

Session對象
　　Session對象指的是客戶端與服務器的一次會話，從客戶連到服務器的一個WebApplication開始，直到客戶端與服務器斷開鏈接爲止。它是HttpSession類的實例

String getId() 返回Session建立時JSP引擎爲它設的惟一ID號
invalidate() 取消Session，使Session不可用，銷燬Session
setMaxInactiveInterval() 設置Session的失效時間，單位是ms毫秒，1秒=1000毫秒
getAttribute(String name) 返回與指定名稱相聯繫的屬性
setAttribute(String name, Object ob) 將一個對象綁定到會話中指定的name屬性
removeAttribute(String name) 刪除綁定到對話中指定名稱的對象

Out對象
　　Out對象是JspWriter類的實例,是向客戶端輸出內容經常使用的對象

這個對象最經常使用的方法只有兩個：out.print("...") out.println("...")
用途都是向客戶端發送信息，即，在瀏覽器中顯示信息。不少時候動態生成網頁都由該語句實現，如：
out.println("<table><tr><td>動態生成</td></tr></table>");

clear() 清除緩衝區裏的數據，但不會把數據輸出到客戶端
clearBuffer() 清除緩衝區裏的數據，並把數據輸出到客戶端
close() 關閉輸出流
flush() 輸出緩衝區裏的數據
newLine() 換行，至關於\n

Page對象
　　Page對象就是指向當前JSP頁面自己，有點象類中的this指針，它是java.lang.Object類的實例

getClass 返回此Object的類
hashCode() 返回此Object的hash碼
equals(Object obj) 判斷此Object是否與指定的Object對象相等
copy(Object obj) 把此Object拷貝到指定的Object對象中
clone() 克隆此Object對象
toString() 把此Object對象轉換成String類的對象
notify() 喚醒一個等待的線程
notifyAll() 喚醒全部等待的線程
wait(int timeout) 使一個線程處於等待直到timeout結束或被喚醒
wait() 使一個線程處於等待直到被喚醒
enterMonitor() 對Object加鎖
exitMonitor() 對Object開鎖

Application對象
　　Application對象實現了用戶間數據的共享，可存放全局變量。它開始於服務器的啓動，直到服務器的關閉，在此期間，此對象將一直存在；這樣在用戶的先後鏈接或不一樣用戶之間的鏈接中，能夠對此對象的同一屬性進行操做；在任何地方對此對象屬性的操做，都將影響到其餘用戶對此的訪問。服務器的啓動和關閉決定了Application對象的生命。它是ServletContext類的實例

getAttribute(String name) 返回給定名的屬性值
setAttribute(String name,Object obj) 設定屬性的屬性值
removeAttribute(String name) 刪除一屬性及其屬性值
getResource(String path) 返回指定資源(文件及目錄)的URL路徑
getResourceAsStream(String path) 返回指定資源的輸入流
getRequestDispatcher(String uripath) 返回指定資源的RequestDispatcher對象

Exception對象
　　Exception對象是一個例外對象，當一個頁面在運行過程當中發生了例外，就產生這個對象。若是一個JSP頁面要應用此對象，就必須把isErrorPage設爲true，不然沒法編譯。他其實是java.lang.Throwable的對象

getMessage() 返回描述異常的消息
toString() 返回關於異常的簡短描述消息
printStackTrace() 顯示異常及其棧軌跡

PageContext對象
　　PageContext對象提供了對JSP頁面內全部的對象及名字空間的訪問，也就是說他能夠訪問到本頁所在的SESSION，也能夠取本頁面所在的Application的某一屬性值，他至關於頁面中全部功能的集大成者，它的本類名也叫PageContext

getOut() 返回當前客戶端響應被使用的JspWriter流(out)
getSession() 返回當前頁中的HttpSession對象(session)
getPage() 返回當前頁的Object對象(page)
getRequest() 返回當前頁的ServletRequest對象(request)
getResponse() 返回當前頁的ServletResponse對象(response)
getException() 返回當前頁的Exception對象(exception)
getServletConfig() 返回當前頁的ServletConfig對象(config)
getServletContext() 返回當前頁的ServletContext對象(application)

setAttribute(String name,Object attribute) 設置屬性及屬性值
setAttribute(String name,Object obj,int scope) 在指定範圍內設置屬性及屬性值
Object getAttribute(String name) 取屬性的值
getAttribute(String name,int scope) 在指定範圍內取屬性的值
Object findAttribute(String name) 尋找一屬性,返回起屬性值或NULL
removeAttribute(String name) 刪除某屬性
removeAttribute(String name,int scope) 在指定範圍刪除某屬性

forward(String relativeUrlPath) 轉發
include(String relativeUrlPath) 在當前位置包含另外一文件

Config對象
　　Config對象是在一個Servlet初始化時，JSP引擎向它傳遞信息用的，此信息包括Servlet初始化時所要用到的參數（經過屬性名和屬性值構成）以及服務器的有關信息（經過傳遞一個ServletContext對象）

getServletContext() 返回含有服務器相關信息的ServletContext對象
getInitParameter(String name) 返回初始化參數的值
getInitParameterNames() 返回Servlet初始化所需全部參數的枚舉

問題六、Java啓動參數Xms和Xmx的含義？

參數名含義默認值
Xms 初始堆大小物理內存的1/64(<1GB)
Xmx 最大堆大小物理內存的1/4(<1GB)
Xmn 年輕代大小
Xss 每一個線程的堆棧大小



問題7-二、SQL注入攻擊(SQL injection)——注入

　　早在十幾年前，基於數據庫的Web應用剛剛盛行的時候，幾乎全部的開發商都忽略了SQL注入弱點，致使當時絕大多數的網站的登陸入口形同虛設！爲何呢？先給一個小小的例子，假如如下SQL代碼是用來在網站登陸入口入執行用戶驗證時的查詢代碼：
　　
SELECT count(*)
FROM users_list_table
WHERE username='USERNAME'
AND password='PASSWORD'

　　以上的USERNAME就是咱們登陸時提供的用戶名，PASSWORD就是咱們登陸時提供的密碼。當用戶輸入正確的用戶名和密碼時，這條語句的執行結果將爲真（True），不然爲假（False），固然爲真時咱們就認爲認證經過，爲假時就認爲認證失敗，即非法登陸。試想一下，若是我在輸入用戶名和密碼的時候輸入以下的內容：
　　
用戶名：a' or 'a'='a
密碼：a' or 'a'='a

用代入法把用戶名和密碼輸入值代入到上述的SQL腳本里結果以下：

SELECT count(*)
FROM users
WHERE username='a' or 'a'='a'
AND password='a' or 'a'='a'

　　相信稍懂一點兒SQL語句的人都知道，這條語句的執行結果就永遠是真了！此時你不須要有賬號，就直接登陸成功了！你對此漏洞理解的深度一樣取決於你的對SQL語句的技能和Web安全知識能力。一個具備良好技能的攻擊者可能利用此漏洞獲取後臺DB的結構並逐步獲取DB的信息。

總結一下：SQL注入弱點是存在基於數據庫的Web應用中，黑客利用精心組織的SQL語句，經過Web接口（一般指咱們的Web頁面的表單）注入的Web應用中，從而獲取後臺DB的訪問與存取權的一種安全弱點。

簡要的解決方案：
　　剛剛介紹了XSS，在這裏關於SQLInjection我想就無需多說了，都是過濾、合法性檢查和長度限制等通用方法。
　　有沒有注意到，XSS和SQL Injection，雖然名字不同，但它們彷佛都屬於我前一篇文章《解讀Web安全性問題的本質》中的第一部分，即輸入／輸出驗證。下面將要介紹的遠程命令執行、目錄遍歷和文件包含一樣也是輸入/輸出驗證問題。



問題九、Filter過濾器功能和用法有哪些，是什麼？

Filter過濾器：
　　Filter與Servlet類似，過濾器是一些Web應用程序組件，能夠綁定到一個Web應用程序中。可是與其餘Web應用程序組件不一樣的是，過濾器是"鏈"在容器的處理過程當中的。這就意味着它們會在Servlet處理器以前訪問一個進入的請求，而且在外發響應信息返回到客戶前訪問這些響應信息。這種訪問使得過濾器能夠檢查並修改請求和響應的內容。
　　它與Servlet的區別在於：它不能直接向用戶生成響應。
　　完整的Filter流程是：
　　Filter對用戶請求進行預處理，接着將請求交給Servlet進行處理並生成響應，最後Filter再對服務器響應進行後處理。

Filter做用：
在HttpServletRequest到達Servlet以前，攔截客戶的HttpServletRequest請求
根據須要檢查HttpServletRequest，也能夠對HttpServletRequest頭和數據進行修改
在HttpServletResponse到達客戶端以前，攔截HttpServletResponse
根據須要檢查HttpServletResponse，也能夠對HttpServletResponse頭和數據進行修改
Filter能夠攔截多個請求和響應，一個請求和響應能夠被多個Filter攔截

Filter種類：
用戶受權的Filter：Filter負責檢查用戶的請求，根據請求過濾用戶的非法請求
日誌Filter：詳細記錄用戶的請求信息
負責解碼的Filter：對非標準編碼的解碼
能改變XML內容的XSLT Filter等

Filter的實現：
建立Filter處理類：Filter處理類必須實現javax.servlet.Filter接口。該接口有3個方法：
public void init(FilterConfig arg0) throws ServletException
用於初始化Filter，只會在Web容器啓動的時候自動調用並且只調用一次，FilterConfig 封裝了Filter配置參數(init-param)內容信息，初始化的時候能夠直接拿出來
在acegi安全認證中FilterConfig封裝的是被代理對象
public void doFilter(ServletRequest req, ServletResponse res,FilterChain chain) throws IOException,ServletException
用於實現過濾的方法，該方法會在每次請求中調用，或每次響應中調用
ServletRequest 封裝了請求信息，ServletResponse 封裝了響應信息
在chain.doFilter(req, res);代碼執行以前進行的處理是對請求的預處理，在chain.doFilter(req, res);代碼執行以後執行的處理是對響應進行的後處理，通常擁有權限的才調用chain.doFilter(req, res);方法或者跳轉到錯誤頁面
public void destroy()
用於進行資源釋放，當過濾處理完畢後會調用該方法。
Web.xml中配置Filter：
配置Filter名，以下：
　　<filter>
　　<filter-name>myFilter</filter-name>
　　<filter-class>com.lanp.MyFilter</filter-class>
　　<init-param>
　　<param-name>super_role</param-name>
　　<param-value>lanp</param-value>
　　</init-param>
　　</filter>
配置Filter名，以下：
　　<filter-mapping>
　　<filter-name>myFilter</filter-name>
　　<url-pattern>/*</url-pattern>
　　</filter-mapping>

2013年9月1日：易度軟件開發

問題一、如何格式化double數據，保留小數點後x位，有多少種方式？

這裏咱們拿 Math.PI 來討論，保留兩位小數點。(PI = 3.141592653589793)圓周率π

===================================================
【方案1】
Math.round( Math.PI * 100 ) /100.0

Math.PI * 100 = 314.1592653589793
Math.round(314.1592653589793) = 314
314 / 100.0 = 3.14 (注意這裏要除以 100.0 ,若是除以100的話，會是整除)
===================================================
【方案2】
String.format( "%.2f", Math.PI )

String類的靜態方法
===================================================
【方案3】
new DecimalFormat("#.00").format(Math.PI)

java.text.DecimalFormat
===================================================
【方案4】
new BigDecimal(Math.PI).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue()

特殊說明下，要用BigDecimal（String s）這個構造方法，不能直接傳double的參數，否則四捨五入有問題的
java.math.BigDecimal
===================================================
【方案5】
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
nf.format(Math.PI);

java.text.NumberFormat
===================================================
【方案6】
先轉字符串，而後 substring截取

截取小數點後N位(先定位小數點位置):獲得i //i表示小數點位置+N
定位小數點截取subString(0,i+1); //差很少這個意思...
===================================================


問題二、JAVA實現從10~50中隨機生成50個數，統計出現的數字及次數，輸出出現最多的次數及對應的數字，按數字升序排列？

public static void main(String[] args) {
TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
for (int i = 0; i < 50; i++) {
// random*41就是範圍從0-40內，+10爲10到50
int number = (int) (Math.random() * 41) + 10;
System.out.print(number + " ");

//統計次數，若是map裏存在了+1，不存在則存入
if (map.containsKey(number)) {
map.put(number, map.get(number) + 1);
} else {
map.put(number, 1);
}
}

System.out.println();
Collection cols = map.values();//獲取map的鍵值對裏值的集合
int max = Collections.max(cols);//獲取最大次數

List list = new ArrayList();

Iterator it = map.entrySet().iterator();//獲取迭代器

while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Integer key = (Integer) entry.getKey();
Integer val = (Integer) entry.getValue();

//若是與最大次數相同則增長到集合中
if (val == max) {
list.add(key);
}
System.out.println(key + "出現的次數爲：" + val);
}

System.out.println("出現的最大次數爲：" + max);

Iterator maxNum = list.iterator();
while (maxNum.hasNext()) {
System.out.println("這些數字是：" + maxNum.next());
}
}

問題三、Final、finally、finalize的區別？

Final用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
　　所以一個類不能既被聲明爲 abstract的，又被聲明爲final的。
　　將變量或方法聲明爲final，能夠保證它們在使用中不被改變。
　　被聲明爲final的變量必須在new一個對象時初始化（即只能在聲明變量或構造器或代碼塊內初始化），而在之後的引用中只能讀取，不可修改。
　　被聲明爲final的方法也一樣只能使用，不能覆蓋(重寫)。
　　
finally是異常處理語句結構的一部分，表示老是執行。

finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，能夠覆蓋此方法提供垃圾收集時的其餘資源回收，例如關閉文件等。JVM不保證此方法總被調用。
　　方法名，Java 技術容許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去以前作必要的清理工做。這個方法是由垃圾收集器在肯定這個對象沒有被引用時對這個對象調用的。
　　它是在 Object 類中定義的，所以全部的類都繼承了它。
　　子類覆蓋 finalize() 方法以整理系統資源或者執行其餘清理工做。finalize() 方法是在垃圾收集器刪除對象以前對這個對象調用的。
　　注意：finalize不必定被JVM調用，只有當垃圾回收器要清除垃圾時才被調用。
　　
問題四、如何將int、char、boolean類型的數據轉換爲字符串類型？

　　 String.valueOf(i);
　　 Integer.toString(i); Character.toString(i);Boolean.toString(i);
　　 String s = "" + i;
　　
問題五、如何將字符串類型轉換爲int、boolean類型？
　　
　　Integer.parseInt(String);
　　Integer.valueOf(String).intValue();
　　
　　Boolean.parseBoolean("true");
　　Boolean.valueOf("true").booleanValue();
　　
　　
問題六、如下代碼的運行結果？
　　
　　String a = "xyz";
String b = "xyz";
String c = new String("xyz");
String k = "xy" + "z";

System.out.println(a == b); //true
System.out.println(b == c); //false
System.out.println(b.equals(c));//true
System.out.println(a == k); //true
　　 System.out.println(a.equals(k));//true
　　
問題七、如下代碼會發生什麼問題？
　　
　　for (double k = 0.5;; k = k + 0.1) {
if (k == 1) {
break;
}
}
　　
　　Double會發生精度丟失問題，形成死循環
　　
問題八、概述MVC體系結構？
　　
MVC是Model－View－Controller的簡寫。
　　M表明業務邏輯層（經過JavaBean，EJB組件實現）。
　　V是視圖層（由JSP頁面產生）。
　　C屬於控制層（通常能夠用基礎的Servlet實現，也可用Struts等開源框架實現）
經過這種設計模型把應用邏輯，處理過程和顯示邏輯分紅不一樣的組件實現。這些組件能夠進行交互和重用。

問題九、現有一個頁面，如何記錄該頁面的訪問次數，有哪些實現方式？監聽器的應用場景

使用監聽器當Session創建時sessionCreated()，存放在Application裏的訪問次數+1

使用JavaScript在頁面打開時，日後臺發送一個請求，瀏覽次數+1
window.onload=function(){
// 此處發送異步請求，瀏覽次數+1
}

問題十、JSP標準標籤庫中經常使用的標籤有哪些？

<c:out>、<c:if>、<c:choose>、<c:forEach>、<c:url>、<c:redirect>、<c:param>

問題十一、頁面中html代碼片斷以下，請問 infoArea 的背景顏色是什麼，並請解析緣由？

　　<style type="text/css">
.green {
　　</style>
　　
　　<div id="infoArea" class="green"
　　style=" width:100px; height:50px"></div>

infoArea的背景色是紅色，由於style的權重是1000，而類選擇器的權重僅爲10，優先級判斷爲style

CSS規範爲不一樣類型的選擇器定義了特殊性權重，特殊性權重越高，樣式會被優先應用。
權重設定以下：
html選擇器，權重爲1
類選擇器，權重爲10
id選擇器，權重爲100
內聯樣式style，權重爲1000
這裏還有一種狀況：在html標籤中直接使用style屬性，這裏的style屬性的權重爲1000；

問題十二、寫一段js腳本將 infoArea的高度改成200px。最好能使用jquery語法？

$(function(){
$("#infoArea").css({"height":"200px"});
});

問題1三、頁面上有2個按鈕Button1和Button2；當點擊Button1時，顯示div1，隱藏div2；當點擊Button2時，顯示div2，隱藏div1，如何實現？

　　<input type="button" id="Button1" value="Button1">
　　<input type="button" id="Button2" value="Button2">
　　<div id="div1">div1</div>
　　<div id="div2">div2</div>


　　$(function(){
$("#Button1").click(function(){
$("#div2").hide();
$("#div1").show();
});
$("#Button2").click(function(){
$("#div1").hide();
$("#div2").show();
});
});

問題1四、使用JSTL標籤，將dataList數據以表格方式展示。（假設標籤庫已引入，<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>）

　　<%
List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();

Map<String, Object> dataMap = new HashMap<String, Object>();
dataList.add(dataMap);
dataMap.put("ID", "1001");
dataMap.put("NAME", "張三");
dataMap.put("SCORES", 90);

dataMap = new HashMap<String, Object>();
dataList.add(dataMap);
dataMap.put("ID", "1002");
dataMap.put("NAME", "李四");
dataMap.put("SCORES", 95);

pageContext.setAttribute("dataList",dataList);
%>

......

工號名稱分數
1001 張三 90
...... ...... ......

代碼以下：

　　<table border="1" width="50%">
<tr>
<td>工號</td><td>姓名</td><td>分數</td>
</tr>
<c:forEach var="dataMap" items="${dataList}">
<c:forEach var="data" items="${dataMap}">
<c:if test="${data.key=='ID'}">
<c:set var="id" value="${data.value}"></c:set>
</c:if>
<c:if test="${data.key=='NAME'}">
<c:set var="name" value="${data.value}"></c:set>
</c:if>
<c:if test="${data.key=='SCORES'}">
<c:set var="scores" value="${data.value}"></c:set>
</c:if>
</c:forEach>
<tr>
<td>${id}</td><td>${name}</td><td>${scores}</td>
</tr>
</c:forEach>
</table>

問題1五、數據庫編程題？ sql語句練習

表名：g_cardapply
字段(字段名/類型/長度)：
g_applyno varchar 8；//申請單號（關鍵字）
g_applydate bigint 8；//申請日期
g_state varchar 2；//申請狀態

表名：g_cardapplydetail
字段(字段名/類型/長度)：
g_applyno varchar 8；//申請單號（關鍵字）
g_name varchar 30；//申請人姓名
g_idcard varchar 18；//申請人身份證號
g_state varchar 2；//申請狀態

其中，兩個表的關聯字段爲申請單號。

建表語句：

DROP DATABASE IF EXISTS yidu;
CREATE DATABASE yidu;

USE yidu;

DROP TABLE IF EXISTS g_cardapply;
CREATE TABLE g_cardapply(
g_applyno VARCHAR(8),
g_applydate BIGINT(8),
g_state VARCHAR(2),
PRIMARY KEY (g_applyno)
);

DROP TABLE IF EXISTS g_cardapplydetail;
CREATE TABLE g_cardapplydetail(
g_applyno VARCHAR(8),
g_name VARCHAR(30),
g_idcard VARCHAR(18),
g_state VARCHAR(2),
PRIMARY KEY (g_applyno)
);

INSERT INTO g_cardapply values("12345677",13780512,"01");
INSERT INTO g_cardapply values("12345678",13780512,"02");
INSERT INTO g_cardapply values("12345679",13780512,"01");
INSERT INTO g_cardapply values("12345680",13780512,"02");

INSERT INTO g_cardapplydetail values("12345677","陳太上","12345678910","01");
INSERT INTO g_cardapplydetail values("12345678","陳太上","12345678910","02");
INSERT INTO g_cardapplydetail values("12345679","李小龍","12345678911","01");
INSERT INTO g_cardapplydetail values("12345680","李小龍","12345678911","02");

SELECT * FROM g_cardapply;
SELECT * FROM g_cardapplydetail;

select from_unixtime(1378051200000/1000);#BIGINT轉datetime
select UNIX_TIMESTAMP('2013-09-02')/100;#time轉BIGINT

查詢身份證號碼爲440401430103082的申請日期

SELECT gc.g_applydate
FROM g_cardapply gc,g_cardapplydetail gcd
WHERE gc.g_applyno = gcd.g_applyno AND
gcd.g_idcard = '440401430103082';

查詢同一個身份證號碼有兩條以上記錄的身份證號碼及記錄個數

SELECT g_idcard,count(g_idcard)
FROM g_cardapplydetail
group by g_idcard
having count(g_idcard)>=2;

將身份證號碼爲440401430103082的記錄在兩個表中的申請狀態均改成07；

UPDATE g_cardapply SET g_state='07'
WHERE g_applyno in
(SELECT g_applyno FROM g_cardapplydetail
WHERE g_idcard='440401430103082');

刪除g_cardapplydetail表中全部姓李的記錄

DELETE FROM g_cardapplydetail
WHERE g_name like '李%';

問題1六、數據庫編程題，學生表(student{studentId, groupId, studentName, score})和興趣小組表(study_group{groupId,groupName})關聯以下圖。 sql語句練習

學校每一個學生均可以選擇參加一個興趣小組（也能夠不參加）。問：
建表語句：
DROP DATABASE IF EXISTS yidu;
CREATE DATABASE yidu;

USE yidu;

DROP TABLE IF EXISTS study_group;
CREATE TABLE study_group(
groupId VARCHAR(38),
groupName VARCHAR(30),
PRIMARY KEY (groupId)
);

DROP TABLE IF EXISTS student;
CREATE TABLE student(
studentId VARCHAR(38),
groupId VARCHAR(38),
studentName VARCHAR(10),
score NUMERIC(4,1),
PRIMARY KEY (studentId),
CONSTRAINT fk_gid FOREIGN KEY(groupId) REFERENCES study_group(groupId)
);


INSERT INTO study_group values("123","一組");
INSERT INTO study_group values("124","二祖");

INSERT INTO student values("1","123","陳一",90.9);
INSERT INTO student values("2","123","陳二",81.9);
INSERT INTO student values("3","124","陳三",93.9);
INSERT INTO student values("4","124","陳四",70.9);
INSERT INTO student values("5",null,"陳五",60.9);
INSERT INTO student values("6",null,"陳六",80.9);

SELECT * FROM study_group;
SELECT * FROM student;

用一條SQL查出各小組成績最優秀的學生，須要查出<小組名稱、學生名稱、成績>

SELECT sgp.groupName,stu.studentName,max(stu.score)
FROM student stu,study_group sgp
WHERE stu.groupId = sgp.groupId
GROUP BY sgp.groupName;



將全部沒有參加小組的學生的活動成績更新爲0

UPDATE student set score = 0
WHERE groupId IS NULL;

用一條sql查出全部學生參加興趣小組的狀況，須要查出<學生名稱、小組名稱>若是學生沒有參加小組，則小組名稱返回「沒有參加小組」

SELECT stu.studentName ,IFNULL(sgp.groupName ,'沒有參加小組')
FROM student stu LEFT JOIN study_group sgp
on stu.groupId = sgp.groupId;

問題1七、用程序在控制檯打印出全部由一、二、三、4組合出來的4位數，不可重複出現同一個數字

　　/**
* 本法是輸入1，2,3,4不重複的4位數
*一個循環是表明一個位數，在最後一層中作個判斷並輸出，就能夠顯示了。
*/
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 5; j++) {
for (int m = 1; m < 5; m++) {
for (int n = 1; n < 5; n++) {
if (i != j && i != m && i != n && j != m && j != n
&& m != n) {
System.out.println(i + "" + j + "" + m + "" + n);
}
}
}
}
}

問題1八、請用jQuery或任一AJAX框架寫一個異步提交請求，要求有成功處理回調函數、失敗回調函數，使用json格式傳遞數據。（具體業務參數、業務邏輯可留空）

回調函數：
　　表明請求返回內容的 data; 表明請求狀態的 textStatus 對象和 XMLHttpRequest 對象
　　
　　$.post(url,{"username":"java"},function(backData,status,xhr){
if(status=="success"){

}else{

}
});


問題1九、將頁面全部table邊框顏色設置爲#66FFCC，table裏面的th元素裏的文字大小設爲13px，td裏的文字大小設爲12px？

　　<style type="text/css">
table{border-color: #66FFCC}
table th{font-size: 13px}
table td{font-size: 12px}
</style>

問題20、將頁面id爲form1的Form表單背景顏色設爲#66FFCC？



　　<style type="text/css">
#form1{background: #66FFCC}
</style>

問題2一、要求用js將下列html中class=」a」的<li/>標籤的innerText填充爲」hello world」。



　　function add(){
var lis = document.getElementsByTagName("li");

for(var i=0; i <lis.length; i++){
if(lis[i].className=="a"){
lis[i].innerText="hello world";
}
}
}

add();

問題2二、請用流複製的方式，完成如下文件複製方法，不準使用第三方類庫？

public void copyFile(String sourceFilePath, String targetFilePath) throws Exception {

FileInputStream fis=new FileInputStream(sourceFilePath);
FileOutputStream fos=new FileOutputStream(targetFilePath);

byte[] byt=new byte[1024];//緩衝區
int len=0;

while((len=fis.read(byt))>0){
fos.write(byt,0,len);
}

fis.close();
fos.close();
}

問題2三、用程序在控制檯輸出101-199之間全部質數（大於1且不能被1或本身之外的天然數？

　　for (int i = 101; i < 200; i++) {
int a = 0;
for (int j = 1; j <= i; j++) {
if (i % j == 0) {
//第一次是被1整除，第二次是被本身整除
a++;
}
if (i == j && a == 2) {
System.out.println(i);
}
}
}

問題2四、數據庫編程題 sql語句練習
有一張部門表sec_dept
dept_id varchar2(38) dept_name varchar2（100） parent_id varchar（38）
部門id 部門名稱上級部門id

建表語句：
DROP TABLE sec_dept;
CREATE TABLE sec_dept(
dept_id VARCHAR2(38),
dept_name VARCHAR2(100),
parent_id VARCHAR(38),
PRIMARY KEY (dept_id)
);

INSERT INTO sec_dept values('1','部門A',null);
INSERT INTO sec_dept values('2','部門B',null);
INSERT INTO sec_dept values('3','部門C','1');
INSERT INTO sec_dept values('4','部門D','2');
INSERT INTO sec_dept values('5','部門E','3');
INSERT INTO sec_dept values('6','部門F','4');

SELECT * FROM sec_dept;


若是該部門爲頂級部門則parent_id爲null。現要求：
用一條sql從頂級部門開始遞歸查出全部部門，並展現各個部門的級別。Sql能夠寫plsql或tsql。
結果格式如：
部門名稱級別
部門A 1
部門B 2
部門C 2
部門D 3
部門E 3
部門F 3


select dept_name,parent_id from sec_dept
start with dept_id in (select dept_id from sec_dept where parent_id is null)
connect by prior dept_id=parent_id;

假設目前須要對全部部門表進行分頁查詢（不用考慮問題1的部門級別），每頁數據顯示10條記錄，目前要查第3頁的部門數據，請寫出查詢sql（假設部門不止30個）

SELECT * FROM
(
SELECT A.*, ROWNUM RN
FROM (SELECT * FROM sec_dept) A
WHERE ROWNUM <= 30
)
WHERE RN >= 21;

問題2五、數據庫編程題？
現有工資表income字段以下：
Income_time Date person Dept_id Dept_name income
收入日期人員部門id 部門名稱收入

建表語句：
DROP TABLE income;
CREATE TABLE income(
income_time Date,
person VARCHAR2(50),
Dept_id VARCHAR(20),
Dept_name VARCHAR(20),
income number
);

INSERT INTO income values(sysdate,'A號','1','A部門',1000);
INSERT INTO income values(add_months(sysdate,-1),'A號','1','A部門',2000);
INSERT INTO income values(add_months(sysdate,1),'A號','1','A部門',3000);
INSERT INTO income values(sysdate,'B號','2','B部門',700);
INSERT INTO income values(add_months(sysdate,-1),'B號','2','B部門',500);
INSERT INTO income values(add_months(sysdate,1),'B號','2','B部門',600);
INSERT INTO income values(sysdate,'C號','3','C部門',4000);
INSERT INTO income values(add_months(sysdate,-1),'C號','3','C部門',3500);
INSERT INTO income values(add_months(sysdate,1),'C號','3','C部門',4500);


要求用一個SQL語句（注意是一個）的處全部人（不區分人員）每月及上月和下月的總收入
要求列表輸出爲：
年份月份當月收入上月收入下月收入
　　

select
(SELECT to_char(sysdate,'yyyy') from dual) as "年份",
(SELECT to_char(sysdate,'mm') from dual) as "月份",
(SELECT sum(income) from income where to_char(income_time,'mm')=to_char(sysdate,'mm')) as "當月收入",
(SELECT sum(income) from income where to_char(income_time,'mm')=to_char(sysdate,'mm')-1) as "上月收入",
(SELECT sum(income) from income where to_char(income_time,'mm')=to_char(sysdate,'mm')+1) as "下月收入"
from dual;

查出各個月份的各部門全部人總收入，要求生成合計行
生成結果如：
2013年 6月開發1部 A君 3000
2013年 6月開發1部 B君 3000
2013年 6月開發1部 C君 3000
2013年 6月開發1部合計 9000
2013年 6月開發2部 D君 3000
2013年 6月開發2部 E君 3000
2013年 6月開發2部合計6000

注意：統計了各月份各部門全部人的總收入，但未實現生成合並行
SELECT to_char(income_time,'yyyy-mm'),dept_name,person,sum(income)
FROM income
GROUP BY to_char(income_time,'yyyy-mm'),dept_name,person
ORDER BY to_char(income_time,'yyyy-mm');

問題2六、數據庫編程題

當前有兩個數據量很大的寬表A和B
A結構：
Pk_id varchar2（38） Filed1 varchar2（200） Filed2 varchar2（200） ….
主鍵字段1 字段2 其他字段
B結構：
Pk_id varchar2（38） Fk_id varchar2（38） Filed1 varchar2（200） Filed2. varchar2（200） …. Create_time
主鍵關聯A的外鍵字段1 字段2 其他字段生成時間

　　其中表B的數據每日生成一次，且新增數量級達到百萬級。
　　表A爲維表數據基本不變。表A和B除主、外鍵沒有任何鍵或其它優化措施。
　　目前需每個月經過如下sql統計出符合條件的B表的Feild1和Field2明細信息
Select * from B
where Months_between(create_time, sysdate) = 0
and fk_id in (select pk_id from A where A.field1 = ‘condition’)
若只考慮對上述sql查詢性能的優化，能夠採起哪些優化措施？（優化措施可有多種，請儘可能列舉）

一、通配符*號修改成Field1和Field2
二、爲A表的Field1創建索引
三、in修改成exists

2013年9月5日：

問題一、說說ArrayList,Vector, LinkedList的存儲性能和特性？

　　ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增長和插入元素，它們都容許直接按序號索引元素，可是插入元素要涉及數組元素移動等內存操做，因此索引數據快而插入數據慢，Vector因爲使用了synchronized方法（線程安全），一般性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據須要進行前向或後向遍歷，可是插入數據時只須要記錄本項的先後項便可，因此插入速度較快。
　　LinkedList也是線程不安全的，LinkedList提供了一些方法，使得LinkedList能夠被看成堆棧和隊列來使用。

問題二、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?

short s1 = 1; s1 = s1 + 1; （s1+1運算結果是int型，須要強制轉換類型）
short s1 = 1; s1 += 1;（能夠正確編譯）

當使用+=、-=、*=、/=、%=、運算符對基本類型進行運算時，遵循以下規則：
　　運算符右邊的數值將首先被強制轉換成與運算符左邊數值相同的類型，而後再執行運算，且運算結果與運算符左邊數值類型相同。

在s1=s1+1;中，s1+1運算的結果是int型，把它賦值給一個short型變量s1，因此會報錯

而在s1+=1;中，因爲s1是short類型的，因此1首先被強制轉換爲short型，而後再參與運算，而且結果也是short類型的，所以不會報錯

那麼，s1=1+1;爲何不報錯呢？
這是由於1+1是個編譯時能夠肯定的常量，「+」運算在編譯時就被執行了，而不是在程序執行的時候，這個語句的效果等同於s1=2，因此不會報錯。

前面講過了，對基本類型執行強制類型轉換可能得出錯誤的
結果，所以在使用+=、-=、*=、/=、%=、等運算符時，要多加註意。

問題三、說說你對數據庫設計裏的三範式的理解?

第一範式（1NF）無重複的列

　　所謂第一範式（1NF）是指數據庫表的每一列都是不可分割的基本數據項，同一列中不能同時有多個值，即實體中的某個屬性不能有多個值或者不能有重複的屬性。
　　若是出現重複的屬性，就可能須要定義一個新的實體，新的實體由重複的屬性構成，新實體與原實體之間爲一對多關係。在第一範式（1NF）中表的每一行只包含一個實例的信息。簡而言之，第一範式就是無重複的列。
　　
　　在任何一個關係數據庫中，第一範式（1NF）是對關係模式的基本要求，不知足第一範式（1NF）的數據庫就不是關係數據庫。
　　在當前的任何關係數據庫管理系統（DBMS）中，不可能作出不符合第一範式的數據庫，由於這些DBMS不容許你把數據庫表的一列再分紅二列或多列。所以，你想在現有的DBMS中設計出不符合第一範式的數據庫都是不可能的。
舉例：
　　一張學生表Student(stuNo,stuName,age,age,sex)是不符合第一範式的，由於有重複列age屬性。
　　去除重複列age之後的Student(stuNo,stuName,age,sex)是符合第一範式的。

第二範式（2NF）屬性徹底依賴於主鍵 [ 消除部分子函數依賴 ]

　　第二範式（2NF）是在第一範式（1NF）的基礎上創建起來的，即知足第二範式（2NF）必須先知足第一範式（1NF）。
　　第二範式（2NF）要求數據庫表中的每一個實例或行必須能夠被惟一地區分。爲實現區分一般須要爲表加上一個列，以存儲各個實例的惟一標識。
　　例如員工信息表中加上了員工編號（emp_id）列，由於每一個員工的員工編號是惟一的，所以每一個員工能夠被惟一區分。這個惟一屬性列被稱爲主關鍵字或主鍵、主碼。

　　第二範式（2NF）要求實體的屬性徹底依賴於主關鍵字。
　　所謂徹底依賴是指不能存在僅依賴主關鍵字一部分的屬性，若是存在，那麼這個屬性和主關鍵字的這一部分應該分離出來造成一個新的實體，新實體與原實體之間是一對多的關係。
　　爲實現區分一般須要爲表加上一個列，以存儲各個實例的惟一標識。簡而言之，第二範式就是屬性徹底依賴於主鍵。
　　這裏說的主關鍵字可能不僅有一個，有些狀況下是存在聯合主鍵的，就是主鍵有多個屬性。

舉例：
　　以學生選課爲例，每一個學生均可以選課，而且有這一門課程的成績，那麼若是將這些信息都放在一張表StuGrade(stuNo,stuName,age,sex,courseNo,courseName,credit,score)。
　　
　　若是不仔細看，咱們會覺得這張表的主鍵是stuNo，可是當咱們看到最後一個score屬性之後，在想一想若是沒有課程信息，那麼哪裏有學生成績信息呢。因此這張表的主鍵是一個聯合主鍵(stuNo,corseNo)，這個聯合屬性可以惟一肯定score屬性。
　　那麼再看其餘信息，好比stuName只須要stuNo就可以惟一肯定，courseName只須要courseNo就可以惟一肯定，所以這樣就存在了部分依賴，不符合第二範式。
　　若是要讓學生課程成績信息知足第二範式，那麼久須要將這張表拆分紅多張表，一張學生表Studnet(stuNo,stuName,age,sex)，一張課程表Course(courseNo,courseName,credit)，還有最後一張學生課程成績表StuGrade(stuNo,courseNo,score)。以下：
　　
這樣就符合第二範式了。

第三範式（3NF）屬性不依賴於其它非主屬性 [ 消除傳遞依賴 ]

　　知足第三範式（3NF）必須先知足第二範式（2NF）。
　　簡而言之，第三範式（3NF）要求一個數據庫表中不包含已在其它表中已包含的非主關鍵字信息。

舉例:

　　每個員工都有一個所屬部門，假若有一個員工信息表
　　Employee(emp_id,emp_name,emp_age,dept_id,dept_name,dept_info)
　　
　　這張員工信息表的主鍵是emp_id，由於這個屬性可以惟一肯定其餘全部屬性，好比知道員工編號emp_id之後，確定可以知道員工姓名，所屬部門編號，部門名稱和部門介紹。
　　因此這裏dept_id不是主屬性，而是非主屬性。
　　
　　可是，咱們又能夠發現dept_name,dept_info這兩個屬性也能夠由dept_id這個非主屬性決定，即dept_name依賴dept_id，而dept_id依賴emp_id，這樣就存在了傳遞依賴。並且咱們能夠看出傳遞依賴的一個明顯缺點就是數據冗餘很是嚴重。
　　
　　那麼如何解決傳遞依賴問題？
　　其實很是簡單，咱們只須要將dept_name,dept_info這連個屬性刪除就能夠了。
　　即修改成Employee(emp_id,emp_name,emp_age,dept_id)
　　而後再建立一個部門表Dept(dept_id,dept_name,dept_info)
　　
　　這樣若是要搜索某一個員工的部門信息dept_info，能夠經過數據庫鏈接來實現，查詢語句以下：
　　SELECT e.emp_id,e.emp_name,d.dept_name
　　FROM Employee e,Dept d
　　WHERE e.dept_id=d.dept_id;
　　
注意：
數據庫鏈接會帶來一部分的性能損失
並非數據庫範式越高效率越高
有時會在數據冗餘與範式之間作出權衡，在實際的數據庫開發過程當中，每每會容許一部分的數據冗餘來減小數據庫鏈接

問題四、數據庫範式越高越好嗎?
　　
　　使用範式的主要目的是爲了減小數據冗餘、消除插入異常、更新異常、刪除異常。
　　另外從程序設計的角度範式把數據模式作到了高內聚低耦合讓數據組織的更加和諧。
　　在數據庫設計中應儘可能知足最高範式，可是應用的範式等級越高，查詢時須要鏈接的表就越多，這樣會增長了查詢的複雜度，下降了數據庫查詢性能處理速度緩慢和處理邏輯複雜
　　爲了提升數據庫的運行效率，經常須要下降範式標準：適當增長冗餘，達到以空間換時間的目的。


問題五、設計4個線程,中兩個線程每次對j增長1,另外兩個線程對j每次減小1，請寫出代碼?

　　// 採用 Runnable 接口方式建立的多條線程能夠共享實例屬性
private int data;

/*
* 這裏add方法和sub方法加synchronized關鍵字
* 是由於當兩個線程同時操做同一個變量時
* 就算是簡單的j++操做時，在系統底層也是經過多條機器語句來實現
* 因此在執行j++過程也是要耗費時間，
* 這時就有可能在執行j++的時候，另一個線程H就會對j進行操做
* 所以另一個線程H可能操做的可能就不是最新的值了，所以要提供線程同步
*/

// 同步增長方法
private synchronized void add() {
data++;
System.out.println(Thread.currentThread().getName() + ":" + data);
}

// 同步減小方法
private synchronized void sub() {
data--;
System.out.println(Thread.currentThread().getName() + ":" + data);
}

// 增長線程
class Add implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
add();
}
}
}

// 減小線程
class Sub implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
sub();
}
}
}

public static void main(String[] args) throws Exception {
Test t = new Test();

//內部類的實例化
Add add = t.new Add();
Sub sub = t.new Sub();

//建立線程，每次建立2個線程，此處爲2*n個線程，n=2
for (int i = 0; i < 2; i++) {
Thread t1 = new Thread(add);
t1.start();
Thread t2 = new Thread(sub);
t2.start();
}
}

問題六、寫一個方法，實現字符串的反轉，如：輸入abc，輸出cba?

方法1：
　　String data="abc";
char[] ch = data.toCharArray();

StringBuffer sb=new StringBuffer();

for (int i = ch.length-1; i >=0; i--) {
sb.append(ch[i]);
}

System.out.println(sb);

方法2：
　　String data="abc";
int length = data.length();

StringBuffer sb=new StringBuffer(length);

for (int i = length-1; i >= 0; i--) {
sb.append(data.charAt(i));
}

System.out.println(sb);

方法3：
　　String data="abc";
int length = data.length();

String str="";

for (int i = 0; i < length; i++) {
str=data.substring(i,i+1)+str;

}

System.out.println(str);

方法4：
　　String data="abc";

StringBuffer sb=new StringBuffer(data);

String str = sb.reverse().toString();

System.out.println(str);

方法5：遞歸
　　public static void main(String[] args) {
String data="abc";

String reverse = Test.reverse(data);

System.out.println(reverse);
}

public static String reverse(String data){
if(data.length()==1){
return data;
}

String str = data.substring(data.length()-1, data.length());

str+=reverse(data.substring(0,data.length()-1));

return str;
}

問題七、對於池技術的理解?-->以C3P0鏈接池爲例

----------------------------故事敘述開始


2013年9月9日：

問題一、如何取小數點前兩位，並四捨五入，再進行顯示百分比?

小數點前兩位方法1：
　　BigDecimal bd = new BigDecimal(0.4567);

// 保留兩位小數且向上進位的四捨五入,四捨五入後要從新賦值,不只只setScale
BigDecimal bds = bd.setScale(2, BigDecimal.ROUND_HALF_UP);

System.out.println(bds);

小數點前兩位方法2：
　　DecimalFormat df = new DecimalFormat("#,##0.00");

df.setRoundingMode(RoundingMode.HALF_UP);

String str = df.format(1234.4547);

System.out.println(str);

百分比顯示：
　　DecimalFormat df=new DecimalFormat("0.00%");
df.setRoundingMode(RoundingMode.HALF_UP);

String str = df.format(0.4567);

System.out.println(str);

面試題: !=!=未看12 略多 sql語句練習 很是 有用

JAVA面試總結

面試題: !=!=未看12 略多 sql語句練習很是有用