基礎篇４

一、JDK常用的包４

二、 Get和Post的差別４

三、 Java多态的具體展現４

四、 StringBuffer StringBuilder String 差別５

五、 Hashtable與HashMap的差別５

六、九大隐式對象５

七、 Forword(請求轉發)與Redirect(重定向) ６

八、JQurey總結６

九、 XML和Json的特點６

十、 request.getSession()、reqeust.getSession(false)和 request.getSession(true) ７

十一、 Page和PageContext的差別７

十二、 Ajax總結７

十三、JSP9大隐視對象中四個作用域的大小與作用範圍７

十四、 List,Set,Collection,Collections ８

十五、 java的基本資料類型８

十六、冒泡排序８

十七、二分查找法９

十八、時間類型轉換９

十九、階乘１０

二十、UE和UI的差別１０

二十一、osi七層模型１０

二十二、線程和程序的差別１１

二十三、jvm的記憶體結構１１

二十四、記憶體洩露和記憶體溢出１１

二十五、單例１１

二十六、解析xml檔案的幾種技術１２

二十七、項目的生命周期１３

二十八、OSCache的判斷１４

二十九、經常通路的技術網站１４

三十、項目團隊中交流的工具１４

三十一、平時浏覽的書籍１４

三十二、java Exception體系結構１５

三十三、session和cookie的差別１５

三十四、位元組流與字元流的差別１６

三十五、final,finally,finalize 三者差別１６

三十六、Io流的層次結構１６

三十七、JAVA: １８

三十八、JavaSE JavaEE JavaME差別１８

三十九、JDK JRE JVM的差別：１９

四十、報錯的狀态碼：２０

四十一、協定以及預設的端口号２０

四十二、抽象類與接口的差別２０

四十三、修飾符的作用２０

架構篇２１

一、 Struts1的運作原理２１

二、 Struts2的運作原理２１

三、 struts2的體系結構２１

四、 Spring MVC運作原理２２

五、 Struts1.x與Struts2.x的差別２３

六、 Spring MVC、struts1和struts2差別２３

七、 Struts2中result中的type類型２３

八、 Struts2标簽２４

九、 SSI整合２４

十、 SSH整合２４

十、 Spring MVC整合２５

十一、Hibernate 中get 和 load的差別２５

十二、 Hibernate、Ibatis、Jdbc三者的差別２５

十三、 Hibernate的運作原理２６

十四、 Hibernate五大核心（類/接口）簡述２６

十五、 Hibernate與JDBC的差別２６

十六、Hibernate中的兩大配置檔案２６

十七、 Hibernate事務處理２７

十八、 Hibernate的三種狀态以及狀态的轉換２７

十九、分頁步驟２７

二十、hibernate緩存概述２７

二十一、Ssh的概述：２８

二十二、防止表單重複送出２８

二十三、JSP标簽：２９

二十四、過濾器２９

二十五、攔截器的了解３０

二十六、Spring融入架構３０

資料庫篇３１

一、 JDBC連接配接資料庫步驟(以MYSQL為例) ３１

二、資料庫連接配接池３２

三、 mysql的資料庫導入導出３２

四、 jdbc分段批量送出的時候出現異常怎麼處理? ３３

五、 jdbc批量處理資料３３

六、 Oracle分頁３３

七、 Oracle的基本資料類型３３

八、 id、rowid、rownum的差別３４

九、主鍵和唯一索引的差別？３４

十、 Preparedstatement和statement的差別３５

十一、資料庫三範式３５

十二、視圖概述３５

十三、存儲過程概述３５

十四、索引概述３６

十五、必背的sql語句３７

業務場景篇３９

一、 Spring的概述３９

二、事務概述４１

三、權限概述４１

四、 OSCache業務場景４２

五、線程概述４２

六、 Ajax請求Session逾時問題４３

七：java線程池概述４３

八、 OSCache概述４４

九、 OSCache+autocomplete+單例業務場景４４

十、緩存概述４５

十一、實作頁面靜态化業務場景４５

十二、 servlet線程安全描述４５

十三、 (jbpm4)工作流引擎描述: ４６

十四、 JPBM業務場景４７

十五、 Ant描述４７

十六、 FreeMarker描述４７

十七、 webService描述４８

十八、 oracle索引概述４９

十九、 oracle存儲過程４９

二十、Junit 業務場景５０

二十一、Apache+Tomcat 實作負載均衡及seesion複制５０

二十二、Ant業務場景５０

二十三、maven業務場景５１

二十四、Servlet的概述：５１

優化篇５２

一、代碼優化５２

二、業務優化５２

三、 sql優化５３

四、防sql注入５３

基礎篇

一、JDK常用的包

◆java.lang：這個是系統的基礎類，比如String、Math、Integer、System和Thread，提供常用功能。在java.lang包中還有一個子包：java.lang.reflect用于實作java類...

◆java.io: 這裡面是所有輸入輸出有關的類，比如檔案操作等

◆java.net: 這裡面是與網絡有關的類，比如URL,URLConnection等。

◆java.util : 這個是系統輔助類，特别是集合類Collection,List,Map等。

◆java.sql: 這個是資料庫操作的類，Connection, Statememt，ResultSet等

Get和Post的差別

1.get是從伺服器上擷取資料，post是向伺服器傳送資料，

2.get傳送的資料量較小，不能大于2KB。post傳送的資料量較大，一般被預設為不受限制。

3.get安全性非常低，post安全性較高。但是執行效率卻比Post方法好。

4.在進行檔案上傳時隻能使用post而不能是get。

Java多态的具體展現

面向對象程式設計有四個特征：抽象，封裝，繼承，多态。

多态有四種展現形式：

1. 接口和接口的繼承。

2. 類和類的繼承。

3. 重載。

4. 重寫。

其中重載和重寫為核心。

重載：重載發生在同一個類中，在該類中如果存在多個同名方

法，但是方法的參數類型和個數不一樣，那麼說明該方法被重

載了。

重寫：重寫發生在子類繼承父類的關系中，父類中的方法被子

類繼承，方法名，傳回值類型，參數完全一樣，但是方法體不

一樣，那麼說明父類中的該方法被子類重寫了。

StringBuffer StringBuilder String 差別

String 字元串常量不可變使用字元串拼接時是不同的2個空間

StringBuffer 字元串變量可變線程安全字元串拼接直接在字元串後追加

StringBuilder 字元串變量可變非線程安全字元串拼接直接在字元串後追加

1.StringBuilder執行效率高于StringBuffer高于String.

2.String是一個常量，是不可變的，是以對于每一次+=指派都會建立一個新的對象， StringBuffer和StringBuilder都是可變的，當進行字元串拼接時采用append方法，在原來的基礎上進行追加，是以性能比String要高，又因為StringBuffer 是線程安全的而StringBuilder是線程非安全的，是以StringBuilder的效率高于 StringBuffer.

3.對于大資料量的字元串的拼接，采用StringBuffer,StringBuilder.

Hashtable與HashMap的差別

HashMap不是線程安全的，HashTable是線程安全。

HashMap允許空（null）的鍵和值（key），HashTable則不允許。

HashMap性能優于Hashtable。

Map

1.Map是一個以鍵值對存儲的接口。Map下有兩個具體的實作，分别是HashMap和HashTable.

2.HashMap是線程非安全的，HashTable是線程安全的，是以HashMap的效率高于HashTable.

3.HashMap允許鍵或值為空，而HashTable不允許鍵或值為空.

九大隐式對象

輸入/輸出對象： request response out

作用域通信對象： session application pageContext

Servlet 對象： page config

錯誤對象： exception

Forword(請求轉發)與Redirect(重定向)

1、從資料共享上

Forword是一個請求的延續，可以共享request的資料

Redirect開啟一個新的請求，不可以共享request的資料

2、從位址欄

Forword轉發位址欄不發生變化

Redirect轉發位址欄發生變化

八、JQurey總結

jquery是一個輕量級的js架構，具有跨浏覽器的特性，相容性好，

并且封裝了很多工具，友善使用。

常用的有: 選擇器，dom操作，ajax(ajax不能跨域) ，特效，工具類

XML和Json的特點

Xml特點：

1、有且隻有一個根節點；

2、資料傳輸的載體

3、所有的标簽都需要自定義

4、是純文字檔案

Json（JavaScript Object Notation）特點：

json分為兩種格式:

json對象(就是在{}中存儲鍵值對，鍵和值之間用冒号分隔，

鍵值對之間用逗号分隔);

json數組(就是[]中存儲多個json對象，json對象之間用逗号分隔)

（兩者間可以進行互相嵌套）資料傳輸的載體之一

差別：

　　傳輸同樣格式的資料，xml需要使用更多的字元進行描述，

流行的是基于json的資料傳輸。

xml的層次結構比json更清晰。

共同點：

xml和json都是資料傳輸的載體，并且具有跨平台跨語言的特性。

request.getSession()、reqeust.getSession(false)和 request.getSession(true)

getSession()/getSession(true)：當session存在時傳回該session，否則建立一個 session并傳回該對象

getSession(false)：當session存在時傳回該session，否則傳回null

Page和PageContext的差別

Page是servlet對象；使用this關鍵字，它的作用範圍是在同一頁面。

PageContext是作用域通信對象；通常使用setAttribute()和getAttribute()來設定和擷取存放對象的值。

Ajax總結

AJAX 全稱：異步JavaScript及 XML（Asynchronous JavaScript And XML）

Ajax的核心是JavaScript對象XmlHttpRequest(XHR)。

Ajax的優點:

　　　　提高使用者體驗度(UE)

　　　　提高應用程式的性能

　　　　進行局部重新整理

AJAX不是一種新的程式設計語言，而是一種用于建立更好更快以及互動性更強的 Web 應用程式的技術。

2. 通過 AJAX，我們的 JavaScript 可使用JavaScript的XMLHttpRequest對象來直接與伺服器進行通信。通過這個對象，我們的 JavaScript 可在不重載頁面的情況與Web伺服器交換資料，即可局部重新整理。

3. AJAX 在浏覽器與 Web 伺服器之間使用異步資料傳輸（HTTP 請求），這樣就可使網頁從伺服器請求少量的資訊，而不是整個頁面，減輕伺服器的負擔，提升站點的性能。

AJAX 可使網際網路應用程式更小、更快，更友好，使用者體驗（UE）好。

5. Ajax是基于标準化并被廣泛支援的技術，并且不需要插件和下載下傳小程式

十三、JSP9大隐視對象中四個作用域的大小與作用範圍

四個作用域從大到小：appliaction>session>request>page

application：全局作用範圍，整個應用程式共享.生命周期為：應用程式啟動到停止。

session：會話作用域，當使用者首次通路時，産生一個新的會話，以後伺服器就可以記住這個會話狀态。

request：請求作用域，就是用戶端的一次請求。

page：一個JSP頁面。

以上作用範圍使越來越小， request和page的生命周期都是短暫的，他們之間的差別就是：一個request可以包含多個page頁(include，forward)。

List,Set,Collection,Collections

List和Set都是接口，他們都繼承于接口Collection,List是一個有序的可重複的集合，而Set的無序的不可重複的集合。Collection是集合的頂層接口，Collections是一個封裝了衆多關于集合操作的靜态方法的工具類,因為構造方法是私有的，是以不能執行個體化。

2.List接口實作類有ArrayList,LinkedList,Vector。ArrayList和Vector是基于數組實作的,是以查詢的時候速度快，而在進行增加和删除的時候速度較慢LinkedList是基于鍊式存儲結構，是以在進行查詢的時候速度較慢但在進行增加和删除的時候速度較快。又因為Vector是線程安全的，是以他和ArrayList相比而言，查詢效率要低。

java的基本資料類型

資料類型大小

byte(位元組) 1(8位)

shot(短整型) 2(16位)

int(整型) 4(32位)

long(長整型) 8(32位)

float(浮點型) 4(32位)

double(雙精度) 8(64位)

char(字元型) 2(16位)

boolean(布爾型) 1位

冒泡排序

public class Sort {

public static void sort() {

Scanner input = new Scanner(System.in);

int sort[] = new int[10];

int temp;

System.out.println("請輸入10個排序的資料：");

for (int i = 0; i < sort.length; i++) {

sort[i] = input.nextInt();

}

for (int i = 0; i < sort.length - 1; i++) {

for (int j = 0; j < sort.length - i - 1; j++) {

if (sort[j] < sort[j + 1]) {

temp = sort[j];

sort[j] = sort[j + 1];

sort[j + 1] = temp;

}

System.out.println("排列後的順序為：");

for(int i=0;i<sort.length;i++){

System.out.print(sort[i]+" ");

}

public static void main(String[] args) {

sort();

}

十七、二分查找法

十八、時間類型轉換

public class DateFormat {

public static void fun() {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

String newDate;

try {

newDate = sdf.format(new SimpleDateFormat("yyyyMMdd")

.parse("20121115"));

System.out.println(newDate);

} catch (ParseException e) {

e.printStackTrace();

}

public static void main(String args[]) {

fun();

}

階乘

public class Multiply {

public static int multiply(int num) {

if (num < 0) {

System.out.println("請輸入大于0的數！");

return -1;

} else if (num == 0 || num == 1) {

return 1;

} else {

return multiply(num - 1) * num;

}

public static void main(String[] args) {

System.out.println(multiply(10));

}

二十、UE和UI的差別

UE 是使用者體驗度

UI 界面原型（使用者界面）（相當于買房時用的模型）

設計UI的作用：

1、幫助程式員工作（界面已由美工設計完成）

2、提前讓使用者對項目有個宏觀的了解，知道效果是什麼樣子。

二十一、osi七層模型

第一層：實體層

第二層：資料鍊路層

第三層：網絡層

第四層：傳輸層

第五層：會話層

第六層：表示層

第七層：應用層

二十二、線程和程序的差別

1.線程(Thread)與程序（Process）

程序定義的是應用程式與應用程式之間的邊界，通常來說一個程序就代表一個與之對應的應用程式。不同的程序之間不能共享代碼和資料空間，而同一程序的不同線程可以共享代碼和資料空間。

一個程序可以包括若幹個線程，同時建立多個線程來完成某項任務，便是多線程。
實作線程的兩種方式：繼承Thread類，實作Runable接口

二十三、jvm的記憶體結構

java虛拟機的記憶體結構分為堆(heap)和棧(stack),堆裡面存放是對象執行個體也就是new出來的對象。棧裡面存放的是基本資料類型以及引用資料類型的位址。

對于所謂的常量是存儲在方法區的常量池裡面。

二十四、記憶體洩露和記憶體溢出

記憶體洩露 (memory leak)，是指應用程式在申請記憶體後，

無法釋放已經申請的記憶體空間.一次記憶體洩露危害可以忽略，

但如果任其發展最終會導緻記憶體溢出(out of memory).

如讀取檔案後流要進行及時的關閉以及對資料庫連接配接的釋放。

記憶體溢出（out of memory）是指應用程式在申請記憶體時，

沒有足夠的記憶體空間供其使用。

如我們在項目中對于大批量資料的導入，采用分段批量送出的方式。

二十五、單例

單例就是該類隻能傳回一個執行個體。

單例所具備的特點：

1.私有化的構造函數

2.私有的靜态的全局變量

3.公有的靜态的方法

單例分為懶漢式、餓漢式和雙層鎖式

餓漢式:

public class Singleton1 {

private Singleton1() {};

private static Singleton1 single = new Singleton1();

public static Singleton1 getInstance() {

return single;

}

懶漢式：

public class Singleton2 {

private Singleton2() {}

private static Singleton2 single=null;

public static Singleton2 getInstance() {

if (single == null) {

single = new Singleton2();

}

return single;

}

線程安全：

public class Singleton3 {

private Singleton3() {}

private static Singleton3 single ;

public static Singleton3 getInstance() {

if(null == single){

synchronized(Singleton3.class){

if(null == single){

single = new Singleton3();

}

return single;

}

二十六、解析xml檔案的幾種技術

1、解析xml的幾種技術

1.dom4j

2.sax

3.jaxb

4.jdom

5.dom

1.dom4j

dom4j是一個Java的XML API，類似于jdom，用來讀寫XML檔案的。dom4j是一個非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟體。

2.sax

SAX（simple API for XML）是一種XML解析的替代方法。相比于DOM，SAX是一種速度更快，更有效的方法。它逐行掃描文檔，一邊掃描一邊解析。而且相比于DOM，SAX可以在解析文檔的任意時刻停止解析，但任何事物都有其相反的一面，對于SAX來說就是操作複雜。

3.jaxb

JAXB（Java Architecture for XML Binding) 是一個業界的标準，是一項可以根據XML Schema産生Java類的技術。該過程中，JAXB也提供了将XML執行個體文檔反向生成Java對象樹的方法，并能将Java對象樹的内容重新寫到XML執行個體文檔。從另一方面來講，JAXB提供了快速而簡便的方法将XML模式綁定到Java表示，進而使得Java開發者在Java應用程式中能友善地結合XML資料和處理函數。

2、dom4j 與 sax 之間的對比：【注：必須掌握！】

dom4j不适合大檔案的解析，因為它是一下子将檔案加載到記憶體中，是以有可能出現記憶體溢出，

sax是基于事件來對xml進行解析的，是以他可以解析大檔案的xml

也正是因為如此，是以dom4j可以對xml進行靈活的增删改查和導航，而sax沒有這麼強的靈活性

是以sax經常是用來解析大型xml檔案，而要對xml檔案進行一些靈活（crud）操作就用dom4j

二十七、項目的生命周期

1.需求分析

2.概要設計

3.詳細設計(用例圖，流程圖，類圖)

4.資料庫設計(powerdesigner)

5.代碼開發（編寫）

6.單元測試（junit 白盒測試）(開發人員)

svn版本管理工具(送出，更新代碼，文檔)

7.內建測試（黑盒測試，loadrunner（編寫測試腳本）(進階測試)）

8.上線試運作（使用者自己體驗）

9.壓力測試（loadrunner）

10.正式上線

11.維護

二十八、OSCache的判斷

Object obj = CacheManager.getInstance().getObj("oaBrandList");

//從緩存中取資料

if (null == obj) {

obj = brandDao.getBrandList();

//如果為空再從資料庫擷取資料

//擷取之後放入緩存中

CacheManager.getInstance().putObj("oaBrandList", obj);

}

return (List<OaBrand>)obj;

二十九、經常通路的技術網站

1.csdn(詳細步驟的描述)

2.iteye(詳細步驟的描述)

3.oschina（開源中國擷取java開源方面的資訊技術）

4.java開源大全 www.open-open.com(擷取java開源方面的資訊技術)

5.infoq(對java,php,.net等這些語言的一些最新消息的報道)

6.itpub 綜合性技術論壇

三十、項目團隊中交流的工具

飛秋(區域網路) qq(區域網路，外網)

RTX（區域網路，外網）郵箱（區域網路，外網）

三十一、平時浏覽的書籍

實戰經驗：

*** in action(實戰)

*** 深入淺出

*** 入門指南

思想基礎:

　　大話設計模式重構

三十二、java Exception體系結構

java 異常是程式運作過程中出現的錯誤。Java把異常當作對象來處理，并定義一個基類java.lang.Throwable作為所有異常的超類。在Java API中定義了許多異常類,分為兩大類，錯誤Error和異常Exception。其中異常類Exception又分為運作時異常(RuntimeException)和非運作時異常(非runtimeException)，也稱之為不檢查異常（Unchecked Exception）和檢查異常（Checked Exception）。

1、Error與Exception

Error是程式無法處理的錯誤，比如OutOfMemoryError、ThreadDeath等。

這些異常發生時，Java虛拟機（JVM）一般會選擇線程終止。

Exception是程式本身可以處理的異常，這種異常分兩大類運作時異常和非運作時異常。程式中應當盡可能去處理這些異常。

2、運作時異常和非運作時異常

運作時異常: 都是RuntimeException類及其子類異常： IndexOutOfBoundsException 索引越界異常

ArithmeticException：數學計算異常

NullPointerException：空指針異常

ArrayOutOfBoundsException：數組索引越界異常

ClassNotFoundException：類檔案未找到異常

ClassCastException：造型異常（類型轉換異常）

這些異常是不檢查異常（Unchecked Exception），程式中可以選擇捕獲處理，也可以不處理。這些異常一般是由程式邏輯錯誤引起的。

非運作時異常:是RuntimeException以外的異常，類型上都屬于Exception類及其子類。從程式文法角度講是必須進行處理的異常，如果不處理，程式就不能編譯通過。如：

IOException、檔案讀寫異常

FileNotFoundException：檔案未找到異常

EOFException：讀寫檔案尾異常

MalformedURLException：URL格式錯誤異常

SocketException：Socket異常

SQLException：SQL資料庫異常

三十三、session和cookie的差別

session是存儲在伺服器端，cookie是存儲在用戶端的，是以安全來講session的安全性要比cookie高，然後我們擷取session裡的資訊是通過存放在會話cookie裡的sessionid擷取的。又由于session是存放在伺服器的記憶體中，是以session裡的東西不斷增加會造成伺服器的負擔，是以會把很重要的資訊存儲在session中，而把一些次要東西存儲在用戶端的cookie裡，然後cookie确切的說分為兩大類分為會話cookie和持久化cookie，會話cookie确切的說是存放在用戶端浏覽器的記憶體中，是以說他的生命周期和浏覽器是一緻的，浏覽器關了會話cookie也就消失了，然而持久化cookie是存放在用戶端硬碟中，而持久化cookie的生命周期就是我們在設定cookie時候設定的那個儲存時間，然後我們考慮一問題當浏覽器關閉時session會不會丢失，從上面叙述分析session的資訊是通過sessionid擷取的，而sessionid是存放在會話cookie當中的，當浏覽器關閉的時候會話cookie消失是以我們的sessionid也就消失了，但是session的資訊還存在伺服器端，這時我們隻是查不到所謂的session但它并不是不存在。那麼，session在什麼情況下丢失，就是在伺服器關閉的時候，或者是session過期，再或者調用了invalidate()的或者是我們想要session中的某一條資料消失調用session.removeAttribute()方法，然後session在什麼時候被建立呢，确切的說是通過調用session.getsession來建立，這就是session與cookie的差別

三十四、位元組流與字元流的差別

stream結尾都是位元組流，reader和writer結尾都是字元流

兩者的差別就是讀寫的時候一個是按位元組讀寫，一個是按字元。

實際使用通常差不多。

在讀寫檔案需要對内容按行處理，比如比較特定字元，處理某一行資料的時候一般會選擇字元流。

隻是讀寫檔案，和檔案内容無關的，一般選擇位元組流。

三十五、final,finally,finalize 三者差別

Final是一個修飾符：

當final修飾一個變量的時候，變量變成一個常量，它不能被二次指派

當final修飾的變量為靜态變量（即由static修飾）時，必須在聲明這個變量的時候給它指派

當final修飾方法時，該方法不能被重寫

當final修飾類時，該類不能被繼承

Final不能修飾抽象類，因為抽象類中會有需要子類實作的抽象方法，（抽象類中可以有抽象方法，也可以有普通方法，當一個抽象類中沒有抽象方法時，這個抽象類也就沒有了它存在的必要）

Final不能修飾接口，因為接口中有需要其實作類來實作的方法

Finally：

Finally隻能與try/catch語句結合使用，finally語句塊中的語句一定會執行，并且會在return，continue，break關鍵字之前執行

finalize：

Finalize是一個方法，屬于java.lang.Object類，finalize()方法是GC （garbage collector垃圾回收）運作機制的一部分，finalize()方法是在 GC清理它所從屬的對象時被調用的

三十六、Io流的層次結構

從流的方向

輸入流輸出流

從流的類型上

字元流位元組流

inputstream和outputstream都是抽象類

它們下面的實作包括

FileInputStream,BufferedInputStream

FileOutputStream,BufferedOutputStream

reader 和 writer

FileReader,BufferedReader,StringReader

FileWriter,BufferedWriter,StringWriter,PrintWriter

三十七、JAVA:

Java是面向對象的，跨平台的，它通過java虛拟機來進行跨平台操作，它可以進行自動垃圾回收的【c語言是通過人工進行垃圾回收】，java還會進行自動配置設定記憶體。【c語言是通過指定進行配置設定記憶體的】，隻需要new一個對象，這個對象占用了多少空間，不需要我們來管，java虛拟機負責管這些，用完之後也不需要我們來釋放，java虛拟機會自動釋放

三十八、JavaSE JavaEE JavaME差別

是什麼：

Java SE=Java Standard Edition=j2se = java 标準版

Java EE=Java Enterprise Edition=j2ee= java 企業版

Java ME=Java Mobile Edition=j2me = java移動版

特點：

SE主要用于桌面程式（swing）,控制台開發(main程式)。

EE企業級開發(JSP,EJB,Spring MVC,Struts,hibernate,ibatis等)，

用于企業級軟體開發，網絡開發，web開發。

ME嵌入式開發(手機,小家電，PDA)。[蘋果的ios，黑莓]

三者之間的關系：

Java SE（Java Platform, Standard Edition，Java标準版）就是基于JDK和JRE的。

Java SE為Java EE提供了基礎。

Java EE除了基于我們這個所謂的Java SE外，還新加了企業應用所需的類庫

三十九、JDK JRE JVM的差別：

Jdk【Java Development ToolKit】就是java開發工具箱， JDK是整個JAVA的核心裡邊包含了jre，它除了包含jre之外還包含了一些javac的工具類，把java源檔案編譯成class檔案，java檔案是用來運作這個程式的，除此之外，裡邊還包含了java源生的API，java.lang.integer在rt的jar包裡邊【可以在項目中看到】，通過rt這個jar包來調用我們的這些io流寫入寫出等

JDK有以下三種版本：

J2SE，standard edition，标準版，是我們通常用的一個版本

J2EE，enterpsise edtion，企業版，使用這種JDK開發J2EE應用程式

J2ME，micro edtion，主要用于移動裝置、嵌入式裝置上的java應用程式

Jre【Java Runtime Enviromental】是java運作時環境，那麼所謂的java運作時環境，就是為了保證java程式能夠運作時，所必備的一基礎環境，也就是它隻是保證java程式運作的，不能用來開發，而jdk才是用來開發的，所有的Java程式都要在JRE下才能運作。

包括JVM和JAVA核心類庫和支援檔案。與JDK相比，它不包含開發工具——編譯器、調試器和其它工具。

Jre裡邊包含jvm

Jvm：【Java Virtual Mechinal】因為jre是java運作時環境，java運作靠什麼運作，而底層就是依賴于jvm，即java虛拟機，java虛拟機用來加載類檔案，java中之是以有跨平台的作用，就是因為我們的jvm

關系：

J2se是基于jdk和jre，

JDK是整個JAVA的核心裡邊包含了jre，

Jre裡邊包含jvm

四十、報錯的狀态碼：

301 永久重定向

302 臨時重定向

304 服務端未改變

403 通路無權限

200 正常

404 路徑

500 内部錯誤

四十一、協定以及預設的端口号

ftp 21 檔案傳輸協定

Pop3 110 它是網際網路 <http://baike.baidu.com/view/1706.htm>電子郵件 <http://baike.baidu.com/view/1524.htm>的第一個離線 <http://baike.baidu.com/view/113466.htm>協定标準

Smtp 25 簡單郵件傳輸協定

http 80 超文本傳輸協定

oracle 預設端口号1521

mysql預設端口号 3306

四十二、抽象類與接口的差別

1.一個類隻能進行單繼承，但可以實作多個接口。

2.有抽象方法的類一定是抽象類，但是抽象類裡面不一定有抽象方法；

接口裡面所有的方法的預設修飾符為public abstract，接口裡的成員變量預設的修飾符為 pulbic static final。

關系

接口和接口繼承

接口和抽象類抽象類實作接口

類和抽象類類繼承抽象類

類和類繼承

四十三、修飾符的作用

修飾符的作用範圍:

private default protected public

同一個類中可以可以可以可以

同一個包的類中可以可以可以

不同包的子類中可以可以

不同包的類中可以

四十四、onready和onload的差別

1.onready比onload先執行

2.onready是在頁面解析完成之後執行，而onload是在頁面所有元素加載後執行

3.onload隻執行最後一個而onready可以執行多個。

參考：

執行時間 window.onload必須等到頁面内包括圖檔的所有元素加載完畢後才能執行。 $(document).ready()是DOM結構繪制完畢後就執行，不必等到加載完畢。 2.編寫個數不同 window.onload不能同時編寫多個，如果有多個window.onload方法，隻會執行一個 $(document).ready()可以同時編寫多個，并且都可以得到執行 3.簡化寫法 window.onload沒有簡化寫法 $(document).ready(function(){})可以簡寫成$(function(){}); 另外，需要注意一點，由于在$(document).ready() 方法内注冊的事件，隻要DOM 就緒就會被執行，是以可能此時元素的關聯檔案未下載下傳完。例如與圖檔有關的html 下載下傳完畢，并且已經解析為DOM 樹了，但很有可能圖檔還沒有加載完畢，是以例如圖檔的高度和寬度這樣的屬性此時不一定有效。要解決這個問題，可以使用Jquery 中另一個關于頁面加載的方法---load() 方法。Load() 方法會在元素的onload 事件中綁定一個處理函數。如果處理函數綁定給window 對象，則會在所有内容( 包括視窗、架構、對象和圖像等) 加載完畢後觸發，如果處理函數綁定在元素上，則會在元素的内容加載完畢後觸發。 Jquery 代碼如下： $(window).load(function (){ // 編寫代碼 });等價于JavaScript 中的以下代碼 Window.onload = function (){ // 編寫代碼 }

架構篇

Struts1的運作原理

在啟動時通過前端總控制器ActionServlet加載struts-config.xml并進行解析，當使用者在jsp頁面發送請求被struts1的核心控制器ActionServlet接收，ActionServlet在使用者請求時将請求參數放到對應的ActionForm對象中的成員變量中，然後ActionServlet則會根據struts-config.xml中的映射關系找到相應的Action中的方法，将對應的ActionForm一并傳給這個Action中的方法裡，然後執行相應的業務邏輯操作，最後就根據ActionMapping的findforward方法傳回一個ActionForward,之後在struts-config.xml中找到與之對應的forward标簽，根據它的配置路徑找到對應的jsp頁面。

Struts2的運作原理

1、tomcat 啟動的時候會加載 web.xml 、核心控制器 FilterDispatcher 會加載并解析 struts.xml

2、用戶端會發送一個請求到 action 、FilterDispatcher 會根據字尾名進行攔截

3、FilterDispatcher根據 struts.xml 的配置檔案資訊找到某個action 對應的某個類裡的指定方法

4、執行相關的業務邏輯最後傳回一個String

5、<action/> 裡配置 <result/> name的屬性值與傳回的String 進行比對,跳轉到指定的jsp 頁面

struts2的體系結構

1、用戶端向Servlet容器（例如Tomcat）發送一個請求；

2、這個請求經過一系列的過濾器（Filter）；

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

4、如果ActionMapper決定需要調用某個Action，FilterDispatcher把請求的處理交給ActionProxy；

5、ActionProxy通過Configuration Manager詢問架構的配置檔案，找到需要調用的Action類；

6、ActionProxy建立一個ActionInvocation的執行個體。

7、ActionInvocation在調用Action的過程前後，涉及到相關攔截器（Intercepter）的調用。

8、一旦Action執行完畢，ActionInvocation負責根據struts.xml中的配置找到對應的傳回結果。傳回結果通常是jsp或者FreeMarker的模版。（體系結構圖見下一頁）

Spring MVC運作原理

整個處理過程從一個HTTP請求開始：

1.Tomcat在啟動時加載解析web.xml,找到spring mvc的前端總控制器DispatcherServlet,并且通過DispatcherServlet來加載相關的配置檔案資訊。

2.DispatcherServlet接收到用戶端請求，找到對應HandlerMapping，根據映射規則，找到對應的處理器（Handler）。

3.調用相應處理器中的處理方法，處理該請求後，會傳回一個ModelAndView。

4.DispatcherServlet根據得到的ModelAndView中的視圖對象，找到一個合适的ViewResolver（視圖解析器），根據視圖解析器的配置，DispatcherServlet将要顯示的資料傳給對應的視圖，最後顯示給使用者。

Struts1.x與Struts2.x的差別

Struts 2以WebWork為核心，

采用攔截器的機制來處理使用者的請求，struts1嚴重依賴于servletAPI,

屬于侵入性架構,struts2不嚴重依賴于servletAPI,屬于非侵入型架構。

線程模型方面：

Struts1的Action是單執行個體的,

一個Action的執行個體處理所有的請求。

Struts2的Action是一個請求對應一個執行個體（每次請求時都新new出一個對象）,

沒有線程安全方面的問題

封裝請求參數：

Struts1中強制使用ActionForm對象封裝請求的參數。

Struts2可以選擇使用POJO類來封裝請求的參數，或者直接使用Action的屬性。

struts1的前端總控制器(核心總控制器)為ActionServlet,

struts2的前端總控制器(核心總控制器)為FilterDispather

Spring MVC、struts1和struts2差別

1.spring mvc 單例非線程安全

struts1單例非線程安全

struts2線程安全對每個請求都産生一個執行個體

2.spring mvc的入口是servlet，而struts2是filter

spring 的前端總控制器為 DispatcherServlet

struts2 的前端總控制器為 FilterDispatcher

struts1 的前端總控制器為 actionServlet

3. 參數傳遞：struts是在接受參數的時候，

可以用屬性來接受參數，這就說明參數是讓多個方法共享的。

springmvc 用方法來接受參數

4.spring mvc是基于方法的設計,而sturts是基于類

Struts2中result中的type類型

1.dispatcher：它是預設的，用來轉向頁面，通常處理JSP

2.redirect：将使用者重定向到一個已配置好的URL

3.redirectAction：将使用者重定向到一個已定義好的action

4.chain：将action和另外一個action連結起來

5.freemarker：呈現Freemarker模闆

6.httpheader：傳回一個已配置好的HTTP頭資訊響應

7.stream：向浏覽器發送InputSream對象對下載下傳的内容和圖檔非常有用

8.velocity：呈現Velocity模闆

9.xslt ：該XML可以通過XSL模闆進行轉換

10.plaintext：顯示原始檔案内容，例如檔案源代碼

Struts2标簽

首先需要引用 <%@taglib prefix="s" uri="/struts-tags"%>

1.<s:if></s:if> 判斷标簽後面可跟 <s:else>

2.<s:iterator> </s:iterator> 疊代标簽

3.<s:include></s:include> 引入标簽可以把一個JSP頁面或者servlet引入一個頁面中

4.<s:property></s:property> 輸出标簽

5.<s:set></s:set> 标簽賦予變量一個特定範圍内的值

6.<s:form></s:form> 表單标簽

7.<s:testarea></s:textarea> 文本域标簽

8.<s:select></s:select> 下拉标簽

9.<s:url></s:url> 聲明一個url的路徑

最常用的是：

判斷<s:if></s:if>

循環<s:iterator></s:terator>

輸出<s:property></s:property>

SSI整合

1、Action繼承于Actionsupport

2、引入struts-spring-plugin.jar包，進而完成struts和spring的整合

3、在struts2的action中注入service，保證service的名字和配置檔案中的一緻，并生成get,set方法

4、Dao層繼承于SqlMapClientDaoSupport

5、在dao層的配置檔案中注入sqlMapClient

SSH整合

1.首先在web.xml中通過ContextLoaderListener來融入spring，

并加載spring的相關配置檔案

2.同樣配置sturts2的前端總控制器filterDispatcher來過濾相關的

請求并且加載struts.xml

3.action繼承ActionSupport，然後通過引入struts-spring-plugin.jar

包并且根據配置檔案中service的id生成get,set方法來注入service層。

4.dao層繼承于HibernateDaoSupport，并且在dao的配置檔案中注入sessionFactory.

5.通過spring中的配置檔案加載hibernate.cfg.xml檔案進而融入hibernate.

在ssh架構中是怎麼整合spring?

首先在web.xml中通過ContextLoaderListener來融入spring，

并加載spring的相關配置檔案

在ssh架構中是怎麼整合hibernate?

通過spring中的配置檔案加載hibernate.cfg.xml檔案進而融入hibernate

dao層繼承于HibernateDaoSupport，并且在dao的配置檔案中注入sessionFactory

在ssh架構中是怎麼整合struts2?

配置sturts2的前端總控制器filterDispatcher來過濾相關的

請求并且加載struts.xml

Spring MVC整合

1.首先,要在web.xml裡面配置SpringMVC的核心控制器,DispatcherServlet,對指定的字尾請求進行攔截。

2.Controller層要加 @Controller注解,表明該類是MVC的控制層。

3.建立Service接口,給接口加上注解 @Component或者 @Service 表明這是Service業務處理層

4.在Controller層聲明Service變量(屬性),給變量（屬性）加上 @Autowired注解,通過自動綁定機制将Service注入到Controller。 (注：@Autowired預設是ByType,如果想根據屬性名注入,那麼就再加上注解 @Resource(name="屬性名"))

5.在Controller層的方法上加上注解 @RequestMapping("requestAddress") 表明該方法的請求位址

6.Dao層要加上注解 @Repository 表明這是資料庫持久層

7.同樣将dao執行個體注入到service層中。

8.配置視圖解析器 "InternalResourceViewResolver",對處理後的跳轉進行統一配置。

十一、Hibernate 中get 和 load的差別

加載方式：

load為延遲加載(傳回的是一個隻有id屬性的代理,隻有使用該對象屬性時,才發出sql語句)；

get為立即加載(執行時,會立即向資料庫發出sql語句)

傳回結果：

load檢索不到記錄時,會抛ObjectNotFoundException異常

get檢索不到記錄時,會傳回null

Hibernate、Ibatis、Jdbc三者的差別

Hibernate屬于全自動， Ibatis屬于半自動，Jdbc屬于手動，從開發效率上講hibernate較高，ibatis居中，jdbc較低，從執行效率上講hibernate較低，ibatis居中，jdbc較高，因為jdbc是手工寫sql語句，程式員對sql的控制能力更大，可以根據業務需要進行優化，而ibatis雖然也可以對sql進行優化，但是他裡面将resultset封裝為實體的過程中采用了反射機制是以一定程度上影響了性能，而hibernate因為高度封裝是以開發效率相對較高，但正因為這個原因，是以程式員在對sql語句的控制和優化方面相對比較弱，而且在将resultset封裝成實體的過程中也采用了反射機制，是以在性能方面較低

Hibernate的運作原理

首先通過configuration去加載hibernate.cfg.xml這個配置檔案，根據

配置檔案的資訊去建立sessionFactory,sessionFactory是線程安全的，

是一個session工廠，用來建立session,session是線程不安全的，相當于

jdbc的connection，最後通過session去進行資料庫的各種操作，在進行操作

的時候通過transaction進行事務的控制。

Hibernate五大核心（類/接口）簡述

1 .Configuration接口的作用是對Hibernate進行配置，以及對它進行啟動。（加載 hibernate.cfg.xml）并建立一個SessionFactory對象。

2 .SessionFactory接口

SessionFactory接口負責初始化Hibernate。它充當資料存儲源的代理，并負責建立 Session對象。SessionFactory是線程安全的。

3 .Session接口

Session（會話）接口是Hibernate應用使用的主要接口。Session接口負責執行被持久化對象的CRUD操作(增删改查)。Session對象是非線程安全的。Session 相當于jdbc的connection

4 .Query與Criteria接口

總之Query和Criteria接口負責執行各種資料庫查詢。

5 .Transaction接口

Transaction（事務）負責操作相關的事務。

Hibernate與JDBC的差別

hibernate和jdbc主要差別就是，hibernate先檢索緩存中的映射對象( 即hibernate操作的是對象)，而jdbc則是直接操作資料庫.
Hibernate是JDBC的輕量級的對象封裝，它是一個獨立的對象持久層架構。Hibernate可以用在任何JDBC可以使用的場合
Hibernate是一個和JDBC密切關聯的架構，是以Hibernate的相容性和JDBC驅動，和資料庫都有一定的關系，但是和使用它的Java程式，和App Server沒有任何關系，也不存在相容性問題。

4、如果正确的使用JDBC技術,它的執行效率一定比hibernate要好,因為hibernate是基于jdbc的技術.

5、JDBC使用的是SQL語句，Hibernate使用的是HQL語句，但是HQL語句最終還會隐式轉換成SQL語句執行。

十六、Hibernate中的兩大配置檔案

*.hbm.xml：主鍵生成政策，映射關系，一對多，一對一的關系。

Hibernate.cfg.xml：方言(用哪個資料庫)，資料庫連接配接資訊，包含*.hbm.xml内容，映射檔案，也可以配事務。

Hibernate事務處理

開啟事務 session.beginTransaction();

執行相關的操作，如果成功則session.getTransaction().commit();

執行操作失敗則 session.getTransaction.rollback();

Hibernate的三種狀态以及狀态的轉換

Transient(臨時)

new 一個初始化對象後，并沒有在資料庫裡儲存資料，處于臨時狀态；

Persistent(持久化)

當執行save()方法，調用session.close()方法之前，記憶體中的對象與資料庫有對應關系處于持久化狀态；

Detached(托管/遊離)

　　　當執行session.close()之後，處于托管狀态；

狀态的轉換

處于托管狀态下，調用update()方法後，轉換為持久化狀态；

在持久化狀态下，執行delete()方法後，轉換為臨時狀态；

在未初始化對象之前，調用get(),load(),find(),iterate()之後，直接進入持久化狀态。

分頁步驟

①前台封裝一個顯示分頁的元件

②查詢總條數

③背景封裝分頁工具類，計算開始位置、結束位置、總頁數

④背景寫支援分頁的sql語句

⑤前台包含分頁元件，實作分頁效果

注意:

查詢總條數的where和查詢清單資訊的where條件要保證一緻。

二十、hibernate緩存概述

hibernate分為一級緩存即session緩存也叫事務級别的緩存以及

二級緩存sessionFactory即應用級别的緩存,還有查詢緩存即三級緩存.

一級緩存的生命周期和session的生命周期保持一緻，

hibernate預設就啟用了一級緩存，

不能将其關閉，可以通過session.clear()和session.evict(object)來管理一級緩存。其中get,load,iterate都會使用一級緩存，一級緩存緩存的是對象。

二級緩存的生命周期和sessionFactory的生命周期保持一緻，可以跨session,被多個session共享，hibernate3預設開啟二級緩存,也可以手動開啟并指定緩存插件如ehcache,oscache

等。二級緩存也隻能緩存對象。

三級緩存也叫查詢緩存，查詢緩存是針對普通屬性結果集的緩存,

對實體對象的結果集隻緩存id。對query.list()起作用，query.iterate不起作用，也就是query.iterate不使用查詢緩存

二十一、Ssh的概述：

ssh是web開發中常見的一種架構

s-struts

s-spring

h-hibernate

其中struts在架構中充當控制器，實作MVC，主要用來處理使用者的請求，和跳轉頁面。使項目結構清晰，開發者隻需要關注業務邏輯的實作即可。

spring在ssh充當粘合劑，粘合struts-sping-hibernate，主要用來進行事物的控制，

hibernate-充當資料庫持久層，主要用它來與資料庫互動，提高開發效率，減輕程式員sql控制要求，而且hibernate通過反射機制，有靈活的映射性，還支援各種關系，一對一，一對多，多對多。

在進行ssh整合的時候，我們應該注意：

1. Action繼承于ActionSupport

引入struts-spring-plugin.jar包，進而完成struts和spring的整合

在struts2的action中注入service，保證service的名字和配置檔案中的一緻，并生成get,set方法

Dao層繼承于hibernateDaoSupport

在dao層的配置檔案中注入sessionFactory

二十二、防止表單重複送出

針對于重複送出的整體解決方案：

1.用redirect來解決重複送出的問題

2.點選一次之後，按鈕失效

3.通過loading

4.自定義重複送出過濾器

5.解決struts2重複送出

可以結合s:token标簽來解決重複送出問題

利用token的原理：

1.在前端的jsp頁面中加入s:token标簽，在通路該頁面時就會生成

隐藏域，該隐藏域中包含一個随機生成的字元串，并把該字元串

存入session中

2.在struts2的配置檔案中加入token攔截器後，當正常通路action

的時候，會從session中取出該字元串，然後和頁面隐藏域中送出

字元串做對比，如果一緻則正常執行并删除session中存儲的字元串。

二十三、JSP标簽：

1.JSP include動作

jsp:include 動作

以“<jsp: 動作名 ” 開始，以“</jsp:動作名> ” 結束

比如：<jsp:include page=" Filename" />

2.JSP指令：<%@ include%><%@ %>

以“<%@ ” 開始，以“%> ” 結束。比如：

<%@ include file = " Filename" %>

3.JSP輸出表達式：<%= %><%=Java表達式 %>

輸出變量的值，後邊不能加<%= ; %>

4.JSP Scriptlet【腳本】:<% ;%> <% Java 代碼 %>

例子：

<% Calendar now = Calendar.getInstance(); %>

5.JSP聲明：<%! %> <%! 函數或者方法 %>

例子：

<%!

String getHello(String name) {

return "Hi," + name + "!";

}

6.疊代标簽：<c:foreach>

Jstl中的核心标簽（core）

7.JSP注釋：

<%-- 這也是注釋,但用戶端不能檢視到 --%>

el表達式：${}
jsp:include動作是在運作時動态包含。

@include指令是在編譯時包含。

它們兩個都隻能包含本項目的相關檔案，不能包含其他項目的。

如果要包含其他項目的檔案可以使用c:import

二十四、過濾器

filter的概述:

filter是一個過濾器，用來在請求前和響應後進行資料的處理。

filter的生命周期是:

執行個體化--->初始化(init)-->進行過濾(doFilter)--->銷毀(destroy)-->釋放資源

一個Filter必須實作javax.servlet.Filter接口

在項目中我們通常通過filter進行編碼轉換，

進行安全驗證，進行重複送出的判斷。

了解(不需要主動說)

filter 相當于攔截器相當于Spring AOP

servlet+jsp+javabean+jdbc+filter

<filter-name>encodingFilter</filter-name>

<filter-class>org.leopard.filter.EncodingFilter</filter-class>

<init-param>

<param-name>encode</param-name>

<param-value>utf-8</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>encodingFilter</filter-name>

<url-pattern>*</url-pattern>

</filter-mapping>

二十五、攔截器的了解

什麼是攔截器：

攔截器是AOP中的概念，它本身是一段代碼，可以通過定義“織入點”，來指定攔截器的代碼在“織入點”的前後執行，進而起到攔截的作用

正如上面 Struts2的Reference中講述的，Struts2的Interceptor，其攔截的對象是Action代碼，可以定義在Action代碼之前或者之後執行攔截器的代碼。

在項目中，我們經常用來攔截通過非正常程式而進行的通路

Struts2的攔截器和Servlet過濾器類似。在執行Action的execute方法之前，Struts2會首先執行在struts.xml中引用的攔截器，在執行完所有引用的攔截器的intercept方法後，會執行Action的execute方法。

其中intercept方法是攔截器的核心方法，所有安裝的攔截器都會調用之個方法。在Struts2中已經在struts-default.xml中預定義了一些自帶的攔截器，如timer、params等。如果在<package>标簽中繼承struts-default，則目前package就會自動擁有struts-default.xml中的所有配置。代碼如下：

攔截器是Struts2架構的核心，它主要完成解析請求參數、将請求參數指派給Action屬性、執行資料校驗、檔案上傳等工作

在struts-default.xml中有一個預設的引用，在預設情況下（也就是<action>中未引用攔截器時）會自動引用一些攔截器。struts2中預設的攔截器是defaultStack.

自定義攔截器需要特别注意的是不要忘記引入struts2預設的攔截器。為了實作某些操作，我們可以自定義攔截器，

自定義攔截器有三種方式定義。分别為實作Interceptor接口，繼承抽象類AbstractInterceptor，繼承MethodFilterInteceptor類。

攔截器在項目中的運用：

同時可以減輕代碼備援，提高重用率。

如果要求使用者密碼、權限等的驗證，就可以用自定義的攔截器進行密碼驗證和權限限制。對符合的登入者才跳轉到正确頁面。

二十六、Spring融入架構

我們通過在web.xml中配置ContextLoaderListener這個監聽器也加載

spring的配置檔案，進而融入到項目架構中。

二十七、項目的部署方式

1、如果項目單獨部署到tomcat中的時候，應該看tomcat中的server.xml;

2、如果和eclipse結合使用進行項目部署的時候，應該看eclipse裡面的server.xml.

二十八、Spring中Bean的作用域，生命周期

Spring 3中為Bean定義了5中作用域，分别為singleton（單例）、prototype（原型）、request、session和global session，5種作用域說明如下：

singleton：單例模式，Spring IoC容器中隻會存在一個共享的Bean執行個體，無論有多少個Bean引用它，始終指向同一對象。Singleton作用域是Spring中的預設作用域，也可以顯示的将Bean定義為singleton模式，配置為：

prototype:原型模式，每次通過Spring容器擷取prototype定義的bean時，容器都将建立一個新的Bean執行個體，每個Bean執行個體都有自己的屬性和狀态，而singleton全局隻有一個對象。根據經驗，對有狀态的bean使用prototype作用域，而對無狀态的bean使用singleton作用域。

request：在一次Http請求中，容器會傳回該Bean的同一執行個體。而對不同的Http請求則會産生新的Bean，而且該bean僅在目前Http Request内有效。

<bean id="loginAction" class="com.cnblogs.Login" scope="request"/>,針對每一次Http請求，Spring容器根據該bean的定義建立一個全新的執行個體，且該執行個體僅在目前Http請求内有效，而其它請求無法看到目前請求中狀态的變化，當目前Http請求結束，該bean執行個體也将會被銷毀。

session：在一次Http Session中，容器會傳回該Bean的同一執行個體。而對不同的Session請求則會建立新的執行個體，該bean執行個體僅在目前Session内有效。

<bean id="userPreference" class="com.ioc.UserPreference" scope="session"/>,同Http請求相同，每一次session請求建立新的執行個體，而不同的執行個體之間不共享屬性，且執行個體僅在自己的session請求内有效，請求結束，則執行個體将被銷毀。

global Session：在一個全局的Http Session中，容器會傳回該Bean的同一個執行個體，僅在使用portlet context時有效。

Bean的生命周期

　　經過如上對Bean作用域的介紹，接下來将在Bean作用域的基礎上講解Bean的生命周期。

Spring容器可以管理singleton作用域下Bean的生命周期，在此作用域下，Spring能夠精确地知道Bean何時被建立，何時初始化完成，以及何時被銷毀。而對于prototype作用域的Bean，Spring隻負責建立，當容器建立了Bean的執行個體後，Bean的執行個體就交給了用戶端的代碼管理，Spring容器将不再跟蹤其生命周期，并且不會管理那些被配置成prototype作用域的Bean的生命周期。Spring中Bean的生命周期的執行是一個很複雜的過程，讀者可以利用Spring提供的方法來定制Bean的建立過程。Spring容器在保證一個bean執行個體能夠使用之前會做很多工作

資料庫篇

JDBC連接配接資料庫步驟(以MYSQL為例)

1、加載JDBC驅動程式：

通過Class類的forName方法實作，并将驅動位址放進去

成功加載後，會将Driver類的執行個體注冊到DriverManager類中。

2、提供JDBC連接配接的URL 、建立資料庫的連接配接

•要連接配接資料庫，需要向java.sql.DriverManager請求并獲得Connection對象，

該對象就代表一個資料庫的連接配接。

•使用DriverManager的getConnectin()方法傳入指定的欲連接配接的資料庫的路徑、數據庫的使用者名和密碼。

Connection con=DriverManager.getConnection(url , username , password);

&&&:"jdbc:mysql://localhost/test?user=root&password=123&useUnicode=true&characterEncoding=utf-8”;

3、建立一個Statement

•要執行SQL語句，必須獲得java.sql.Statement執行個體

•執行靜态SQL語句。通常通過Statement執行個體實作。

•執行動态SQL語句。通常通過PreparedStatement執行個體實作。

String sql = “”;

Statement st = con.createStatement() ;

PreparedStatement pst = con.prepareStatement(sql) ;

4、執行SQL語句

Statement接口提供了executeQuery、executeUpdate、execute三種方法

executeQuery：執行select語句，傳回ResultSet結果集

ResultSet rst = pst.executeQuery();

• executeUpdate：執行insert、update、delete語句

pst.executeUpdate();

5、關閉JDBC對象

操作完成以後要把所有使用的JDBC對象全都關閉，以釋放JDBC資源。

資料庫連接配接池

資料庫連接配接池的優點運作原理:

在我們不使用資料庫連接配接池的時候，每次通路資料庫都需要建立連接配接，

使用完成之後需要釋放關閉連接配接，而這樣是很耗費資源的。當我們使用

資料庫連接配接池的時候，在tomcat啟動的時候就建立了指定數量的連接配接，

之後當我們程式使用的時候就直接從連接配接池裡面取，而不需要建立，同理，

當我們使用完的時候也不需要關閉連接配接，而是将連接配接傳回到連接配接池中，供

其他請求繼續使用。

DBCP：比較穩定。

C3P0: 性能比較高。

mysql的資料庫導入導出

配置：

首先找到mysql的安裝目錄，進入bin目錄下複制路徑

将mysql的bin目錄粘貼在計算機環境變量的path中

授權：

登入mysql

将某張表的某個權限賦給某個使用者

grant [select,insert,update,delete,create,drop] on [databaseName].[tableName] to [userName]@[userIP] identified by [‘連接配接密碼’]

grant select,insert,update,delete,create,drop on oa_ssh.user to root@[IP] identified by 'root';

将所有庫的所有權限賦給某個使用者

grant all privileges on *.* to [userName]@[userIp] identified by [‘連接配接密碼’]

grant all privileges on *.* to root@[IP] identified by ‘root';

将所有庫的所有權限賦給所有使用者

grant all privileges on *.* to root@'%' identified by ‘root’;

　　　　導出本地資料庫：

mysqldump -u 使用者名 -p 資料庫名 > 磁盤：導出的檔案名(加字尾)

　　　　遠端導出資料庫：

mysqldump -h IP -u 使用者名 -p 資料庫名稱 >導出的檔案名(加字尾)

　　　　遠端導出資料表：

mysqldump -u root -p -d --add-drop-table 資料庫名稱 > 導出檔案

名(加字尾)

　　　　導入資料：

mysql -u root -p登入成功後 ==》 source 磁盤：導入的檔案名(加字尾)

jdbc分段批量送出的時候出現異常怎麼處理?

通過Map來解決性能問題。首先在分段批量送出的時候，我們不采用事務，這樣就保證了合法的資料就自動送出，不合法的資料就自己自動進行復原，為了避免不合法資料影響後續合法資料的送出，采用定義業務規則字典表，實作對資料的驗證，将不合法的資料記錄下來，供使用者進行後續處理，而合法的資料就全部送出。

jdbc批量處理資料

批量處理資料:(代碼優化:提高程式執行性能)

降低了java程式代碼(用戶端)和資料庫之間的網絡通信的次數。

在jdbc中進行批量插入的核心API為 addBatch,executeBatch

大資料量的插入問題:（jdbc,hibernate,ibatis）

1.每次隻插入一條和資料庫互動多次(很耗時間)

2.批量插入和資料庫隻互動一次(記憶體溢出)

3.分段批量插入(推薦)

jdbc批量處理資料是通過PreparedStatement對象的 addbatch(), executebatch（） clearbatch()進行和資料庫的互動。通常我們使用分段批量處理的方式這樣可以提高程式的性能，防止記憶體溢出。

1.每個sql語句都和資料庫互動一次(非批量操作)

2.隻和資料庫互動一次(批量操作)(記憶體溢出)

　當資料達到一定額度的時候就和資料庫進行互動，分多次進行(分段批量操作)

(500或者1000)

pst.addBatch();

if (i > 0 && i%1000 == 0) {

pst.executeBatch();

pst.clearBatch();

}

Oracle分頁

select * from (select * from (select s.*,rownum rn from student s ) where rn<=5) where rn>0

Oracle的基本資料類型

Oracle的基本資料類型（常用）：

1、字元型

Char 固定長度字元串占2000個位元組

Varchar2 可變長度字元串占4000個位元組

Nvarchar2 占2000個字元（最多能存2000個字母/中文）

2、大對象型（lob）

Blob ：二進制資料最大長度4G

Blob 用于存一些圖檔，視訊，檔案。

比如：當我們在進行檔案上傳時，我們一般把上傳的檔案存在硬碟上，可以不占用資料庫，下載下傳時，如果項目遷移時，檔案也要跟着遷移。是以我們可以把用blob把它存在資料庫中。但這樣也增加了資料庫的負擔。

Clob ：字元資料最大長度4G，可以存大字元串 varchar2和nvarchar2都具有一定的局限性，它們長度有限，但資料庫中無論用varchar2或nvarchar2類型，還是用clob，在java端都使用String接收。

3、數值型

Integer 整數類型，小的整數。

Float 浮點數類型。

Real 實數類型。

Number（p,s）包含小數位的數值類型。P表示精度，s表示小數後的位數。

Eg: number(10,2) 表示小數點之前可有8位數字，小數點後有2位。

4、日期類型

Date 日期（日-月-年） DD-MM-YY(HH-MI-SS)

Timestamp 跟date比它可以精确到微秒。精确範圍0~9 預設為6.

id、rowid、rownum的差別

rowid實體位置的唯一辨別。

而id是邏輯上的唯一辨別，是以rowid查找速度要快于id,是目前最快的

定位一條記錄的方式

rowid和rownum都是"僞數列"

所謂“僞數列”也就是預設隐藏的一個數列。

rownum用于标記結果集中結果順序的一個字段，

它的特點是按順序标記，而且是連續的，

換句話說就是隻有有rownum=1的記錄，才可能有rownum=2的記錄。

rownum關鍵字隻能和<或者<=直接關聯

如果是>或者=則需要給他起個别名

主鍵和唯一索引的差別？

在建立主鍵的同時會生成對應的唯一索引，主鍵在保證資料唯一性的同時不允許為空，而唯一可以有一個為空資料項，一個表中隻能有一個主鍵，但是一個主鍵可以有多個字段，一個表中可以有多個唯一索引。

Preparedstatement和statement的差別

用Prepared statement進行開發。Prepared statement是預編譯的，而statement不是，在每次執行sql語句的增删改時，如果是一條資料兩者沒差距，但如果資料量大于1，那麼每次執行sql語句statement都要重新編譯一次，而Prepared statement不用，Prepared statement的運作效率大于statement；從代碼的可維護性和可讀性來說，雖然用Prepared statement來代替statement會使代碼多出幾行，但這樣的代碼無論從可讀性還是可維護性來說，都比直接使用statement的代碼高很多檔次；最重要的一點，從安全角度來說，使用Prepared statement可以大大提高程式的安全性，因為Prepared statement是用‘？’傳參,可以防止sql注入，具有安全性，而statement用的是‘+’字元串拼接，安全性較低。

資料庫三範式

第一範式：資料庫表中的所有字段值都是不可分解的原子值。

第二範式：需要確定資料庫表中的每一列都和主鍵相關，而不能隻與主鍵的某一部分相關（主要針對聯合主鍵而言）

第三範式：需要確定資料表中的每一列資料都和主鍵直接相關，而不能間接相關

視圖概述

視圖可以視為“虛拟表”或“存儲的查詢”

建立視圖所依據的表稱為“基表”

視圖的優點：

提供了另外一種級别的表安全性:隐藏了一些關鍵的字段

簡化的使用者的SQL指令

隔離基表結構的改變

存儲過程概述

存儲過程（Stored Procedure）

　　可以包含邏輯判斷的sql語句集合。

　　是經過預編譯，存在于資料庫中。

　　通過調用指定存儲過程的名字（可有參，可無參）來執行。

優點：

　　簡化了複雜的業務邏輯，根據需要可重複使用

　　屏蔽了底層細節，不暴露表資訊即可完成操作

　　降低網絡的通信量，多條語句可以封裝成一個存儲過程來執行

　　設定通路權限來提高安全性

　　提高執行效率，因為它是預編譯以及存儲在資料庫中

缺點：

　　可移植性差，相同的存儲過程并不能跨多個資料庫進行操作

　　大量使用存儲過程後，首先會使伺服器壓力增大，而且維護難度逐漸增加

存儲過程的文法：

--下面是在oracle資料庫下最基本的文法

--僅建立一個名為testProcedure 的無參的存儲過程

--IS也可以是AS

--如果已經存在名為 testProcedure 的存儲過程，下面的文法會出現名稱已被使用的錯誤

--解決辦法：

--第一句可以寫成 create or replace procedure testProcedure

--這樣會替換原有的存儲過程

--NULL表示任何可以正确執行的sql 語句，但至少一句

create procedure testProcedure

BEGIN

NULL

END;

存儲過程的參數的分類:

OUT

INOUT

注意：

　　存儲過程之間可互相調用

　　存儲過程一般修改後，立即生效。

索引概述

1、索引的概念

索引就是加快查詢表中資料的方法。

資料庫的索引類似于書籍的索引。

在書籍中，索引允許使用者不必翻閱完整個書就能迅速地找到所需要的資訊。

在資料庫中，索引也允許資料庫程式迅速地找到表中的資料，

而不必掃描整個資料庫.

2、索引的優點

1.建立唯一性索引，保證資料庫表中每一行資料的唯一性

2.大大加快資料的檢索速度，這也是建立索引的最主要的原因

3.減少磁盤IO（向字典一樣可以直接定位）

3、索引的缺點

1.建立索引和維護索引要耗費時間，這種時間随着資料量的增加而增加

2.索引需要占用額外的實體空間

3.當對表中的資料進行增加、删除和修改的時候，

索引也要動态的維護，降低了資料的維護速度

4、索引的分類

1.普通索引和唯一性索引

普通索引：CREATE INDEX mycolumn_index ON mytable (myclumn)

唯一性索引：保證在索引列中的全部資料是唯一的

CREATE unique INDEX mycolumn_index ON mytable (myclumn)

2. 單個索引和複合索引

單個索引：對單個字段建立索引

複合索引：又叫組合索引，在索引建立語句中同時包含多個字段名，

最多16個字段

CREATE INDEX name_index ON userInfo(firstname,lastname)

3.順序索引，散列索引,位圖索引

必背的sql語句

一：oracle 分頁

select * from (select t.*, rownum rn from (select * from menu order by id desc) t where rownum < 10) where rn >=5

二: mysql 分頁

select * from music where id limit 5,5

三：oracle中如何快速将一張表的資料複制到另外一張表中(另外一張表不存在，另外一張表存在，但資料為空)

.不存在另一張表時：

create table 新表 as select * from 将要複制的表

存在另一張表時：

insert into 新表名 select 字段 from 将要複制的表名

四：音樂專輯

查詢出special <app:ds:special>表中的id 專輯名并下面有多少首歌曲

Select s.id , min(s.sname),count(m.mid) from special s inner

join ms m on s.id=m.id group by s.id

五：快速删除一張表（不可事物復原，也就是沒有日志記錄）

TRUNCATE from 表名

六：inner join

select 查找資訊 from 表名 1 inner join 表名2 on 表名1.列名 = 表名2.列名

七：left join

左外連接配接 select 查找資訊 from 表名1 left join 表名2 on 表名1.列名 = 表名2.列名

八：right join

右外連接配接 select 查找資訊 from 表名1 right join 表名2 on 表名1.列名 = 表名2.列名

九：oracle中查詢周遊樹形結構（start with）

select * from extmenu

start with pid=0

connect by prior id = pid

十：查詢出來60-70,80-90,95-100學生的資訊

select * from stu where chengji between 60 and 70 or between 80 and 90 or between 95 and 100

select * from stu where chengji > 60 and chengji < 70 or chengji > 80 and chengji < 90 or chengji > 95 and chengji < 100

十一：用exists替換in------進行聯表查詢

select * from dept where exists(select * from emp where emp.deptno=dept.deptno);

或

select * from dept d inner join emp e on d.deptno = e.deptno(隻查詢出兩表共同擁有的字段資料)

十二：删除表中的重複資料：

delete from xin a where a.rowid != (

select max(b.rowid) from xin b

where a.name = b.name

);

業務場景篇

Spring的概述

Spring 是完全面向接口的設計，降低程式耦合性，主要是事務控制并建立bean執行個體對象。在ssh整合時，充當黏合劑的作用。IOC(Inversion of Control) 控制反轉/依賴注入，又稱DI(Dependency Injection) (依賴注入)

IOC的作用：産生對象執行個體，是以它是基于工廠設計模式的

Spring IOC的注入

通過屬性進行注入，通過構造函數進行注入，

注入對象數組注入List集合

注入Map集合注入Properties類型

Spring IOC 自動綁定模式：

可以設定autowire按以下方式進行綁定

按byType隻要類型一緻會自動尋找，

按byName自動按屬性名稱進行自動查找比對.

AOP 面向方面（切面）程式設計

AOP是OOP的延續，是Aspect Oriented Programming的縮寫，

　　　　意思是面向方面(切面)程式設計。

注：OOP(Object-Oriented Programming ) 面向對象程式設計

AOP 主要應用于日志記錄，性能統計，安全控制,事務處理（項目中使用的）等方面。

Spring中實作AOP技術：

在Spring中可以通過代理模式來實作AOP

代理模式分為

靜态代理：一個接口，分别有一個真實實作和一個代理實作。

動态代理：通過代理類的代理，接口和實作類之間可以不直接發生聯系，而可以在運作期（Runtime）實作動态關聯。

動态代理有兩種實作方式，可以通過jdk的動态代理實作也可以通過cglib

來實作而AOP預設是通過jdk的動态代理來實作的。jdk的動态代理必須要有

接口的支援，而cglib不需要，它是基于類的。

Spring AOP事務的描述：

在spring-common.xml裡通過<aop:config>裡面先設定一個表達式，設定對service裡那些方法如：對add* ,delete*,update*等開頭的方法進行事務攔截。我們需要配置事務的傳播（propagation="REQUIRED"）特性,通常把增,删,改以外的操作需要配置成隻讀事務（read-only="true"）.隻讀事務可以提高性能。之後引入tx:advice,在tx:advice引用 transactionManager（事務管理）,在事務管理裡再引入sessionFactory,sessionFactory注入 dataSource，最後通過<aop:config> 引入txAdvice。

Spring實作ioc控制反轉描述：

原來需要我們自己進行bean的建立以及注入，而現在交給

spring容器去完成bean的建立以及注入。

所謂的“控制反轉”就是對象控制權的轉移，

從程式代碼本身轉移到了外部容器。

官方解釋:

控制反轉即IoC (Inversion of Control)，

它把傳統上由程式代碼直接操控的對象的調用權交給容器，

通過容器來實作對象元件的裝配和管理。

所謂的“控制反轉”概念就是對元件對象控制權的轉移，

從程式代碼本身轉移到了外部容器。

事務概述

在資料庫中,所謂事務是指一組邏輯操作單元即一組sql語句。當這個單元中的一部分操作失敗,整個事務復原，隻有全部正确才完成送出。

事務的ACID屬性

1. 原子性（Atomicity）

原子性是指事務是一個不可分割的工作機關，事務中的操作要麼都發生，

要麼都不發生。

2. 一緻性（Consistency）

事務必須使資料庫從一個一緻性狀态變換到另外一個一緻性狀态。(資料不被破壞)

3. 隔離性（Isolation）

事務的隔離性是指一個事務的執行不能被其他事務幹擾.

4. 持久性（Durability）

持久性是指一個事務一旦被送出，

它對資料庫中資料的改變就是永久性的.

在JDBC中，

事務預設是自動送出的，

每次執行一個 SQL 語句時，如果執行成功，

就會向資料庫自動送出，而不能復原

為了讓多個 SQL 語句作為一個事務執行：

（1）執行語句前調用 Connection 對象的 setAutoCommit(false);

以取消自動送出事務

（2）在所有的 SQL 語句都成功執行後，調用 commit(); 方法送出事務

（3）在出現異常時，調用 rollback(); 方法復原事務。

權限概述

權限涉及到5張表：

使用者表，角色表，權限表(菜單表)，使用者角色關聯表，角色權限關聯表

當使用者登入時，根據使用者名和密碼到使用者表驗證資訊是否合法，如果合法

則擷取使用者資訊，之後根據使用者id再到使用者角色關聯表中得到相關連的角色

id集合,之後根據角色id再到角色權限關聯表中擷取該角色所擁有的權限id集合，

然後再根據權限id集合到權限表（菜單表）中擷取具體的菜單，展現給目前

登入使用者，進而達到不同用使用者看到不同的菜單權限。

我們通過ZTree來給角色賦權并且通過ZTree來展示菜單，以及通過ZTree來管理菜單即增加和編輯菜單。

我們做的權限控制到url級别,為了防止使用者不登入直接輸入url通路的這個弊端，通過攔截器進行攔截驗證。

OSCache業務場景

在我以前的項目中，我們考慮了系統性能問題，這個時候我們采用了Oscache緩存，剛開始把這個功能交給了項目組中的另外一個同僚來做的，但是他做完的時候他發現緩存中明明已經緩存了資料，但是在取得時候發現沒有資料，我們項目經理讓我去幫忙看看這個問題，我閱讀完他的代碼之後，我發現了他每次緩存的時候都是調用一個新的緩存對象的方法，結果出現了明明已經走了緩存的方法而取不到資料的問題，通過我多年的工作經驗，我就想到了應該用單例模式去封裝一個單例工具類來調用oscache。但是，在後來的測試過程中，發現當并發通路的時候也會出現上述的問題，這個時候我直接采取的DCL（雙重判定鎖）單例模式封裝了工具類，既解決了線程安全問題，相對的性能問題也考慮到了，這個問題才得到了完善的解決。

線程概述

線程的狀态以及狀态之間的互相轉換：

1、建立狀态(New)：新建立了一個線程對象。

2、就緒狀态(Runnable)：線程對象建立後，其他線程調用了該對象的start()方法。該狀态的線程位于可運作線程池中，變得可運作，等待擷取CPU的使用權。

3、運作狀态(Running)：就緒狀态的線程擷取了CPU，執行程式代碼。

4、阻塞狀态(Blocked)：阻塞狀态是線程因為某種原因放棄CPU使用權，暫時停止運作。直到線程進入就緒狀态，才有機會轉到運作狀态。阻塞的情況分三種：

(一)、等待阻塞：運作的線程執行wait()方法，JVM會把該線程放入等待池中。

(二)、同步阻塞：運作的線程在擷取對象的同步鎖時，若該同步鎖被别的線程占用，則JVM會把該線程放入鎖池中。

(三)、其他阻塞：運作的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀态。當sleep()狀态逾時、join()等待線程終止或者逾時、或者I/O處理完畢時，線程重新轉入就緒狀态。

5、死亡狀态(Dead)：線程執行完了或者因異常退出了run()方法，該線程結束生命周期。

實作線程的兩種方式：

是繼承Thread類或實作Runnable接口，但不管怎樣，當new了這個對象後，線程就已經進入了初始狀态

wait和sleep的差別：

線程通路：

鎖池狀态，之後等待鎖釋放，然後通路代碼

wait

等待隊列(釋放資源)--->調用notify或者notifyall之後鎖池狀态--->( 等待鎖釋放)--->可運作狀态--->運作狀态---->通路代碼

sleep,join

不釋放資源-->結束後直接進入可運作狀态--->運作狀态---->通路代碼

一個java控制台程式，預設運作兩個線程，一個主線程，一個垃圾回收線程。

線程與程序的差別：

1.線程(Thread)與程序(Process)

2.一個程序可以包括若幹個線程，同時建立多個線程來完成某項任務，便是多線程。

Ajax請求Session逾時問題

我在做項目時有時會遇到session逾時問題，如果session逾時，平常請求沒有什麼問題，通過攔截器可以正确跳到登陸頁面，可是你如果用ajax請求的話這就出現問題了，因為ajax是異步的，局部重新整理，是以登陸界面不會再全頁面中顯示，他隻會顯示到頁面的一部分當中。是以根據我這幾年的經驗找到了我認為比較好的一種方法。因為那我用的架構是和struts2內建的，是以就在攔截器中進行設定：

首先判斷session是否為空就是判斷session是否逾時，如果逾時就取出請求的head頭資訊request.getHeader("x-requested-with")，如果不為空就和XMLHttpRequest(Ajax辨別)進行比較 (request.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest"))) 如果相等說明此請求是ajax請求。

如果是ajax請求就可以用response.setHeader("鍵","值")來設定一個辨別來告訴使用者這是ajax請求并且session逾時時發出的，這樣我就可以在回調函數中取出自己設定的那個唯一辨別：XMLHttpRequest.getResponseHeader("");如果取出的值是和自己在背景中設定的值一樣的話，就證明session已經逾時，這樣就可以設定window.location.replace("登陸界面")，來跳轉到登陸界面了。

這樣做雖然解決了問題，但是，會在每個回調函數中寫入那些代碼，這樣的話代碼就會顯得特别零散，是以就想能不能定義一個全局的設定是以就找到了jqery的ajaxSetUp方法，通過ajaxSetUp對jqery的ajax進行全局的判斷(ajaxSetUp就相當于ajax的攔截器)，通過設定ajaxSetUp裡的complete，它就相當于回調函數，這樣那就彌補了上一方法的不足。

我做項目時還用到$(document).ajaxStart()，這是ajax請求時的事件；$(document).ajaxSuccess()，這是AJAX請求成功後的事件。我一般用他們來顯示遮罩層和隐藏遮罩層用的加遮罩層是為了不讓使用者重複送出，更提高了使用者體驗度，讓使用者知道已經送出了。

七：java線程池概述

ava線程池的工作原理和資料庫連接配接池的差不多，因為每次重新建立線程

都是很耗資源的操作，是以我們可以建立一個線程池，這樣當需要用到線程

進行某些操作時，就可以直接去線程池裡面找到空閑的線程，這樣就可以直接

使用，而不用等到用到的時候再去建立，用完之後可以把該線程重新放入線程池

供其他請求使用進而提高應用程式的性能。

OSCache概述

oscache是一個高性能的j2ee架構，可以和任何java代碼進行內建，并且還可以通過标簽對頁面内容進行緩存，還以緩存請求。

我們通常将那些頻繁通路但是又不是經常改變的資料進行緩存。為了保證緩存資料的有效性，在資料發生改變的時候，我們要重新整理緩存，避免髒資料的出現。重新整理緩存的政策有兩種，一種是定時重新整理，一種手動重新整理。

緩存資料的時機通常也分為兩種，即在tomcat(web容器)啟動時候加載資料進行緩存，另外也可以在使用者第一次通路資料的時候進行緩存，這個相當于緩存的立即加載和按需加載。

緩存的層次如下:jsp-->action-->service-->dao,緩存越靠前對性能的提升越大

一個action裡面可以有多個service,一個service中可以有多個dao或者多個service

任何類之間都可以進行互相調用，可以通過構造函數傳參，set,get傳參或者是方法傳參将相關的類連接配接起來。

OSCache+autocomplete+單例業務場景

在我以前做某項目的過程中，其中我們在做産品清單的查詢的時候為了提高使用者的體驗度，我們使用了autocomplete插件來代替select進行品牌的選擇，才開始的時候每次都要根據使用者輸入的資訊去查詢資料庫進行模糊比對傳回結果，後來我們考慮到系統的性能，是以我們采用了oscache緩存，才開始這個功能是交給我們項目組中的另外一個同僚來做的，但是他做完後，我們在使用這個工具類的時候，發現有時緩存中明明已經有時我們需要的資料，但是從緩存裡面取的時候，發現沒有，之後項目經理讓我去幫這個同僚看看這個問題，我經過閱讀他的代碼發現，它裡面在使用緩存的時候，針對于每次方法的調用都産生一個新的執行個體，結果導緻了上面的問題，這個時候我想起了可以使用設計模式中的單例模式來解決這個問題，才開始我直接采用了普通的單列模式，但是後來在測試的過程中，發現當使用者并發量大的時候還是會出現上面的問題，之後我再次考慮了代碼，最後發現是因為沒有給單列模式加鎖的原因，進而導緻了大使用者并發的時候，線程安全的問題，之後我便在方法上加上了synchronized關鍵字，解決上述的問題，但是後來測試人員回報，覺的這段的性能有問題，我考慮之後便采用在方法體内加鎖并結合雙重判定的方式解決了上面的問題。我們是将資料在tomcat啟動的時候加載到緩存中，之後使用者進行查詢的時候直接從緩存中擷取資料，根據字首比對進行查詢，将結果傳回給使用者。這樣在提高使用者體驗度的同時也提高性能。

緩存概述

應用程式為了提高性能，可以通過使用緩存來達到目的，緩存的存儲媒體可以記憶體或者硬碟，通常将資料存儲在記憶體裡，确切的說是jvm的記憶體中，緩存是基于Map這種思想建構的，以鍵值對的方式進行存儲和擷取，之是以還可以将緩存的資料存儲在硬碟中，是因為記憶體資源相當有限和寶貴，是以當記憶體資源不足的時候，就可以将其存儲到硬碟中，雖然硬碟的存取速度比記憶體要慢，但是因為減少了網絡通信量，是以還是提高程式的性能。緩存可以分為用戶端緩存和伺服器端緩存，所謂的用戶端緩存通常指的是IE浏覽器的緩存，伺服器端緩存指的web伺服器的緩存，通常可以通過第三方元件實作，如oscache,memcache。

實作頁面靜态化業務場景

我們在做某項目時，涉及到程式通路的性能問題，這時候我們想到可以通過靜态化來提高使用者通路時候的性能，是以我們就采用了freemarker模闆引擎，考慮到頁面也是要有動态的變化的，是以我們采用spring定時器在每天晚上2點鐘的時候定時再次生成html靜态頁面，考慮釋出時候的性能問題，我們又采取線程池技術，讓多個線程同時釋出，進而縮減釋出時間。

servlet線程安全描述

servlet是單列的，對于所有請求都使用一個執行個體，是以如果有全局變量被多

線程使用的時候，就會出現線程安全問題。

解決這個問題有三種方案:

1.實作singleThreadModel接口，這樣對于每次請求都會建立一個新的servlet執行個體，這樣就會消耗服務端記憶體，降低性能，但是這個接口已經過時，不推薦使用。

2.可以通過加鎖(synchroniezd關鍵字)來避免線程安全問題。這個時候雖然還是單列，但是對于多線程的通路，每次隻能有一個請求進行方法體内執行，隻有執行完畢後，其他線程才允許通路，降低吞吐量。

3.避免使用全局變量，使用局部變量可以避免線程安全問題，強烈推薦使用此方法來解決servlet線程安全的問題。

(jbpm4)工作流引擎描述:

JPBM是JBOSS旗下的一個開源的基于hibernate的工作流引擎。工作流就是在日常生活中，我們一些常見的如請假流程、采購流程、入職流程，通俗的來講就是一些在現實生活中的流程以資訊化以程式的方式實作。

一個工作流首先需要進行流程定義，流程定義是由節點和跳轉組成的，節點又可以稱為環節、活動節點、活動環節，并且節點也可以分為兩大類型：人工節點和自動節點，人工節點有start開始節點、end結束節點、task任務節點，自動節點有decision判斷節點、fork分支節點、join聚合節點和state狀态節點，并且一個流程有且隻有一個開始節點，但可以有多個結束節點。

流程定義是靜止的，它在運作狀态時會轉換成流程執行個體，一個流程定義可以對應多個流程執行個體。流程運作後，會産生兩個檔案，*.jdpl.xml檔案和*.png圖檔檔案，也會生成18張資料庫表，常用且核心的表有JBPM4_LOB 存儲表，主要存儲xml檔案和png圖檔、JBPM4_TASK 任務表、JBPM4_EXECUTION 流程執行個體表、JBPM4_VARIABLE變量表。

JBPM有五大核心類：

ProcessEngine：主要擷取各種的Service

RepositoryService：主要釋出流程定義

ExecutionService：主要操作流程執行個體

TaskService：主要操作人工服務

HistoryService：主要操作曆史服務。

核心方法：

讀取jbpm定義的檔案生成zip包存到lob表中：createDeployment()

擷取流程定義清單：createProcessDefinitionQuery

根據定義的key或id來啟動流程執行個體：startProcessInstanceByKey(id)

擷取待辦任務清單：findPersonalTasks(userName)

完成指定任務清單：completeTask(*.getActivityId())

擷取曆史任務清單：createHistoryTaskQuery()

擷取流程執行個體的ID：task.getExecutionId()

(了解的表)

JBPM4_HIST_ACTINST 流程活動(節點) 執行個體表

JBPM4_HIST_DETAIL 流程曆史詳細表

JBPM4_HIST_PROCINST 流程執行個體曆史表

JBPM4_HIST_TASK 流程任務執行個體曆史表

JBPM4_HIST_VAR 流程變量( 上下文) 曆史表

JPBM業務場景

首先進行請假的流程定義，我們流程的定義是（員工送出請假單---》經理審批---》總監審批---》總經理審批---》結束），通過repositoryService将其釋出部署到jbpm4_lob表中，

之後擷取流程定義清單，選中請假的流程定義，員工開始進行請假單的填寫，儲存并通過executionService開啟流程執行個體，然後用taskService擷取經理的待辦任務清單，選中待辦任務，進行審批，通過調用taskService.completeTask()進入到總監審批環節，然後用總監進行登入，同樣擷取待辦任務清單，然後調用taskService.completeTask()進入總經理審批環節，總經理審批之後，結束流程。在這個過程中我們還可以根據historyService檢視目前登入人已辦的任務清單。

Ant描述

Ant是apache旗下的對項目進行自動打包、編譯、部署的建構工具，他主要具有輕量級并且跨平台的特性，而且基于jvm，預設檔案名為build.xml

Ant主要的标簽：

Project 根标簽，

target 任務标簽，

property 屬性标簽，自定義鍵/值供多次使用，

java 執行編譯後的java檔案

javac 編譯java檔案

war 打成war包

其它标簽：copy，delete，mkdir，move，echo等。

FreeMarker描述

FreeMarker是一個用Java語言編寫的模闆引擎，它是基于模闆來生成文本輸出的通用工具。Freemarker可以生成HTML， XML，JSP或Java等多種文本輸出。

工作原理：定義模闆檔案，嵌入資料源，通過模闆顯示準備的資料

（資料 + 模闆 = 輸出）

　　我們在使用模闆中發現freemarker具有許多優點，它徹底的分離表現層和業務邏輯，模闆隻負責資料在頁面中的表現，不涉及任何的邏輯代碼，是以使得開發過程中的人員分工更加明确，作為界面開發人員，隻需專心建立HTML檔案、圖像以及Web頁面的其他可視化方面，不用理會資料；而程式開發人員則專注于系統實作，負責為頁面準備要顯示的資料。

如果使用jsp來展示，開發階段進行功能調适時，需要頻繁的修改JSP，每次修改都要編譯和轉換，浪費了大量時間，FreeMarker模闆技術不存在編譯和轉換的問題，在開發過程中，我們在不必在等待界面設計開發人員完成頁面原型後再來開發程式。由此使用freemarker還可以大大提高開發效率。

webService描述

webservice是SOA（面向服務程式設計）的一種實作，主要是用來實作異構平台通信也就是不同平台不同項目之間的資料傳輸，進而避免了資訊孤島的問題，它之是以能夠

進行異構平台通信是因為它是完全基于xml的，是以說，webService是跨平台，

跨語言，跨架構的。

webservice的三要素分别是：

wsdl（webservice description language）用來描述釋出的接口（服務）

soap(simple object access protocol) 是xml和http的結合，是webservice資料通信

的協定

uddi（univers）用來管理,分發,查詢webService的服務

webservice的具體三種實作方式（架構）

1. Axis2:可以用多種語言開發（java c c++ C#），是一個重量級架構，功能非常強大，是以說涉及到的api非常多，是以說它的性能比較慢。

2. Xfire：它相比Axis2來說是一個輕量級架構，但是它的性能要比Axis2高， Api也相對少。

3. cxf：是Xfire的更新版，就好比是，struts2是webwork的更新，人們會逐漸淡忘webwork,但是struts2會慢慢變成主流。然而cxf就好比是struts2，會成為主流技術。然後cxf和spring內建起來非常友善，簡易，性能方面也要比Xfire高。

【注】jdk6 自帶的webservice jws

業務場景

我在以前做項目的時候，其中遇到一個功能，需要進行兩個項目之間的資料的傳輸，

項目經理讓我去完成這個任務，我根據以往的項目經驗，想到兩種解決方案，第一種

就是開放另外一個項目的資料庫的權限給我，然後我直接通過通路另外一個項目的資料

庫，來得到需要的資訊，但後來我分析了下，覺的這種方式不安全，而且因為當時

這個項目是另外一家公司負責在做，是以資料庫裡面的表結構，以及以後牽涉

到的責任問題都很多，是以我就采用了第二種方案，即通過webservices的方式，進行

異構系統之間資料資訊的傳遞，webservices的具體實作，有xfire,cxf,axis2,

我根據以往的項目經驗，了解到cxf是xfire的更新版本，适用于java語言，

xfire/cxf 性能比axis2要高，并且和spring整合起來也比較友善，而axis2支援更多的語言，性能相對于cxf要低，通過上面分析，結合我們目前的兩個項目都是基于java 語言的，是以我采用cxf這種方式實作了兩個項目之間資料的傳遞，我們為了保證 webservice的安全性我們采用了基于WS-Security标準的安全驗證(使用CXF回調函數)。

webservice服務端配置流程

首先在web.xml中引入cxfServlet核心類，指定對以/cxf開頭的url路徑提供webservice服務，之後我們在要釋出成webservice接口上添加@Webservice 注解，而且還要在實作類上添加同樣的webservice注解并且要說明實作了哪個接口，之後在spring-webservice.xml中釋出webservice服務，通過jaxws:endpoint這個标簽，并且在标簽配置implementor和address來表明實作服務的類，以及釋出的位址，最後在浏覽器中輸入相關的webservice位址?wsdl來驗證服務是否釋出成功。

webservice用戶端的配置

首先通過wsdl2java根據釋出的webservice服務端位址的wsdl生成用戶端調用的中間橋梁java類，将生成的java類拷貝到用戶端項目中，配置spring-client.xml檔案，通過jaxws:client定義一個bean,并通過address屬性指明要通路的webservice的服務位址，通過serviceClass指明充當中間橋梁的服務類，之後擷取該bean,就可以通過它來通路釋出的webservice接口中的方法。

oracle索引概述

索引呢是與表相關的一個可選結構，可以提高sql語句的檢索效率，相當于我們的字典目錄，可以快速進行定位，是以可以減少磁盤I/O, 但是因為索引在實體與邏輯上都是獨立于表的資料它會占用一定的實體空間(額外磁盤空間) 是以并不是索引越多越好,而我們應該根據業務需求去建立索引,而且進行增删改操作時 oracle又要自動維護索引是以在一定程度上也降低了維護速度，而且我們在建立索引和維護索引要耗費時間，這種時間随着資料量的增加而增加，我們一般建立索引呢是這樣建立的 create index 索引名 on 表名(字段)，索引又分為普通索引唯一索引(unique) 單個索引複合索引(又叫組合索引，在索引建立語句中同時可包含多個字段名)，順序索引，散列索引,位圖索引。

oracle存儲過程

存儲過程就是封裝一些sql的集合，也就是一條條的sql語句，過程的優點就是簡化了sql指令加上它是預編譯的，是以它的執行效率和性能較高，再者，如果不調用過程的話就要和資料庫發生多次互動，調用過程隻需傳一個指令所有的那些執行邏輯都在資料庫端執行，是以說它降低了網絡的通信量，其次，存儲過程大大提高了安全性，這就是優點

缺點呢，就是不同的資料庫對過程支援的關鍵字支援的關鍵字都是不一樣的，是以它的移植性是非常差的，再者，它的維護性難度也比較大，因為它沒有專業的調試和維護工具，是以說它維護起來比較麻煩，這就是存儲過程的基本概述.

二十、Junit 業務場景

在我們開發項目的時候為了提高代碼的性能和保證邏輯正确性，在我們編寫代碼後往往都要進行單元測試，來驗證代碼，當時我們公司開發人員全部使用的main方法來進行驗證，但是使用mian的最大缺點就是不能将多個類同時進行驗證，驗證的結果不直覺，測試複雜（每個類都要寫main方法，單個運作），一定程度上浪費時間，所有我和項目經理提議使用專業測試工具Junit來進行測試，因為Junit是一個Java語言的單元測試架構，測試簡單，不僅可以提供工作效率和代碼的品質，也提高團隊的合作能力，我提議後我們進行了Junit的教育訓練使用Junit4加注解的方式來測試。

二十一、Apache+Tomcat 實作負載均衡及seesion複制

當我們tomcat通路量大,線程連接配接數不夠時,我們考慮到了tomcat的負載均衡來分擔過多的通路.性能方面負載均衡也能利用多台tomcat來增大記憶體量,

流程,準備工作apache,Jk_mod,tomcat,在apache的conf/httpd.conf檔案中使用include 标簽引入我們自定義的一個mood_jl.conf,在modules中引入下載下傳的k_mod-apache-X.X.XX.so檔案,在其中引入我們的.so,及work.properties檔案,及指定負載配置設定控制器controller,在work.properties檔案中worker.list=controller,tomcat1,tomcat2指定service,worker.tomcat1.port Ajp端口号,type 是ajp,host為指定ip,lbfactor 指定配置設定權重值越大分擔請求越多,worker.controller.type=lbworker.controller.balanced_workers=tomcat1,tomcat2 指定分擔請求的tomcat Session的複制在tomcat中service.xml中Engine标簽加入 jvmRoute 值為work,properties中指定的tomcat名稱,然後打開<Cluster标簽的注釋,最後在應用中程式的web.xml檔案中增加<distributable/>。

二十二、Ant業務場景

Ant是基于java語言編寫的，是以具有跨平台的特性，此外還具有簡潔友善，靈活

配置的特性，是以我就在XX項目中使用ant進行項目的編譯，打包，部署操作。使用ant

之後，如果我們在客戶那裡修改代碼後，就可以直接使用ant進行編譯，打包，部署，而不需要為了編譯，打包，部署專門在客戶那裡安裝eclipse.此外使用ant也可以直接和svn進行互動，下載下傳源碼的同時進行編譯，打包，部署。

二十三、maven業務場景

前段時間在研究maven，知道maven是一個項目管理工具，其核心特點就是通過

maven可以進行包的依賴管理，保證jar包版本的一緻性，以及可以使多個項目共享

jar包，進而能夠在開發大型j2ee應用的時候，減小項目的大小，并且和ant

比起來，maven根據“約定優于配置”的特性，可以對其項目的編譯打包部署進行了

更為抽象的封裝，使得自己不需要像ant那樣進行詳細配置檔案的編寫，直接使用

系統預定好的mvn clean,compile,test,package等指令進行項目的操作。于是我就

在XX項目中采用了maven,為了保證團隊中的成員能夠節省下載下傳jar包所需要的時間，

于是我就采用nexus搭建了在區域網路内的maven私服，然後通過配置settings.xml中

建立mirror鏡像，将所有下載下傳jar包的請求都轉發到maven私服上，之後通過在pom.xml

即(project object model)中配置項目所依賴的jar包，進而達到在建構項目的時候，

先從本地倉庫中查找，如果不存在從内部私服查找，如果不存在最後再從外網central

伺服器查找的機制，達到了節省下載下傳帶寬，提高開發效率，以及jar包重用的目的。

二十四、Servlet的概述：

Servlet是一個web容器，我們通常用的servlet是httpservlet，而httpservlet又是繼承于genericservlet，而genericservlet又實作了servlet接口

servlet的生命周期是：先進行執行個體化，然後是初始化，然後是提高服務，然後銷毀，最後不可用，在這五個生命周期，其中，初始化是調用的init方法，這個方法隻有一個，而提高服務的時候調用的是service方法，而我們具體在我們所寫的這個方法中，因為我們繼承了httpservlet，其實就是對應了doGet（），doPost(),這種方法，然後據我了解，servlet是單例的。非線程安全的，我們通常有一下幾種方案來解決：

第一種，繼承SingleThreadModel但是這樣每次都會建立一個新的servlet執行個體，但這樣消耗伺服器的記憶體，降低了性能，并且這個接口現在已經過時了，不推薦使用。

第二種：我們盡量避免使用全局變量，就我個人而言，我比較喜歡使用這種方法。

第三種，我們可以通過使用ThreadLocal，内部結構是一個Map結構，用目前線程作為key,他會建立多個副本。get,set方法

第四種，我們當然還可以來加鎖，進行解決線程問題。

而且我還知道，向我們這種常用的MVC架構，struts1，spring這些MVC架構，都是基于servlet發展而來的，就比如struts1 的核心總控制器是ActionServlet，而springMVC的前端總控制器是dispatchServlet，在項目我們曾經用serlet來生成圖檔驗證碼的，防止使用者進行暴力破解

（别人問了，再回答）

servlet的配置檔案 web.xml

<servlet-name>ImageCodeServlet</servlet-name> <servlet-class>org.leopard.code.ImageCodeServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>ImageCodeServlet</servlet-name>

<url-pattern>/d</url-pattern>

</servlet-mapping>

描述：

我在web.xml中，我首先需要寫一個servlet标簽，servlet标簽中有兩個子标簽，一個叫servlet-name，這個name可以随便起，但是要保證唯一性，除此之外，在這個servlet-name下有一個servlet-class，這個servlet-class對應的就是我背景提高服務的servlet，除此之外還有一個servlet-mapping，這個裡邊首先有一個servl-name。，這個servl-name首先要保證和上邊的servlet-name保持一緻，除此之外還有一個url-pattern，這是一個虛拟路徑，是用來發送請求的url位址

優化篇

代碼優化

代碼結構層次的優化(目的:更加友善代碼的維護--可維護性，可讀性)

1.代碼注釋(代碼規範)

2.工具類的封裝(友善代碼的維護，使代碼結構更加清晰不臃腫，保證團隊裡代碼品質一緻性)

3.公共部分的提取

代碼性能的優化(目的:使程式的性能最優化)

1.使用一些性能比較高的類(bufferInputStream)

2.緩沖區塊的大小(4k或者8k)

3.公共部分的提取

4.通常要用stringbuffer替代string加号拼接

業務優化

我們做項目的時候業務優化這方面最主要是從使用者體驗度角度進行考慮,減少使用者操作的步驟提高工作效率，通常有以下幾種：

1.可以通過tabindex屬性來改變tab鍵盤的操作順序

2.可以通過Enter鍵來進行搜尋或者送出操作

3.對于單選按鈕和複選按鈕可以通過操作後面的文本來選擇前面的單選按鈕以及複選按鈕

4.添加的資訊要按照id倒序進行排列

5.進行搜尋操作時加入js loading操作（不僅告訴使用者所進行的請求正在被處理，而且防止使用者多次點選送出操作）

6.當進行删除操作的時候要彈出提示框，警告使用者要進行删除操作，是否确認。

7.根據returnURL在使用者登入成功後直接跳到想要通路的資源。

8.進行删除操作時通過confirm提示使用者是否确認删除操作，操作完後提示操作是否成功。

9.減少使用者操作的步驟

10.使用autocomplete插件快速進行搜尋

必背，必做:

1.可以通過Enter鍵來進行搜尋或者送出操作

2.添加的資訊要按照id倒序進行排列

3.進行搜尋操作時加入js loading操作（不僅告訴使用者所進行的請求正在被處理，而且防止使用者多次點選送出操作）

4.當進行删除操作的時候要彈出提示框，警告使用者要進行删除操作，是否确認,如果删除成功則彈出提示框告訴使用者。

5.減少使用者操作的步驟

sql優化

1、SELECT子句中避免使用 *，盡量應該根據業務需求按字段進行查詢

2、盡量多使用COMMIT如對大資料量的分段批量送出釋放了資源，減輕了伺服器壓力

3、在寫sql語句的話，盡量保持每次查詢的sql語句字段用大寫，因為oracle總是先解析 sql語句，把小寫的字母轉換成大寫的再執行

4、用UNION-ALL 替換UNION，因為UNION-ALL不會過濾重複資料，所執行效率要快于UNION,并且UNION可以自動排序，而UNION-ALL不會

5、避免在索引列上使用計算和函數,這樣索引就不能使用

防sql注入

針對防sql注入，我們通常是這樣做的：

首先在前台頁面對使用者輸入資訊進行js驗證，對一些特殊字元進行屏蔽，

比如：or ,單引号，--，= ，還有就是限制使用者名輸入的長度，我們一般

将其限制在6---13位。另外，對于使用者的敏感資訊我們進行Md5加密，還有

，為了增加使用者體驗度和使用者友好度，為了不使使用者看到一些詳細的異常資訊

我們會進行錯誤資訊頁面的定制，像404,500錯誤。另一個我層面講，這樣做

也是為了保護我們的一些重要資訊。此外，我們會給特定的人配置設定定定的權限

，而不是給其配置設定管理者權限！

解決問題篇：

PLSQL連接配接不上本機Oracle：

首先重新配置監聽，如果還不能連接配接，嘗試如下方法：

據ORACLE解釋，在任何作業系統版本都有此問題。

現象：監聽器啟動後，隔一段時間（長短不定），就會出現無法連接配接：若是用10201版本的SQLPLUS，則會出現 NO LISTENER。

9207 版本的SQLPLUS，則會出現：沒反應，HANG住。

原因：10201 版本上的一個BUG：4518443。其會自動建立一個子監聽器，當出現此情況時，監聽器将會挂起。

/opt/oracle/product/10g/network/log/listener.log有如下語句:

WARNING: Subscription for node down event still pending

檢查是否真因為此BUG造成此現象：

$ ps -ef | grep tnslsnr

ora10g 8909 1 0 Sep 15 ? 902:44 /u05/10GHOME/DBHOME/bin/tnslsnr sales -inherit

ora10g 22685 8909 0 14:19:23 ? 0:00 /u05/10GHOME/DBHOME/bin/tnslsnr sales –inherit

正常情況隻有一個監聽器，而此BUG則會出現兩個監聽器。

解決方法：打更新檔4518443 或者在listener.ora 檔案裡加入：

SUBSCRIBE_FOR_NODE_DOWN_EVENT_<listener_name>=OFF

其中，<listener_name> 是資料庫的監聽器的名稱。如：預設情況下，監聽器名為：LISTENER 。則語句就是：

SUBSCRIBE_FOR_NODE_DOWN_EVENT_LISTENER=OFF

重新開機監聽程式

java面試問題總結基礎篇 架構篇 資料庫篇業務場景篇 優化篇解決問題篇：

基礎篇

一、JDK常用的包

八、JQurey總結

十三、JSP9大隐視對象中四個作用域的大小與作用範圍

十七、二分查找法

十八、時間類型轉換

二十、UE和UI的差別

二十一、osi七層模型

二十二、線程和程序的差別

二十三、jvm的記憶體結構

二十四、記憶體洩露和記憶體溢出

二十五、單例

二十六、解析xml檔案的幾種技術

二十七、項目的生命周期

二十八、OSCache的判斷

二十九、經常通路的技術網站

三十、項目團隊中交流的工具

三十一、平時浏覽的書籍

三十二、java Exception體系結構

三十三、session和cookie的差別

三十四、位元組流與字元流的差別

架構篇

十一、Hibernate 中get 和 load的差別

十六、Hibernate中的兩大配置檔案

二十、hibernate緩存概述

資料庫篇

業務場景篇

七：java線程池概述

二十、Junit 業務場景

二十一、Apache+Tomcat 實作負載均衡及seesion複制

二十二、Ant業務場景

二十三、maven業務場景

二十四、Servlet的概述：

優化篇

解決問題篇：

PLSQL連接配接不上本機Oracle：

繼續閱讀

java面試問題總結基礎篇架構篇資料庫篇業務場景篇優化篇解決問題篇：