深圳兩年面試題

目錄2

目錄 １

基礎篇 ４

1、JDK經常使用的包 ４

2、 Get和Post的區別 ４

3、 Java多態的具體體現 ４

4、 StringBuffer StringBuilder String 區別 ５

5、 Hashtable與HashMap的區別 ５

6、 九大隱式對象 ５

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

8、JQurey總結 ６

9、 XML和Json的特色 ６

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

11、 Page和PageContext的區別 ７

12、 Ajax總結 ７

十3、JSP9大隱視對象中四個做用域的大小與做用範圍 ７

十4、 List,Set,Collection,Collections ８

十5、 java的基本數據類型 ８

十6、 冒泡排序 ８

十7、二分查找法 ９

十8、時間類型轉換 ９

十9、 階乘 １０

二10、UE和UI的區別 １０

二11、osi七層模型 １０

二12、線程和進程的區別 １１

二十3、jvm的內存結構 １１

二十4、內存泄露和內存溢出 １１

二十5、單例 １１

二十6、解析xml文件的幾種技術 １２

二十7、項目的生命週期 １３

二十8、OSCache的判斷 １４

二十9、常常訪問的技術網站 １４

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

三11、平時瀏覽的書籍 １４

三12、java Exception體系結構 １５

三十3、session和cookie的區別 １５

三十4、字節流與字符流的區別 １６

三十5、final,finally,finalize 三者區別 １６

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

三十7、JAVA: １８

三十8、JavaSE JavaEE JavaME區別 １８

三十9、JDK  JRE  JVM的區別： １９

四10、報錯的狀態碼： ２０

四11、協議以及默認的端口號 ２０

四12、抽象類與接口的區別 ２０

四十3、修飾符的做用 ２０

框架篇 ２１

1、 Struts1的運行原理 ２１

2、 Struts2的運行原理 ２１

3、 struts2的體系結構 ２１

4、 Spring MVC運行原理 ２２

5、 Struts1.x與Struts2.x的區別 ２３

6、 Spring MVC、struts1和struts2區別 ２３

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

8、 Struts2標籤 ２４

9、 SSI整合 ２４

10、 SSH整合 ２４

10、 Spring MVC整合 ２５

11、Hibernate 中get 和 load的區別 ２５

12、 Hibernate、Ibatis、Jdbc三者的區別 ２５

十3、 Hibernate的運行原理 ２６

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

十5、 Hibernate與JDBC的區別 ２６

十6、Hibernate中的兩大配置文件 ２６

十7、 Hibernate事務處理 ２７

十8、 Hibernate的三種狀態以及狀態的轉換 ２７

十9、 分頁步驟 ２７

二10、hibernate緩存概述 ２７

二11、Ssh的概述： ２８

二12、防止表單重複提交 ２８

二十3、JSP標籤： ２９

二十4、過濾器 ２９

二十5、攔截器的理解 ３０

二十6、Spring融入框架 ３０

數據庫篇 ３１

1、 JDBC鏈接數據庫步驟(以MYSQL爲例) ３１

2、 數據庫鏈接池 ３２

3、 mysql的數據庫導入導出 ３２

4、 jdbc分段批量提交的時候出現異常怎麼處理? ３３

5、 jdbc批量處理數據 ３３

6、 Oracle分頁 ３３

7、 Oracle的基本數據類型 ３３

8、 id、rowid、rownum的區別 ３４

9、 主鍵和惟一索引的區別？ ３４

10、 Preparedstatement和statement的區別 ３５

11、 數據庫三範式 ３５

12、 視圖概述 ３５

十3、 存儲過程概述 ３５

十4、 索引概述 ３６

十5、 必背的sql語句 ３７

業務場景篇 ３９

1、 Spring的概述 ３９

2、 事務概述 ４１

3、 權限概述 ４１

4、 OSCache業務場景 ４２

5、 線程概述 ４２

6、 Ajax請求Session超時問題 ４３

七：java線程池概述 ４３

8、 OSCache概述 ４４

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

10、 緩存概述 ４５

11、 實現頁面靜態化業務場景 ４５

12、 servlet線程安全描述 ４５

十3、 (jbpm4)工做流引擎描述: ４６

十4、 JPBM業務場景 ４７

十5、 Ant描述 ４７

十6、 FreeMarker描述 ４７

十7、 webService描述 ４８

十8、 oracle索引概述 ４９

十9、 oracle存儲過程 ４９

二10、Junit 業務場景 ５０

二11、Apache+Tomcat 實現負載均衡及seesion複製 ５０

二12、Ant業務場景 ５０

二十3、maven業務場景 ５１

二十4、Servlet的概述： ５１

優化篇 ５２

1、 代碼優化 ５２

2、 業務優化 ５２

3、 sql優化 ５３

4、 防sql注入 ５３

 

基礎篇

1、JDK經常使用的包

　java.lang： 這個是系統的基礎類，好比String、Math、Integer、System和Thread， 提供經常使用功能。

　java.io: 這裏面是全部輸入輸出有關的類，好比文件操做等

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

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

　java.sql: 這個是數據庫操做的類，Connection, Statememt，ResultSet等

 

2、Get和Post的區別

1.get是從服務器上獲取數據，post是向服務器傳送數據，

2.get傳送的數據量較小，不能大於2KB。post傳送的數據量較大，通常被默認爲不受限制。

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

4.在進行文件上傳時只能使用post而不能是get。

 

3、Java多態的具體體現 

面向對象編程有四個特徵：抽象，封裝，繼承，多態。

多態有四種體現形式：

1. 接口和接口的繼承。

2. 類和類的繼承。

3. 重載。

4. 重寫。

其中重載和重寫爲核心。

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

法，可是方法的參數類型和個數不同，那麼說明該方法被重

載了。

 

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

類繼承，方法名，返回值類型，參數徹底同樣，可是方法體不

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

 

 

 

 

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.

 

 

5、Hashtable與HashMap的區別

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

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

     HashMap性能優於Hashtable。

 

Map

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

2.HashMap是線程非安全的，HashTable是線程安全的，因此HashMap的效率高於HashTable.

3.HashMap容許鍵或值爲空，而HashTable不容許鍵或值爲空.

 

HashMap是非同步的，沒有對讀寫等操做進行鎖保護，因此是線程不安全的，在多線程場景下會出現數據不一致的問題。而HashTable是同步的，全部的讀寫等操做都進行了鎖（synchronized）保護，在多線程環境下沒有安全問題。可是鎖保護也是有代價的，會對讀寫的效率產生較大影響。

HashMap結構中，是容許保存null的，Entry.key和Entry.value都可覺得null。可是HashTable中是不容許保存null的。

HashMap的迭代器（Iterator）是fail-fast迭代器，可是Hashtable的迭代器（enumerator）不是fail-fast的。若是有其它線程對HashMap進行的添加/刪除元素，將會拋出ConcurrentModificationException，但迭代器自己的remove方法移除元素則不會拋出異常。這條一樣也是Enumeration和Iterator的區別。

 

 

 

6、九大隱式對象

輸入/輸出對象：  request   response   out

做用域通訊對象： session  application  pageContext

Servlet 對象：   page   config

錯誤對象：      exception

 

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

1、從數據共享上

      Forword是一個請求的延續，能夠共享request的數據

      Redirect開啓一個新的請求，不能夠共享request的數據

2、從地址欄

      Forword轉發地址欄不發生變化

      Redirect轉發地址欄發生變化

 

 

8、JQurey總結 

 jquery是一個輕量級的js框架，具備跨瀏覽器的特性，兼容性好，

 而且封裝了不少工具，方便使用。

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

9、XML和Json的特色

 Xml特色：

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

　　2、數據傳輸的載體

　　3、全部的標籤都須要自定義

　　4、是純文本文件

　　

Json（JavaScript Object Notation）特色：

　　json分爲兩種格式:

 

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

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

 

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

（二者間能夠進行相互嵌套）數據傳輸的載體之一

 

區別：

　　傳輸一樣格式的數據，xml須要使用更多的字符進行描述，

    流行的是基於json的數據傳輸。

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

 

共同點：

    xml和json都是數據傳輸的載體，而且具備跨平臺跨語言的特性。

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

getSession()/getSession(true)：當session存在時返回該session，不然新建一個     session並返回該對象

getSession(false)：當session存在時返回該session，不然返回null

 

 

11、Page和PageContext的區別

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

PageContext是做用域通訊對象；一般使用setAttribute()和getAttribute()來設置和獲取存放對象的值。

 

12、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）好。

1. Ajax是基於標準化並被普遍支持的技術，而且不須要插件和下載小程序
2. 同步異步區別

異步：多線程，不會形成阻塞，會繼續執行下面代碼，提高用戶體驗

同步：單線程，會阻塞

sync默認是true:即爲異步方式，$.ajax執行後，會繼續執行ajax後面的腳本，直到服務器端返回數據後，觸發$.ajax裏的success方法

若要將其設置爲false，則全部的請求均爲同步請求，在沒有返回值以前，同步請求將鎖住瀏覽器，用戶其它操做必須等待請求完成才能夠

 

十3、JSP9大隱視對象中四個做用域的大小與做用範圍

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

application：全局做用範圍，整個應用程序共享.生命週期爲：應用程序啓動到中止。

session：會話做用域，當用戶首次訪問時，產生一個新的會話，之後服務器就能夠記              住這個會話狀態。

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

page：一個JSP頁面。

以上做用範圍使愈來愈小， request和page的生命週期都是短暫的，他們之間的區別就是：一個request能夠包含多個page頁(include，forward)。

 

 

十4、List,Set,Collection,Collections

1.List和Set都是接口，他們都繼承於接口Collection,List是一個有序的可重複的集合，而Set的無序的不可重複的集合。Collection是集合的頂層接口，Collections是一個封裝了衆多關於集合操做的靜態方法的工具類,由於構造方法是私有的，因此不能實例化。

 

2.List接口實現類有ArrayList,LinkedList,Vector。ArrayList和Vector是基於數組實現的,因此查詢的時候速度快，而在進行增長和刪除的時候速度較慢LinkedList是基於鏈式存儲結構，因此在進行查詢的時候速度較慢但在進行增長和刪除的時候速度較快。又由於Vector是線程安全的，因此他和ArrayList相比而言，查詢效率要低。

 

三、Set：循環，迭代器，foreach

不容許重複對象，無序，只容許一個 null 元素

若是你想保證插入元素的惟一性，也就是你不想有重複值的出現，那麼能夠選擇一個 Set 的實現類，好比 HashSet、LinkedHashSet 或者 TreeSet

 

十5、java的基本數據類型

數據類型 大小

byte(字節) 1(8位)  -128~127

shot(短整型) 2(16位)

int(整型) 4(32位) 範圍： -2147483648~2147483647

long(長整型) 8(32位)

float(浮點型) 4(32位)

double(雙精度) 8(64位)

char(字符型) 2(16位)

boolean(布爾型) 1位

附加：

 String是基本數據類型嗎?(String不是基本數據類型)

 String的長度是多少，有限制?(長度受內存大小的影響)

十6、冒泡排序

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();

}

}

 

十7、二分查找法

十8、時間類型轉換

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();

}

}

 

十9、階乘

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

}

}

 

二10、UE和UI的區別

UE 是用戶體驗度

UI 界面原型（用戶界面）（至關於買房時用的模型）

 

設計UI的做用：

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

2、提早讓用戶對項目有個宏觀的瞭解，知道效果是什麼樣子。

 

二11、osi七層模型

第一層：物理層

第二層：數據鏈路層

第三層：網絡層

第四層：傳輸層

第五層：會話層

第六層：表示層

第七層：應用層

 

 

二12、線程和進程的區別

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

進程定義的是應用程序與應用程序之間的邊界，一般來講一個進程就表明一個與之對應的應用程序。不一樣的進程之間不能共享代碼和數據空間，而同一進程的不一樣線程能夠共享代碼和數據空間。

 

2.一個進程能夠包括若干個線程，同時建立多個線程來完成某項任務，即是多線程。

3.實現線程的三種方式：繼承Thread類，實現Runable接口，實現Callable接口

二十3、jvm的內存結構

java虛擬機的內存結構分爲堆(heap)和棧(stack),堆裏面存放是對象實例也就是new出來的對象。棧裏面存放的是基本數據類型以及引用數據類型的地址。

 

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

 

堆：存放值

棧：存放地址

本地方法棧：本地一些方法庫

程序計數器：遇到多線程或者其餘事物時，記錄當時執行位置

元空間：

 

線程棧：

棧幀：

局部變量表

操做數棧

動態連接

方法出口

 

垃圾回收機制：老年代和年輕

年輕代：擴大初始內存大小，8/1/1

老年代：年輕代輪迴在15個回合

Tomcat的優化：

Tomcat的初始設置調優節約時間，優化數據庫

B-tree結構，表結構仍是數據源datasource（url）stream和public和private

初始的結果是否處於一致性的，事物的回滾

二十4、內存泄露和內存溢出

內存泄露 (memory leak)，是指應用程序在申請內存後，

沒法釋放已經申請的內存空間.一次內存泄露危害能夠忽略，

但若是任其發展最終會致使內存溢出(out of memory).

如讀取文件後流要進行及時的關閉以及對數據庫鏈接的釋放。

 

內存溢出（out of memory）是指應用程序在申請內存時，

沒有足夠的內存空間供其使用。

如咱們在項目中對於大批量數據的導入，採用分段批量提交的方式。

 

二十5、單例

單例就是該類只能返回一個實例。

單例所具有的特色：

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 tatic 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(single ){

if(null == single){

single = new Singleton3();

}

}

}

return single;

  }

}

 

參考：

 

經過雙重判斷來保證單列設計模式在多線程中的安全性，

而且它在性能方面提升了不少。

synchronized在方法上加鎖 (同步鎖)

synchronized在代碼塊內部加鎖 （同步代碼塊）

synchronized(同步鎖)

使用synchronized如何解決線程安全的問題？

1.synchronized在方法上加鎖

2.synchronized在代碼塊內部加鎖

 

1.懶漢  2.餓漢  3.雙重判斷

 

二十6、解析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

 

 

 

二十7、項目的生命週期

    1.需求分析

2.概要設計

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

4.數據庫設計(powerdesigner)

5.代碼開發（編寫）

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

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

7.集成測試 （黑盒測試，loadrunner（編寫測試腳本）(高級測試)）

8.上線試運行 （用戶本身體驗）

9.壓力測試（loadrunner）

10.正式上線

11.維護

 

二十8、OSCache的判斷

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

//從緩存中取數據

if (null == obj)  {

obj = brandDao.getBrandList();

//若是爲空再從數據庫獲取數據

 //獲取以後放入緩存中

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

}

return (List<OaBrand>)obj;

 

 

二十9、常常訪問的技術網站

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

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

3.oschina（開源中國獲取java開源方面的信息技術）

4.java開源大全 www.open-open.com(獲取java開源方面的信息技術)

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

 

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

飛秋(局域網) qq(局域網，外網)

RTX（局域網，外網） 郵箱 （局域網，外網）

三11、平時瀏覽的書籍

實戰經驗：

　　*** in action(實戰)

　　*** 深刻淺出

　　*** 入門指南

思想基礎:

　　大話設計模式 重構

 

三12、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數據庫異常

 

三十3、session和cookie的區別

session是存儲在服務器端，cookie是存儲在客戶端的，安全性session高

單個cookie在客戶端的限制是3K

因此安全來說session的安全性要比cookie高，而後咱們獲取session裏的信息是經過存放在會話cookie裏的sessionid獲取的。又因爲session是存放在服務器的內存中，因此session裏的東西不斷增長會形成服務器的負擔，因此會把很重要的信息存儲在session中，而把一些次要東西存儲在客戶端的cookie裏，而後cookie確切的說分爲兩大類分爲會話cookie和持久化cookie，會話cookie確切的說是，存放在客戶端瀏覽器的內存中,因此說他的生命週期和瀏覽器是一致的，瀏覽器關了會話cookie也就消失了，然而持久化cookie是存放在客戶端硬盤中，而持久化cookie的生命週期就是咱們在設置cookie時候設置的那個保存時間，而後咱們考慮一問題當瀏覽器關閉時session會不會丟失，從上面敘述分析session的信息是經過會話cookie的sessionid獲取的，當瀏覽器關閉的時候會話cookie消失因此咱們的sessionid也就消失了，可是session的信息還存在服務器端，這時咱們只是查不到所謂的session但它並非不存在。那麼，session在什麼狀況下丟失，就是在服務器關閉的時候，或者是session過時(默認時間是30分鐘)，再或者調用了invalidate()的或者是咱們想要session中的某一條數據消失調用session.removeAttribute()方法，而後session在何時被建立呢，確切的說是經過調用getsession()來建立，這就是session與cookie的區別.

訪問HTML頁面是不會建立session,可是訪問index.JSP時會建立session(JSP其實是一個Servlet, Servlet中有getSession方法)

三十4、字節流與字符流的區別

stream結尾都是字節流，reader和writer結尾都是字符流

二者的區別就是讀寫的時候一個是按字節讀寫，一個是按字符。

實際使用一般差很少。

在讀寫文件須要對內容按行處理，好比比較特定字符，處理某一行數據的時候通常會選擇字符流。

只是讀寫文件，和文件內容無關的，通常選擇字節流。

 

三十5、static、final,finally,finalize 三者區別

1、static修飾的變量和方法，在類加載時即被初始化，可直接經過類名.變量名和類型.方法名進行調用。

2、static修飾的變量，在類加載時會被分配到數據區的方法區。類的實例可共享方法區中的變量。若是static修飾的變量發生改變，那麼全部類實例引用的變量都會一塊兒發生改變。

3、static修飾的方法中不能使用this或super，static修飾的方法屬於類的方法，而this或super只是對象的方法。

4、static修飾的方法不能引用非static 修飾的變量, 在類加載過程當中，當static修飾的方法加載完成時，非static修飾的變量還未加載，因此沒法引用非static修飾的變量。

5、非static修飾的方法能夠引用static 修飾的變量，在類加載過程當中，static修飾的變量優先完成加載，因此當非static修飾的方法完成加載後能夠引用static 修飾的變量。

 

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清理它所從屬的對象時被調用的

三十6、Io流的層次結構

 

從流的方向

輸入流   輸出流

 

從流的類型上

字符流    字節流

 

inputstream和outputstream都是抽象類

 

它們下面的實現包括

 

FileInputStream,BufferedInputStream

 

FileOutputStream,BufferedOutputStream

 

reader 和 writer

 

FileReader,BufferedReader,StringReader

FileWriter,BufferedWriter,StringWriter,PrintWriter

 

 

三十7、JAVA:

Java是面向對象的，跨平臺的，它經過java虛擬機來進行跨平臺操做，它能夠進行自動垃圾回收的【c語言是經過人工進行垃圾回收】，java還會進行自動分配內存。【c語言是經過指定進行分配內存的】，只須要new一個對象，這個對象佔用了多少空間，不須要咱們來管，java虛擬機負責管這些，用完以後也不須要咱們來釋放，java虛擬機會自動釋放

java是一種高級語言，簡單，面向對象，多線程，高性能，安全。

java語言：數據結構+算法+內存管理

  數據結構:數據在內存的分佈方式

  算法:解決問題的方式

  內存的管理:內存的劃分和釋放

Java優勢：簡單、跨平臺、多線程（線程、進程）、動態編譯、類加載機制、垃圾回收機制

 

三十8、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外，還新加了企業應用所需的類庫

 

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

四10、報錯的狀態碼：

 301 永久重定向

 302 臨時重定向

 304 服務端 未改變

 403 訪問無權限

 200 正常

 404 路徑

 500 內部錯誤

四11、協議以及默認的端口號

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

四12、抽象類與接口的區別

 

1.一個類只能進行單繼承，但能夠實現多個接口。

2.有抽象方法的類必定是抽象類，可是抽象類裏面不必定有抽象方法；

  接口裏面全部的方法的默認修飾符爲public abstract，接口裏的成員變量默認的修飾符爲  pulbic static final。

抽象類要被子類繼承，接口要被類實現

接口只能作方法聲明，抽象類中能夠做方法聲明，也能夠作方法實現

接口裏定義的變量只能是公共的靜態的常量，抽象類中的變量是普通變量

 

       關係

接口和接口      繼承

接口和抽象類    抽象類實現接口

類和抽象類      類繼承抽象類

類和類          繼承

四十3、修飾符的做用

修飾符的做用範圍:

 

private  default  protected public

同一個類中      能夠  能夠   能夠    能夠

同一個包的類中 能夠      能夠    能夠

不一樣包的子類中       能夠      能夠

不一樣包的類中        能夠

四十4、onready和onload的區別

1.onready比onload先執行

2.onready是在頁面解析完成以後執行，而onload是在頁面全部元素加載後執行

3.onload只執行最後一個而onready能夠執行多個。

參考：

1.執行時間 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 (){ // 編寫代碼 }

四十5、switch默認接受的幾種數據類型

Short, int, byte, char，String

四十6、request 跟session的區別

1.他們的生命週期不一樣，

request對應的是一次請求，

session對應的是一次會話

2.request佔用資源比較少,相對來講缺少持續性,

而session資源消耗比較大，因此一般使用request來保存信息

四十7、找到解決svn衝突方法

對於svn衝突，能夠採用手工處理將衝突的部分進行整合，

以後備份最新整合後的文件，採用覆蓋更新的方式處理完

衝突以後，再把最新整合後的文件進行提交。

 

四十8、反射的描述

        經過字符串能夠動態建立java對象，而且能夠動態訪問方法，

      屬性等。

      咱們在項目中的時候封裝過數據庫jdbc的持久層，

      其中就利用反射這項

      技術來達到通用

      和靈活的目的。

 

 

 

框架篇   

1、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頁面。

2、Struts2的運行原理

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

2、客戶端會發送一個請求到 action 、FilterDispatcher  會根據後綴名進行攔截

3、FilterDispatcher根據 struts.xml  的配置文件信息 找到 某個action 對應的某個類裏的指定方法

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

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

3、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的模版。（體系結構圖見下一頁）

 

4、Spring MVC運行原理

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

1.Tomcat在啓動時加載解析web.xml,找到spring mvc的前端總控制器DispatcherServlet,而且經過DispatcherServlet來加載相關的配置文件信息。

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

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

4.DispatcherServlet根據獲得的ModelAndView中的視圖對象，找到一個合適的ViewResolver（視圖解析器），根據視圖解析器的配置，DispatcherServlet將要顯示的數據傳給對應的視圖，最後顯示給用戶。

 

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

 

 

6、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是基於類

 

7、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：顯示原始文件內容，例如文件源代碼

 

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

 

9、SSI整合

1、Action繼承於Actionsupport

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

3、在struts2的action中注入service，保證service的名字和配置文件中的一致， 並生成get,set方法

4、Dao層繼承於SqlMapClientDaoSupport

5、在dao層的配置文件中注入sqlMapClient

 

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

 

10、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",對處理後的跳轉進行統一配置。

11、Hibernate 中get 和 load的區別

加載方式：

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

　　　　get爲當即加載(執行時,會當即向數據庫發出sql語句)

返回結果：

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

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

12、Hibernate、Ibatis、Jdbc三者的區別

Hibernate屬於全自動， Ibatis屬於半自動，Jdbc屬於手動，從開發效率上講hibernate較高，ibatis居中，jdbc較低，從執行效率上講hibernate較低，ibatis居中，jdbc較高，由於jdbc是手工寫sql語句，程序員對sql的控制能力更大，能夠根據業務須要進行優化，而ibatis雖然也能夠對sql進行優化，可是他裏面將resultset封裝爲實體的過程當中採用了反射機制因此必定程度上影響了性能，而hibernate由於高度封裝因此開發效率相對較高，但正由於這個緣由，因此程序員在對sql語句的控制和優化方面相對比較弱，並且在將resultset封裝成實體的過程當中也採用了反射機制，因此在性能方面較低

十3、Hibernate的運行原理

首先經過configuration去加載hibernate.cfg.xml這個配置文件，根據

配置文件的信息去建立sessionFactory,sessionFactory是線程安全的，

是一個session工廠，用來建立session,session是線程不安全的，至關於

jdbc的connection，最後經過session去進行數據庫的各類操做，在進行操做

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

十4、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（事務）負責操做相關的事務。

十5、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語句執行。

十6、Hibernate中的兩大配置文件

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

Hibernate.cfg.xml：方言(用哪一個數據庫)，數據庫鏈接信息，包含*.hbm.xml內容，映射 文件，也能夠配事務。

十7、Hibernate事務處理

開啓事務 session.beginTransaction();

執行相關的操做，若是成功則session.getTransaction().commit();

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

十8、Hibernate的三種狀態以及狀態的轉換

Transient(臨時)

      new 一個初始化對象後，並無在數據庫裏保存數據，處於臨時狀態；

Persistent(持久化)

      當執行save()方法，調用session.close()方法以前，內存中的對象與數據庫有           對應關係處於持久化狀態；

Detached(託管/遊離)

　　　當執行session.close()以後，處於託管狀態；

狀態的轉換

      處於託管狀態下，調用update()方法後，轉換爲持久化狀態；

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

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

十9、分頁步驟

①前臺封裝一個顯示分頁的組件

②查詢總條數

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

④後臺寫支持分頁的sql語句

⑤前臺包含分頁組件，實現分頁效果

 

注意:

查詢總條數的where和查詢列表信息的where條件要保證一致。

二10、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不使用查詢緩存

 

二11、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

 

二12、防止表單重複提交

針對於重複提交的總體解決方案：

1.用redirect來解決重複提交的問題

2.點擊一次以後，按鈕失效

3.經過loading

4.自定義重複提交過濾器無奈                                           

5.解決struts2重複提交

能夠結合s:token標籤來解決重複提交問題

 

利用token的原理：

1.在前端的jsp頁面中加入s:token標籤，在訪問該頁面時就會生成

  隱藏域，該隱藏域中包含一個隨機生成的字符串，並把該字符串

  存入session中

 

2.在struts2的配置文件中加入token攔截器後，當正常訪問action

的時候，會從session中取出該字符串，而後和頁面隱藏域中提交

字符串作對比，若是一致則正常執行並刪除session中存儲的字符串。

 

二十3、JSP標籤：

JSP和servlet區別

jsp經編譯後就變成了Servlet.(JSP的本質就是Servlet，JVM只能識別java的類，不能識別JSP的代碼,Web容器將JSP的代碼編譯成JVM可以識別的java類)

jsp更擅長表現於頁面顯示,servlet更擅長於邏輯控制.

Servlet中沒有內置對象，Jsp中的內置對象都是必須經過HttpServletRequest對象，HttpServletResponse對象以及HttpServlet對象獲得.

Jsp是Servlet的一種簡化，使用Jsp只須要完成程序員須要輸出到客戶端的內容，Jsp中的Java腳本如何鑲嵌到一個類中，由Jsp容器完成。而Servlet則是個完整的Java類，這個類的Service方法用於生成對客戶端的響應。

JSP是Servlet技術的擴展，本質上就是Servlet的簡易方式。JSP編譯後是「類servlet」。Servlet和JSP最主要的不一樣點在於，Servlet的應用邏輯是在Java文件中，而且徹底從表示層中的HTML裏分離開來。而JSP的狀況是Java和HTML能夠組合成一個擴展名爲.jsp的文件。JSP側重於視圖，Servlet主要用於控制邏輯

 

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註釋：

<!-- 這是註釋,但客戶端能夠查看到 -->

<%-- 這也是註釋,但客戶端不能查看到 --%>

8.el表達式：${}

9.jsp:include動做是在運行時動態包含。

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

  它們兩個都只能包含本項目的相關文件，不能包含其餘項目的。  

   若是要包含其餘項目的文件能夠使用c:import

二十4、過濾器

filter的概述:

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

 

filter的生命週期是:

實例化--->初始化(init)-->進行過濾(doFilter)--->銷燬(destroy)-->釋放資源

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

 

 在項目中咱們一般經過filter進行編碼轉換，

 進行安全驗證，進行重複提交的判斷。

 

瞭解(不須要主動說)

filter 至關於 攔截器 至關於Spring AOP

servlet+jsp+javabean+jdbc+filter

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

二十5、攔截器的理解

什麼是攔截器：

攔截器是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中的全部配置。代碼以下：

<package name="demo" extends="struts-default" > ... </package>

  攔截器是Struts2框架的核心，它主要完成解析請求參數、將請求參數賦值給Action屬性、執行數據校驗、文件上傳等工做

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

  自定義攔截器須要特別注意的是不要忘記引入struts2默認的攔截器。爲了實現某些操做，咱們能夠自定義攔截器，

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

攔截器在項目中的運用：

同時能夠減輕代碼冗餘，提升重用率。

若是要求用戶密碼、權限等的驗證，就能夠用自定義的攔截器進行密碼驗證和權限限制。對符合的登入者才跳轉到正確頁面。

二十6、Spring融入框架

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

spring的配置文件，從而融入到項目框架中。

二十7、項目的部署方式

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

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

 

 

數據庫篇

1、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資源。

2、數據庫鏈接池

數據庫鏈接池的優勢運行原理:

在咱們不使用數據庫鏈接池的時候，每次訪問數據庫都須要建立鏈接，

使用完成以後須要釋放關閉鏈接，而這樣是很耗費資源的。當咱們使用

數據庫鏈接池的時候，在tomcat啓動的時候就建立了指定數量的鏈接，

以後當咱們程序使用的時候就直接從鏈接池裏面取，而不須要建立，同理，

當咱們使用完的時候也不須要關閉鏈接，而是將鏈接返回到鏈接池中，供

其餘請求繼續使用。

 

DBCP：比較穩定。

C3P0: 性能比較高。

3、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 磁盤：導入的文件名(加後綴)

 

 

4、jdbc分段批量提交的時候出現異常怎麼處理?

      經過Map來解決性能問題。首先在分段批量提交的時候，咱們不採用事務，這樣就保證了合法的數據就自動提交，不合法的數據就本身自動進行回滾，爲了不不合法數據影響後續合法數據的提交，採用定義業務規則字典表，實現對數據的驗證，將不合法的數據記錄下來，供用戶進行後續處理，而合法的數據就所有提交。

 

5、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();

}

 

6、Oracle分頁

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

 

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

 

8、id、rowid、rownum的區別

rowid物理位置的惟一標識。

而id是邏輯上的惟一標識，因此rowid查找速度要快於id,是目前最快的         

定位一條記錄的方式

rowid和rownum都是"僞數列"

所謂「僞數列」也就是默認隱藏的一個數列。

rownum用於標記結果集中結果順序的一個字段，

它的特色是按順序標記，並且是連續的，

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

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

若是是>或者=則須要給他起個別名

9、主鍵和惟一索引的區別？ 

        在建立主鍵的同時會生成對應的惟一索引，主鍵在保證數據惟一性的同時不容許爲         空，而惟一能夠有一個爲空數據項，一個表中只能有一個主鍵，可是一個主鍵能夠         有多個字段，一個表中能夠有多個惟一索引。

 

10、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用的是‘+’字符串拼接，安全性較低。

 

11、數據庫三範式

       第一範式：數據庫表中的全部字段值都是不可分解的原子值。

       第二範式：須要確保數據庫表中的每一列都和主鍵相關，而不能只與主鍵的某一部                  分相關（主要針對聯合主鍵而言）

       第三範式：須要確保數據表中的每一列數據都和主鍵直接相關，而不能間接相關

 

12、視圖概述

      視圖能夠視爲「虛擬表」或「存儲的查詢」

      建立視圖所依據的表稱爲「基表」

      視圖的優勢：

      提供了另一種級別的表安全性:隱藏了一些關鍵的字段

      簡化的用戶的SQL命令

      隔離基表結構的改變

 

十3、存儲過程概述

存儲過程（Stored Procedure）

　　能夠包含邏輯判斷的sql語句集合。

　　是通過預編譯，存在於數據庫中。

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

優勢：

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

　　屏蔽了底層細節，不暴露表信息便可完成操做

　　下降網絡的通訊量，多條語句能夠封裝成一個存儲過程來執行

　　設置訪問權限來提升安全性

　　提升執行效率，由於它是預編譯以及存儲在數據庫中

缺點：

　　可移植性差，相同的存儲過程並不能跨多個數據庫進行操做

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

 

存儲過程的語法：

 

--下面是在oracle數據庫下最基本的語法

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

--IS也能夠是AS

--若是已經存在名爲 testProcedure 的存儲過程，下面的語法會出現 名稱已被使用的錯誤

--解決辦法：

--第一句能夠寫成 create or replace procedure testProcedure

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

--NULL表示任何能夠正確執行的sql 語句，但至少一句

 

create procedure testProcedure

IS

BEGIN

 

NULL

 

END;

 

存儲過程的參數的分類:

IN

OUT

INOUT

 

注意：

　　存儲過程之間可相互調用

　　存儲過程通常修改後，當即生效。

 

 

十4、索引概述

 

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.順序索引，散列索引,位圖索引

 

十5、必背的sql語句

    1：oracle 分頁

 

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

 

  2: mysql 分頁

 

         select * from music where id limit 5,5

 

  3：oracle中如何快速將一張表的數據複製到另一張表中(另一張表不存在，另一張       表存在，但數據爲空)

一、.不存在另外一張表時：

create  table  新表  as  select * from 將要複製的表

二、存在另外一張表時：

insert  into  新表名  select  字段  from  將要複製的表名

 

 

 

  4：音樂專輯

 

   查詢出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

 

  5：快速刪除一張表（不可事物回滾，也就是沒有日誌記錄）

 

      TRUNCATE from 表名

 

  6：inner join

 

  select 查找信息 from 表名 1 inner join 表名2 on 表名1.列名 = 表名2.列名

 

  7：left join

  

  左外鏈接    select 查找信息 from 表名1 left join 表名2 on 表名1.列名 = 表名2.列名

    

 

  8：right join

 

   右外鏈接  select 查找信息 from 表名1 right join 表名2 on 表名1.列名 = 表名2.列名

 

  9：oracle中查詢遍歷樹形結構（start  with）

 

  select * from extmenu

        start with pid=1

connect by prior id = pid

快速刪除父節點以及父節點下的全部節點：

Delete from extmenu where id in (

elect * from extmenu

        start with pid=1

connect by prior id = pid

)

 

 

  10：查詢出來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

 

11：用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(只查詢出兩表共同擁有的字段數據)

 

12：刪除表中的重複數據：

delete from xin a where a.rowid != (

select max(b.rowid) from xin b

where a.name = b.name

);

 

13：row_number()，rank() over ，dense_rank() over 按工資排序

  select sal,

                 row_number() over(order by sal desc) rank1,

                 rank() over(order by sal desc) rank,

                 dense_rank() over(order by sal desc) drank

            from emp

 

14：select * from (select emp.* from(

dense_rank() over(partition by departNo order by sal desc)

rk from emp )

Where rk=4

 

十6、ibatis批量

this.getSqlMapClientTemplate().execute(

new SqlMapClientCallback() {

public Object doInSqlMapClient(

SqlMapExecutor executor)

throws SQLException {

executor.startBatch();

for (int i = 0, n = list.size(); i < n; i++) {

executor.insert(

"productAttach.insertProductAttach",

list.get(i));

}

executor.executeBatch();

return null;

}

});

 

ibatis,jdbc,hibernate的分段的實現:

都應該在組裝list的時候進行拆分（如：action層加入）

if(list.size() % 1000 == 0)

{

productAttachService.addBatch(list);

list.clear();

}

 

if (list.size() > 0)

productAttachService.addBatch(list);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

業務場景篇

1、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)，

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

經過容器來實現對象組件的裝配和管理。

所謂的「控制反轉」概念就是對組件對象控制權的轉移，

從程序代碼自己轉移到了外部容器。

 

 

2、事務概述

      在數據庫中,所謂事務是指一組邏輯操做單元即一組sql語句。當這個單元中的一部分操做失敗,整個事務回滾，只有所有正確才完成提交。

判斷事務是否配置成功的關鍵點在於出現異常時事務是否會回滾

 

事務的ACID屬性

1. 原子性（Atomicity）

原子性是指事務是一個不可分割的工做單位，事務中的操做要麼都發生，

要麼都不發生。  

 

2. 一致性（Consistency）

事務必須使數據庫從一個一致性狀態變換到另一個一致性狀態。(數據不被破壞)

 

3. 隔離性（Isolation）

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

 

4. 持久性（Durability）

 

持久性是指一個事務一旦被提交，

它對數據庫中數據的改變就是永久性的.即便系統重啓也不會丟失.

 

在JDBC中，

事務默認是自動提交的，

每次執行一個 SQL 語句時，若是執行成功，

就會向數據庫自動提交，而不能回滾

 

爲了讓多個 SQL 語句做爲一個事務執行：

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

     以取消自動提交事務

（2）在全部的 SQL 語句都成功執行後，調用 commit(); 方法提交事務

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

 

3、權限概述

          權限涉及到5張表：

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

 

當用戶登陸時，根據用戶名和密碼到用戶表驗證信息是否合法，若是合法

則獲取用戶信息，以後根據用戶id再到用戶角色關聯表中獲得相關連的角色

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

而後再根據權限id集合到權限表（菜單表）中獲取具體的菜單，展示給當前

登陸用戶，從而達到不一樣用用戶看到不一樣的菜單權限。

 

咱們經過ZTree來給角色賦權而且經過ZTree來展現菜單，以及經過ZTree來管 理菜單即增長和編輯菜單。

咱們作的權限控制到url級別,爲了防止用戶不登陸直接輸入url訪問的這個弊端，經過攔截器進行攔截驗證。

 

4、OSCache業務場景

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

 

5、線程概述

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

　 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.一個進程能夠包括若干個線程，同時建立多個線程來完成某項任務，即是多線程。

 

6、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線程池概述

    java線程池的工做原理和數據庫鏈接池的差很少，由於每次從新建立線程

都是很耗資源的操做，因此咱們能夠創建一個線程池，這樣當須要用到線程

進行某些操做時，就能夠直接去線程池裏面找到空閒的線程，這樣就能夠直接

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

供其餘請求使用從而提升應用程序的性能。

 

線程池的核心流程:

1.構建一個 ThreadPoolExecutor 並指定默認要建立的線程的數量

2.經過 threadPool.execute()

去添加一個個要執行的線程即實現了Runable接口的java類

3.在實現了Runable接口的java類的run方法中寫入具體的業務代碼

線程池的業務場景：

我在工做的時候，當時一個同事給我提了一個需求，目前有大量的圖片

須要處理生產縮略圖並進行加水印，由於按照普通的處理方法一個個的

進行處理太慢了，問我有沒有好的解決方案，這個時候我就想到了java中

的線程池，我構建了一個線程數爲5個線程池，而後採用分段批量提取的

方式每500條爲一組數據進行圖片信息的提取，而後再把這些經過Threadpool的

execute方法交給線程池中的線程進行處理，即充分使用了CPU硬件資源又加快

了大數據狀況下程序的處理效率。

 

 

我當時在工做的過程當中，認識一個作電商的朋友，他們當時公司才起步，不少

技術都不成熟，因此就經常和我探討一些技術問題，有次他向我請教一個問題，

問我如何才能提升網站的性能，我根據本身在項目中的經驗以及本身之前閱讀的

關於優化方面的資料給他提出了不少建議，如用lucene進行全文檢索，用memcached

進行分佈式緩存，以及經過spring定時器結合freeMarker模板引擎來生成靜態

頁面，因爲要生成的頁面的數量比較多，考慮到程序的性能，我建議他結合

java的線程池進行工做，這樣就能夠充分使用了CPU硬件資源又加快

了大數據狀況下程序的處理效率。

 

8、OSCache概述

     oscache是一個高性能的j2ee框架，能夠和任何java代碼進行集成，而且還能夠經過標籤對頁面內容進行緩存，還以緩存請求。

咱們一般將那些頻繁訪問可是又不是常常改變的數據進行緩存。爲了保證緩存數據的有效性，在數據發生改變的時候，咱們要刷新緩存，避免髒數據的出現。刷新緩存的策略有兩種，一種是定時刷新，一種手動刷新。

 

緩存數據的時機一般也分爲兩種，即在tomcat(web容器)啓動時候加載數據進行緩存，另外也能夠在用戶第一次訪問數據的時候進行緩存，這個至關於緩存的當即加載和按需加載。

 

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

 

一個action裏面能夠有多個service,一個service中能夠有多個dao或者多個service

 

任何類之間均可以進行相互調用，能夠經過構造函數傳參，set,get傳參或者是方法傳   參將相關的類鏈接起來。

9、OSCache+autocomplete+單例業務場景

      在我之前作某項目的過程當中，其中咱們在作產品列表的查詢的時候爲了提升用戶的體驗度，咱們使用了autocomplete插件來代替select進行品牌的選擇，纔開始的時候每次都要根據用戶輸入的信息去查詢數據庫進行模糊匹配返回結果，後來咱們考慮到系統的性能，所以咱們採用了oscache緩存，纔開始這個功能是交給咱們項目組中的另一個同事來作的，可是他作完後，咱們在使用這個工具類的時候，發現有時緩存中明明已經有時咱們須要的數據，可是從緩存裏面取的時候，發現沒有，以後項目經理讓我去幫這個同事看看這個問題，我通過閱讀他的代碼發現，它裏面在使用緩存的時候，針對於每次方法的調用都產生一個新的實例，結果致使了上面的問題，這個時候我想起了能夠使用設計模式中的單例模式來解決這個問題，纔開始我直接採用了普通的單列模式，可是後來在測試的過程當中，發現當用戶併發量大的時候仍是會出現上面的問題，以後我再次考慮了代碼，最後發現是由於沒有給單列模式加鎖的緣由，從而致使了大用戶併發的時候，線程安全的問題，以後我便在方法上加上了synchronized關鍵字，解決上述的問題，可是後來測試人員反饋，覺的這段的性能有問題，我考慮以後便採用在方法體內加鎖並結合雙重斷定的方式解決了上面的問題。咱們是將數據在tomcat啓動的時候加載到緩存中，以後用戶進行查詢的時候直接從緩存中獲取數據，根據前綴匹配進行查詢，將結果返回給用戶。這樣在提升用戶體驗度的同時也提升性能。

 

10、緩存概述

應用程序爲了提升性能，能夠經過使用緩存來達到目的，緩存的存儲介質能夠

內存或者硬盤，一般將數據存儲在內存裏，確切的說是jvm的內存中，緩存是

基於Map這種思想構建的，以鍵值對的方式進行存取，之因此還能夠將

緩存的數據存儲在硬盤中，是由於內存資源至關有限和寶貴，因此當內存資源

不足的時候，就能夠將其存儲到硬盤中，雖然硬盤的存取速度比內存要慢，可是

由於減小了網絡通訊量，因此仍是提升程序的性能。緩存能夠分爲客戶端緩存和

服務器端緩存，所謂的客戶端緩存一般指的是IE瀏覽器的緩存，服務器端緩存指

的web服務器的緩存，一般能夠經過第三方組件實現，如oscache,memcache

 

 

咱們一般將那些頻繁訪問可是又不是常常改變的數據進行緩存。爲了保證緩存數據的

有效性，在數據發生改變的時候，咱們要刷新緩存，避免髒數據的出現。刷新緩存的

策略有兩種，一種是定時刷新，一種手動刷新。

 

 

緩存的層次以下:jsp-->action-->service(一般放置在service)-->dao,

緩存越靠前對性能的提高越大

 

緩存的策略:(緩存空間不足須要進行清理的時候使用)

LRU:最近最少使用原則.(理解:存儲書)

FIFO:先進先出的緩存策略.(理解:排隊)

 

你來講說緩存？說說你對緩存的理解（若是遇到重複的，就能夠省略）

 

咱們在項目中使用緩存的目的是爲了提升應用程序的性能，減小訪問數據庫

的次數，從而提升應用程序的吞吐量。咱們一般將權限，菜單,組織機構

這些頻繁訪問可是不常常改變的基礎數據進行緩存，其中我在作()某某項目的時候

就經過oscache對ZTree的樹形菜單進行了緩存，而且在作的時候和單列設計

模式進行結合，考慮到多線程下的安全問題，還對單例模式加入了雙重斷定鎖

的檢查方式。

11、實現頁面靜態化業務場景

     咱們在作某項目時，涉及到程序訪問的性能問題，這時候咱們想到能夠經過靜態化來提升用戶訪問時候的性能，因此咱們就採用了freemarker模板引擎，考慮到頁面也是要有動態的變化的，因此咱們採用spring定時器在天天晚上2點鐘的時候定時再次生成html靜態頁面，考慮發佈時候的性能問題，咱們又採起線程池技術，讓多個線程同時發佈，從而縮減發佈時間。

 

12、servlet線程安全描述

     servlet是單列的，對於全部請求都使用一個實例，因此若是有全局變量被多

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

 

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

1.實現singleThreadModel接口，這樣對於每次請求都會建立一個新的servlet實例，這樣就會消耗服務端內存，下降性能，可是這個接口已通過時，不推薦使用。

2.能夠經過加鎖(synchroniezd關鍵字)來避免線程安全問題。這個時候雖然仍是單列，可是對於多線程的訪問，每次只能有一個請求進行方法體內執行，只有執行完畢後，其餘線程才容許訪問，下降吞吐量。

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

 

十3、(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變量表。

 

圖形化的靈活定製（主動說）

能夠根據需求進行流程圖的改變的，即定義的流程圖是能夠根據須要改變的，而不是死的。

能夠進行圖形化的監控(主動說)

輸出圖片

獲取活動節點的座標

進行疊加

判斷節點:(主動說，也能夠了解)

實現implements DecisionHandler接口並重寫decide方法,

返回的字符串要和xml中配置的transition的name保持一致。

分支斷定節點

 

 

 

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 流程變量( 上下文) 歷史表

 

十4、JPBM業務場景

    首先進行請假的流程定義，咱們流程的定義是（員工提交請假單---》經理審批---》總監審批---》總經理審批---》結束），經過repositoryService將其發佈部署到jbpm4_lob表中，

以後獲取流程定義列表，選中請假的流程定義，員工開始進行請假單的填寫，保存並經過executionService開啓流程實例，而後用taskService獲取經理的待辦任務列表，選中待辦任務，進行審批，經過調用taskService.completeTask()進入到總監審批環節，而後用總監進行登陸，一樣獲取待辦任務列表，而後調用taskService.completeTask()進入總經理審批環節，總經理審批以後，結束流程。在這個過程當中咱們還能夠根據historyService查看當前登陸人已辦的任務列表。

十5、Ant描述

     Ant是apache旗下的對項目進行自動打包、編譯、部署的構建工具，他主要具備     輕量級而且跨平臺的特性，並且基於jvm，默認文件名爲build.xml

Ant主要的標籤：

Project 根標籤，

target 任務標籤，

property 屬性標籤，自定義鍵/值 供屢次使用，

java 執行編譯後的java文件

javac 編譯java文件

war 打成war包

其它標籤：copy，delete，mkdir，move，echo等。

 

十6、FreeMarker描述

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

 

工做原理：定義模板文件，嵌入數據源，經過模板顯示準備的數據

（數據 + 模板 = 輸出）

　　咱們在使用模板中發現freemarker具備許多優勢，它完全的分離表現層和業務邏輯，模板只負責數據在頁面中的表現，不涉及任何的邏輯代碼，因此使得開發過程當中的人員分工更加明確，做爲界面開發人員，只需專心建立HTML文件、圖像以及Web頁面的其餘可視化方面，不用理會數據；而程序開發人員則專一於系統實現，負責爲頁面準備要顯示的數據。

若是使用jsp來展現，開發階段進行功能調適時，須要頻繁的修改JSP，每次修改都要編譯和轉換，浪費了大量時間，FreeMarker模板技術不存在編譯和轉換的問題，在開發過程當中，咱們在沒必要在等待界面設計開發人員完成頁面原型後再來開發程序。由此使用freemarker還能夠大大提升開發效率。

 

十7、webService描述

   （主動說）

     webservice是SOA（面向服務編程）的一種實現，

     主要是用來實現異構平臺通訊也就      

     是不一樣平臺不一樣項目之間的數據傳輸，從而避免了信息孤島的問題，

     它之因此可以

     進行異構平臺通訊是由於它是徹底基於xml的，

     因此說，webService是跨平臺，

     跨語言，跨框架的，在java中一般有三種技術框架分別是xfire,cxf,axis2。

     咱們爲了保證        

webservice的安全性，採用了基於

WS-Security標準的安全驗證(使用回調函數)。

 

 

 

 

（不必主動說）

     webservice的三要素分別是：

     wsdl（webservice description language）

     用來描述發佈的接口（服務）

     

     soap(simple object access protocol)

     是xml和http的結合，是webservice數據通訊的協議

     

     uddi 用來管理，查詢webService的服務

 

（不必主動說）

     webservice的具體三種實現方式（框架）或者三種實現框架的區別

      1. Axis2:能夠用多種語言開發，

      是一個重量級框架，功能很是強大，

      可是它的性能比較低。

 

      2. Xfire：它相比Axis2來講是一個輕量級框架，

      它的性能要比Axis2高。

 

      3. cxf：是Xfire的升級版，就比如是，

      struts2是webwork的升級，

      而後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接口中的方法。

 

十8、oracle索引概述

   索引呢  是與表相關的一個可選結構，能夠提升sql語句的檢索效率，至關於咱們的字典目錄 ，能夠快速進行定位 ，因此能夠減小磁盤I/O,   可是由於索引在物理與邏輯上都是獨立於表的數據  它會佔用必定的物理空間(額外磁盤空間)  因此並非索引越多越好,而咱們應該根據業務需求去建立索引,並且進行增刪改操做時 oracle又要自動維護索引  因此在必定程度上也下降了維護速度，並且咱們在建立索引和維護索引要耗費時間，這種時間隨着數據量的增長而增長，咱們通常建立索引呢  是這樣建立的 create  index  索引名 on  表名(字段)，索引又分爲普通索引 惟一索引(unique)  單個索引  複合索引(又叫組合索引，在索引創建語句中同時可包含多個字段名)，順序索引，散列索引,位圖索引。

 

十9、oracle存儲過程

存儲過程就是封裝一些sql的集合，也就是一條條的sql語句，過程的優勢就是簡化了sql命令加上它是預編譯的，因此它的執行效率和性能較高，再者，若是不調用過程的話就要和數據庫發生屢次交互，調用過程只需傳一個命令全部的那些執行邏輯都在數據庫端執行，因此說它下降了網絡的通訊量，其次，存儲過程大大提升了安全性，這就是優勢

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

二10、Junit 業務場景

   在咱們開發項目的時候爲了提升代碼的性能和保證邏輯正確性，在咱們編寫代碼後每每都要進行單元測試，來驗證代碼，當時咱們公司開發人員所有使用的main方法來進行驗證，可是使用mian的最大缺點就是不能將多個類同時進行驗證，驗證的結果不直觀，測試複雜（每一個類都要寫main方法，單個運行），必定程度上浪費時間，全部我和項目經理提議使用專業測試工具Junit來進行測試，由於Junit是一個Java語言的單元測試框架 ，測試簡單，不只能夠提供工做效率和代碼的質量，也提升團隊的合做能力，我提議後咱們進行了Junit的培訓使用Junit4加註解的方式來測試。

 

二11、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/>。

 

咱們在作這個項目時，咱們考慮到服務器性能的問題，咱們最開始想到使用縱向擴展，來增長硬件的配置提升其性能，但這樣作比較耗費資金，並且服務器內存空間也是有限的；因此後來就想到使用橫向擴展來達到這一目的

     當時咱們的apache是經過jk藉助於ajp協議與tomcat進行通訊的，在咱們不進行負載均衡以前，那全部的請求都由一臺tomcat進行處理，這樣會使咱們的tomcat所承受的壓力增大，而咱們進行負載均衡以後，一樣數量的請求通過apache和jk將其分發到多臺tomcat進行處理，從而下降每臺tomcat所承受的壓力,並且當其中一臺機器宕機時，其餘機器還能夠繼續提供服務，保證服務不間斷。

  在這個過程當中，咱們遇到了session問題，而後我此昂到用session複製來解決這個問題；

在apache的配置文件中增長session粘帶特性:

worker.lb.sticky_session=1

worker.lb.sticky_session_force=0

Tomcat的配置

修改server.xml文件：

<Engine name="Catalina" defaultHost="localhost" jvmRoute="tomcat2">

增長jvmRoute=」tomcat2」  *.  jvmRoute賦的值爲worker.properties中配置的相應的server名一致

<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/> 將此配置的註釋去掉

修改應用的web.xml文件

在應用中的web.xml文件中增長<distributable/>。

若是這樣作，當第一次訪問的時候，會把因此數據所有緩存到第一臺服務器上，經過web配置文件，會把第一臺緩存的數據所有複製到第二胎服務器上，這樣作就加大網路通訊量，致使阻塞，因此咱們就想到了能夠經過memcached分佈式緩存來存取session從而解決上述問題。

 

二12、Ant業務場景

Ant是基於java語言編寫的，所以具備跨平臺的特性，此外還具備簡潔方便，靈活

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

以後，若是咱們在客戶那裏修改代碼後，就能夠直接使用ant進行編譯，打包，部署，而不須要爲了編譯，打包，部署專門在客戶那裏安裝eclipse.此外使用ant也能夠直接和svn進行交互，下載源碼的同時進行編譯，打包，部署。

二十3、maven業務場景

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包重用的目的。

 

ant業務場景

 

ant是基於java語言編寫的，所以具備跨平臺的特性，此外還具備簡潔方便，靈活

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

以後，若是咱們在客戶那裏修改代碼後，就能夠直接使用ant進行編譯，打包，部署，

而不須要爲了編譯，打包，部署專門在客戶那裏安裝eclipse.此外使用ant也能夠

直接和svn進行交互，下載源碼的同時進行編譯，打包，部署。

 

maven的經常使用命令

mvn eclipse:clean eclipse:eclipse -Dwtpversion=2.0

 

mvn clean package

 

maven的生命週期是獨立的，可是生命週期下的階段是相互關聯而且延續的。

 

maven的生命週期

 

clean(清理):clean;default(默認):compile,test,packageinstall;site(站點)

 

 

二十4、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>

    <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地址

二十5、bugfree的操做步驟

咱們在使用bugfree的時候咱們首先登錄的時候是以測試員的身份登錄的，也就是系統管理員用戶；測試員在登錄後首先應該給要測試的項目的相關負責人，每人建立一個帳號（也就是在登錄後的頁面的後臺管理中建立用戶），用戶都新建完成以後就新建組，把要測試的項目的用戶添加到組中。最後就新建項目而且新建該項目的模塊。新建完項目以後就是開始測試程序，在程序中遇到bug之後就把錯誤截圖，在到bugfree中新建bug填寫相關的信息和要指派的人（出錯模塊的負責人）和把剛纔的錯誤截圖做爲附件一併傳送過去。

開發人員天天早上上班的第一件事就是用本身的用戶登陸bugfree，而後輸入查詢條件看看前一天有沒有指派給本身的bug須要解決的若是有就進行解決。

開發人員把對應的bug解決以後就去bugfree上把bug對應的狀態改爲已解決狀態，而後進行保存提交，這樣bug的狀態就變成已解決狀態。測試人員上線查看已解決狀態的bug並再次進行測試，若是通過測試bug的問題已解決，就能夠把bug關閉；若是通過測試，發現仍然存在bug，就把bug激活；這樣等開發人員再次登陸的時候就能夠再次看到這個未解決的bug，再次進行解決，如此反覆直到bug所有解決，由於bugfree對bug的修改都有保留，全部咱們能夠看到bug的一步步的完善，直到最後把bug關閉。

Bug的三種狀態：未解決(Active)（測試人員）、已解決(Resolved)(開發人員)、關閉(Closed)（測試人員）

 

 

二十6、Axis2 的配置

 

axis2服務端配置流程

 

1.引入相關的jar包而且在web.xml中配置axis2的核心控制器 axisServlet

 

2.在web-inf下創建相關的三層文件夾結構:

services-->自定義文件夾名-->META-INF-->servies.xml

 

3.在servies.xml中配置service的name以及對應的springBeanName

 

4.在瀏覽器中輸入webservice的服務端地址並加上?wsdl來進行測試，看

   是否發佈成功

 

axis2客戶端配置流程

 

1.經過wsdl2java根據webservice服務端的url生成客戶端代碼

 

2.將代碼引入項目的文件夾中進行正常訪問

二十6、spring定時器

每隔固定的時間執行

 

1.創建一個triggers觸發器集合

 

2.創建SimpleTriggerBean而且指定每次間隔的時間以及執行的次數以及要執行的目標

 

3.經過 targetObject以及targetMethod找到要執行的具體類的具體方法

 

目標對象是一個普通的java類

 

每到指定的時間執行

 

1.創建一個triggers觸發器集合.

 

2.創建CronTriggerBean指定cron表達式以及要執行的目標

 

3.經過 targetObject以及targetMethod找到要執行的具體類的具體方法

 

目標對象是一個普通的java類

二十7、Ext概述

據我瞭解Ext是一個用js編寫RIA框架，它能夠和各類後臺語言結合使用。

我在項目中用Ext來完成的模塊大概狀況是這個樣子，首先我經過layout

等於border的這種方式來進行佈局，分爲上下左右中，而後在左邊用ext

tree來進行菜單的展現，以後在中間區域經過tabs來加入選項卡，而在

選項卡中就是一個個的grid以及form，其中我在作grid的時候，首先經過

store來存取後臺返回的符合model格式數據集，store是經過proxy和後臺的

contoller進行交互，以後把store賦值給grid的store屬性而且經過renderTO

在指定的位置進行渲染展現。

 

Grid問題:

當時我在作grid的時候，發現數據沒有展現出來，

我經過f12進行跟蹤，發現壓根就沒有發送請求，後來我分析了下，發現由於

沒有調用store的loadPage方法，因此致使了這個問題。除此以外在咱們作

項目的過程當中，我手底下帶的一我的一樣在負責grid的時候，數據能夠正常展現，但

分頁信息沒有展現，經過跟蹤他的代碼發現是由於他沒有把store屬性賦值給

分頁工具條，因此才致使了這個問題。

 

tabs選項卡：

當我在作tab選項卡這一模塊的時候，

我首先在加載頁面的時候用TabPanel建立了一個

tab頁面，讓它展現在中間位置，

而後點擊左邊Tree菜單調用add方法動態添加一個個

的tab選項卡，可是作的過程當中出現了相同的選項卡會重複添加的問題，

我查了一些相關資料，最後經過tab的id或者一個惟一標識判斷tab是否選中，

若是選中則調用setActiveTab來激活該選項卡，讓它選中，

不然就添加一個tab。

最後達到了tab不存在就添加，存在就選中的效果。

 

瞭解:

Ext4.0也支持前端的MVC開發模式.

 

爲啥沒采用mvc的開發模式？

咱們當時由於時間方面的緣由，項目經理就決定用普通的這種

開發模式進行開發，並無採用Ext4.0這種mvc模式的特性。但

我認爲他們的核心操做流程是一致的因此對我來講去學習和使用

這種方式並無什麼難度。

二十8、lucene的概述

  lucene是一個全文檢索引擎，在進行模糊匹配的時候，他能夠

  用來替代數據庫中的like,從而在匹配準確性以及性能進行大幅度

  的提升。我在作XX項目的XX模塊的時候，就是用lucene來進行全文檢索

  用IK分詞器來進行分詞。從而實現了高亮顯示關鍵詞，分頁，排序，

  多字段，多條件的高性能搜索。在從數據中取數據生成索引的時候，

  由於表中的數據量比較大，防止一次取出所致使內存溢出問題，我採用了

  分段批量提取的方式進行，除此以外咱們對後續增長的數據根據優先級的

  不一樣採起不一樣的策略，對於那些須要及時顯示的數據咱們經過spring

  定時器  在短期內(30分鐘)進行增量索引的生成，對於那些不須要

  及時展現的數據,咱們經過spring定時器在天天晚上凌晨的時候進行索

  引的從新生成。

二十9、線程池做用

1.減小了建立和銷燬線程的次數，

每一個線程均可以被重複利用，

    可執行多個任務。

 

2.能夠根據系統的承受能力，

調整線程池中線程的數目，

防止由於消耗過多的內存，

而致使服務器宕機

(每一個線程須要大約1MB內存，線程開的越多，

消耗的內存也就越大，最後宕機)。

 

一般咱們使用的線程池是實現了ExecutorService的

ThreadPoolExecutor。

三10、jbpm是如何和spring進行整合

1.經過在spring-common.xml配置文件中配置springHelper，經過springHelper建立

processEngine，再經過processEngine獲取各類工做流的Service，

如repositoryService，executionService，historyService，taskService

 

2.在src根目錄下新建jbpm.cfg.xml文件

三11、Tomcat優化

增大內存(堆，持久代)並開啓server模式

我在作XXX項目時,用到了poi導入和導出數據,因爲公司的業務比較繁多,數據量很大,測試時報內存溢出,通過個人分析再結合上網查閱資料,發現多是tomcat內存不足,須要增大,修改配置文件後測試再也不報錯.

tomcat增大內存的方式經過修改tomcat配置文件

window下， 在bin/catalina.bat文件中最前面添加：

set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m –Xms1024m -Xmx1024m

linux下，在catalina.sh最前面增長：

JAVA_OPTS="-XX:PermSize=64M -XX:MaxPermSize=128m –Xms1024m -Xmx1024m "

-client –service

當咱們在cmd中運行-java時,黑窗口會出現-client -service這兩參數.其做用是設置虛擬機運行模式;client模式啓動比較快，但運行時性能和內存管理效率不如server模式，一般用於客戶端應用程序。server模式啓動比client慢，但可得到更高的運行性能。Windows默認爲client，若是要使用server模式，就須要在啓動虛擬機時加-server參數，以得到更高性能，對服務器端應用，推薦採用server模式，尤爲是多個CPU的系統。在Linux，Solaris上,默認值爲server模式.

JDK版本

影響虛擬機還有JDK的版本,JDK分爲32位,64位兩種版本,32位裝在32位系統,64位系統能夠裝32位和64位JDK.64位JDK性能優於32位JDK.

測試的命令 java -xmx數值m –version  報錯配置大小失敗,反之成功

 

增長Tomcat最大鏈接數

使用場景

我在作完一個XXX項目後,測試時發現併發數量增長到必定程度就會很卡,因而我想到了是否是tomcat最大鏈接數設置有限制.果不其然,配置文件中最大值才500,因而我更改了最大鏈接數,根據業務我修改了鏈接數爲2000,完美的解決了這個問題;

修改方法在conf/service.xml中默認值

<Connector port="8080" maxHttpHeaderSize="8192" maxThreads="1500"

   minSpareThreads="30" maxSpareThreads="75" enableLookups="false"

   redirectPort="8443" acceptCount="100" connectionTimeout="20000"

   disableUploadTimeout="true" />,修改maxthreads的值便可

 

 

tomcat進行gzip壓縮從而下降網絡傳輸量

tomcat 壓縮設置tomcat壓縮gzip啓用

 

HTTP 壓縮能夠大大提升瀏覽網站的速度，它的原理是，

在客戶端請求服務器對應資源後，從服務器端將資源文件壓縮，

再輸出到客戶端，由客戶端的瀏覽器負責解壓縮並瀏覽。

相對於普通的瀏覽過程HTML ,CSS,Javascript , Text ，

它能夠節省60%左右的流量。更爲重要的是，它能夠對動態生成的，

包括CGI、PHP , JSP , ASP , Servlet,SHTML等輸出的網頁也能進行壓縮，

壓縮效率也很高。

啓用tomcat 的gzip壓縮

要使用gzip壓縮功能，你須要在Connector節點中加上以下屬性

 

記住來源：http://www.qi788.com/info-42.html

 

compression="on" 打開壓縮功能

compressionMinSize="50" 啓用壓縮的輸出內容大小，默認爲2KB

noCompressionUserAgents="gozilla, traviata" 對於如下的瀏覽器，不啓用壓縮

compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain"　哪些資源類型須要壓縮

<Connector port="80" protocol="HTTP/1.1"   

           connectionTimeout="20000"   

           redirectPort="8443" executor="tomcatThreadPool" URIEncoding="utf-8"   

           compression="on"   

           compressionMinSize="50" noCompressionUserAgents="gozilla, traviata"   

          compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain" />

 

三12、memcached的介紹

memcached是一個用C語言開發的分佈式的緩存，內部基於相似hashMap的結構。

它的優勢是協議簡單，內置內存存儲，而且他的

分佈式算法是在客戶端完成的，不須要服務器端進行

通訊，咱們當時在作項目的時候由於考慮到項目

的高可用性高擴展性，所以在服務器部署方面採用

了apache+jk+tomcat這種負載均衡的方式，可是也帶來了一個問題

就是session共享的問題，雖然能夠經過session複製來解決這個

問題，可是在性能方面存在缺陷，因此最後咱們採用了

用memcached來存儲session，這樣既解決了session共享

問題，也解決了session複製那種方式所產生的性能問題。

 

瞭解(沒必要主動說，但別人問的話必定要知道)

 

memcached是以KEY-VALUE的方式進行數據存儲的，

KEY的大小限制：Key（max）<=250個字符；

VALUE在存儲時有限制：Value（max）<= 1M；

 

根據最近最少使用原則刪除對象即LRU.

 

 

memcached默認過時時間：ExpiresTime（max）= 30（days）

 

 優化篇

1、代碼優化

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

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

2.工具類的封裝(方便代碼的維護，使代碼結構更加清晰不臃腫，保證團隊裏代碼       質量一致性)

3.公共部分的提取

 

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

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

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

3.公共部分的提取

4.一般要用stringbuffer替代string加號拼接

 

2、業務優化

  咱們作項目的時候業務優化這方面最主要是從用戶體驗度角度進行考慮,減小用戶操       做的步驟提升工做效率，一般有如下幾種：

　　1.能夠經過tabindex屬性來改變tab鍵盤的操做順序

　　2.能夠經過回車鍵來進行搜索或者提交操做

　　3.對於單選按鈕和複選按鈕能夠經過操做後面的文原本選擇前面的單選按鈕以及複選        按鈕

　　4.添加的信息要按照id倒序進行排列

　　5.進行搜索操做時加入js loading操做（不只告訴用戶所進行的請求正在被處理，而       且防止用戶屢次點擊提交操做）

　　6.當進行刪除操做的時候要彈出提示框，警告用戶要進行刪除操做，是否確認。

　　7.根據returnURL在用戶登陸成功後直接跳到想要訪問的資源。

　　8.進行刪除操做時經過confirm提示用戶是否確認刪除操做，操做完後提示操做是否       成功。

　　9.減小用戶操做的步驟

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

 

 

  必背，必作:

　1.能夠經過回車鍵來進行搜索或者提交操做

　　2.添加的信息要按照id倒序進行排列

　　3.進行搜索操做時加入js loading操做（不只告訴用戶所進行的請求正在被處理，並且防止用戶屢次點擊提交操做）

　　4.當進行刪除操做的時候要彈出提示框，警告用戶要進行刪除操做，是否確認,若是刪除成功則彈出提示框告訴用戶。

　　5.減小用戶操做的步驟

6.經過ztree，以及kindeiditor來提升用戶的體驗度

 

3、sql優化

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

 

  2、儘可能多使用COMMIT如對大數據量的分段批量提交釋放了資源，減輕了服務器壓力

 

  3、在寫sql語句的話，儘可能保持每次查詢的sql語句字段用大寫，由於oracle老是先解析      sql語句，把小寫的字母轉換成大寫的再執行

 

  四、用UNION-ALL 替換UNION，由於UNION-ALL不會過濾重複數據，所執行效率        要快於UNION,而且UNION能夠自動排序，而UNION-ALL不會

 

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

     

Sql優化精簡版：

 

1.(重點)(必須說) SELECT語句中避免使用 *，

                 儘可能應該根據業務需求按字段進行查詢

 

舉例：若是表中有個字段用的是clob或者是blob這種大數據字段的話，

     他們的查詢應該根據業務須要來進行指定字段的查詢，切記勿直接用*

 

 

2.(重點) 刪除重複記錄(oracle)：

最高效的刪除重複記錄方法 ( 由於使用了ROWID)例子：

DELETE  FROM  EMP E  WHERE  E.ROWID > (SELECT MIN(X.ROWID)

FROM  EMP X  WHERE  X.EMP_NO = E.EMP_NO);

 

3. 用>=替換>

        

    如一個表有100萬記錄，一個數值型字段A，

      A=0時，有30萬條；

      A=1時，有30萬條；

      A=2時，有39萬條；

      A=3時，有1萬記錄。

      那麼執行 A>2 與 A>=3 的效果就有很大的區別了，由於 A>2 時，

      ORACLE會先找出爲2的記錄索引再進行比較，

      而A>=3時ORACLE則直接找到=3的記錄索引。

 

4.(重點)儘可能多使用COMMIT

如對大數據量的分段批量提交

 

 

5. (重點)用NOT EXISTS 或（外鏈接+判斷爲空）方案 替換 NOT IN操做符

    

    此操做是強列推薦不使用的，由於它不能應用表的索引。

    推薦方案：用NOT EXISTS 或（外鏈接+判斷爲空）方案代替

 

 

6.(重點 必須說)LIKE操做符(大數據的全文檢索使用luncene)(solr)

    由於使用like不當，會致使性能問題，緣由是like在左右兩邊都有

    %的時候，不會使用索引。

        

    如LIKE '%5400%' 這種查詢不會引用索引，

    而LIKE 'X5400%' 則會引用範圍索引。

 

 

    一個實際例子：

    查詢營業編號 YY_BH LIKE '%5400%' 這個條件會產生全表掃描，

    若是改爲         YY_BH LIKE 'X5400%' OR YY_BH LIKE 'B5400%'

    則會利用    YY_BH  的索引進行兩個範圍的查詢，性能確定大大提升。

 

 

 

 

 

7.(重點,必須說)避免在索引列上使用計算和函數,這樣索引就不能使用

   舉例:

低效：

SELECT … FROM  DEPT  WHERE SAL * 12 > 25000;

高效:

SELECT … FROM DEPT WHERE SAL > 25000/12;

 

 

8.(重點 必須說)用UNION-ALL 替換UNION，

由於UNION-ALL不會過濾重複數據並且不會自動排序，

所執行效率要快於UNION。

 

 

 

 

9. （優化,重點,3個方面 a.緩存 b.分段批量 c.存儲過程）減小訪問數據庫的次數

舉例:如果批量刪除多條數據，能夠用  delete  from tableName where id

                                   in (1,2,3)

     而不要用多條delete語句進行刪除

 

 

10.（重點 必須說）用TRUNCATE替代DELETE

TRUNCATE不記錄日誌，DELETE記錄日誌，因此TRUNCATE要快於DELETE

可是一旦用TRUNCATE進行刪除就不能進行恢復,TRUNCATE是刪除整張表的數據

不能加where條件。

==================================================================

mysql,sqlserver中若是

id爲自增類型，那麼若是用TRUNCATE刪除，則id字段再插入數據時從1開始，

若是delete刪除的話，則從刪除以前的id的值繼續增加。

 

     

 

4、防sql注入

       針對防sql注入，咱們一般是這樣作的：

           首先在前臺頁面對用戶輸入信息進行js驗證，對一些特殊字符進行屏蔽，

   好比：or ,單引號，--，= ，還有就是限制用戶名輸入的長度，咱們通常

           將其限制在6---13位。另外，對於用戶的敏感信息咱們進行Md5加密，還有

   ，爲了增長用戶體驗度和用戶友好度，爲了避免使用戶看到一些詳細的異常信息

   咱們會進行錯誤信息頁面的定製，像404,500錯誤。另外一個我層面講，這樣作

   也是爲了保護咱們的一些重要信息。此外，咱們會給特定的人分配定定的權限

   ，而不是給其分配管理員權限！

 sql注入

 

所謂SQL注入，就是經過一些含有特殊字符的sql語句發送到服務器欺騙服務器並進行攻擊。（特殊字符：or, 單引號，--，空格）

 Sql注入的防禦

1.永遠不要信任用戶的輸入。對用戶的輸入進行校驗，能夠經過正則表達式（js正則或者java後臺正則），或限制長度；對單引號和雙"-"進行轉換等。

2.永遠不要使用動態拼裝sql，使用參數化的sql。（永遠不要使用+號拼接sql字符串，而是使用？傳參的方式進行）

3.不要給用戶過高的權限而根據需求進行賦權

4.對敏感信息進行加密 如md5(單向加密不可逆轉)。

5.自定義錯誤頁面。目的是爲了避免把咱們的程序的bug暴露在別有用心的人的面前。而去不會讓用戶看到報錯的頁面，也提升了用戶的體驗度。

 

SQL注入防範

使用參數化的過濾性語句
　　要防護SQL注入，用戶的輸入就絕對不能直接被嵌入到SQL語句中。偏偏相反，用戶的輸入必須進行過濾，或者使用參數化的語句。參數化的語句使用參數而不是將用戶輸入嵌入到語句中。在多數狀況中，SQL語句就得以修正。而後，用戶輸入就被限於一個參數。

輸入驗證

　　檢查用戶輸入的合法性，確信輸入的內容只包含合法的數據。數據檢查應當在客戶端和服務器端（java代碼）都執行之因此要執行服務器端驗證，是爲了彌補客戶端驗證機制脆弱的安全性。
　　在客戶端，攻擊者徹底有可能得到網頁的源代碼，修改驗證合法性的腳本（或者直接刪除腳本），而後將非法內容經過修改後的表單提交給服務器。所以，要保證驗證操做確實已經執行，惟一的辦法就是在服務器端也執行驗證。你能夠使用許多內建的驗證對象，例如Regular Expression Validator，它們可以自動生成驗證用的客戶端腳本，固然你也能夠插入服務器端的方法調用。若是找不到現成的驗證對象，你能夠經過Custom Validator本身建立一個。

錯誤消息處理

　　防範SQL注入，還要避免出現一些詳細的錯誤消息，由於黑客們能夠利用這些消息。要使用一種標準的輸入確認機制來驗證全部的輸入數據的長度、類型、語句、企業規則等。

加密處理

將用戶登陸名稱、密碼等數據加密保存。加密用戶輸入的數據，而後再將它與數據庫中保存的數據比較，這至關於對用戶輸入的數據進行了「消毒」處理，用戶輸入的數據再也不對數據庫有任何特殊的意義，從而也就防止了攻擊者注入SQL命令。

存儲過程來執行全部的查詢

　　SQL參數的傳遞方式將防止攻擊者利用單引號和連字符實施攻擊。此外，它還使得數據庫權限能夠限制到只容許特定的存儲過程執行，全部的用戶輸入必須聽從被調用的存儲過程的安全上下文，這樣就很難再發生注入式攻擊了。

使用專業的漏洞掃描工具

　　攻擊者們目前正在自動搜索攻擊目標並實施攻擊，其技術甚至能夠輕易地被應用於其它的Web架構中的漏洞。企業應當投資於一些專業的漏洞掃描工具，如大名鼎鼎的Acunetix的Web漏洞掃描程序等。一個完善的漏洞掃描程序不一樣於網絡掃描程序，它專門查找網站上的SQL注入式漏洞。最新的漏洞掃描程序能夠查找最新發現的漏洞。

確保數據庫安全

　　鎖定你的數據庫的安全，只給訪問數據庫的web應用功能所需的最低的權限，撤銷沒必要要的公共許可，使用強大的加密技術來保護敏感數據並維護審查跟蹤。若是web應用不須要訪問某些表，那麼確認它沒有訪問這些表的權限。若是web應用只須要只讀的權限，那麼就禁止它對此表的 drop 、insert、update、delete 的權限，並確保數據庫打了最新補丁。

安全審評

在部署應用系統前，始終要作安全審評。創建一個正式的安全過程，而且每次作更新時，要對全部的編碼作審評。開發隊伍在正式上線前會作很詳細的安全審評，而後在幾周或幾個月以後他們作一些很小的更新時，他們會跳過安全審評這關， 「就是一個小小的更新，咱們之後再作編碼審評好了」。請始終堅持作安全審評。

5、數據庫中經常使用術語：

ddl:數據定義語言 Create Drop Alter

dml:數據操縱語言 insert update delete select

dcl:數據控制語言 grant revoke

tcl:事務控制語言 commit rollback

深刻java虛擬機以及大數據

 

 

1.jvm的相關概念

當List放了大量的數據超過jvm中所能容納的內存後，就會發生堆溢出。

當遞歸調用沒有臨界退出條件就會出現 棧溢出。

 

當批量導入大量數據或者用dom4j解析大的xml文件的時候，

會出現 堆溢出，這個時候能夠經過分段批量提交以及用

sax代替dom4j來解決問題。

 

heap(堆)，stack(棧)

 

jvm的結構細分及其概述?

 

Java 虛擬機有一個堆，堆是運行時數據區域，

全部類實例和數組的內存均今後處分配。

堆是在 Java 虛擬機啓動時建立的。」

「在JVM中堆以外的內存稱爲非堆內存(Non-heap memory)」。

能夠看出JVM主要管理兩種類型的內存：堆和非堆。

簡單來講堆就是Java代碼可及的內存，是留給開發人員使用的；

非堆就是JVM留給本身用的。

 

jvm 內存結構？

堆： 邏輯上是連續,物理上能夠處於不連續的內存空間中，

     裏面存儲的是對象實例以及數組。能夠細分爲新生代，老生代。

     經過-Xmx和-Xms控制大小。

 

虛擬機棧：基本數據類型，對象引用(地址，指針)。

 

本地方法棧（瞭解）:它與虛擬機棧發揮的做用差很少，區別在於虛擬機棧爲java方法

的執行提供服務，而本地方法棧爲虛擬機使用到的Native(本地)方法服務。

 

方法區：放了所加載的類的信息（名稱、修飾符等）、類中的靜態變量、

        類中定義爲final類型的常量、類中的Field信息、類中的方法信息

        在Sun JDK中這塊區域對應的爲PermanetGeneration，又稱爲持久代，

        默認爲64M，可經過-XX:PermSize以及-XX:MaxPermSize來指定其大小

   

在服務器啓動的時候報內存溢出是由於方法區過小，也就至關於持久代的內存過小。

經過-XX:PermSize以及-XX:MaxPermSize來指定其大小，能夠解決這個問題。

 

 

常量池是方法區的一部分,用來存儲常量信息。如String就存儲在

常量池中。

 

計數器（瞭解）:經過該計數器的值來選取下一條要執行的字節碼指令。

 

GC是什麼，爲何要有GC？

GC就是垃圾回收，java這種語言是動態分配內存大小的，而且依靠

垃圾回收機制來完成對分配內存空間的回收，從而來避免內存溢出的問題，

也在必定程度上下降了程序員工做的複雜度。

 

jvm中的GC採用了generation（分代回收）算法，

由於大多數的對象存活的時間比較短，

而少部分的對象纔可以長時間存活。

所以，jvm將堆內存劃分爲年輕代（young generation）和

年老代（old generation）。

年輕代中的對象一般創建時間不久，且大部分生命週期也很短；

年老代中的對象則已經建立比較久了，

其聲明週期也相對年輕代比較長。

按照上面的劃分，jvm在作GC時也進行了區別對待，

對年輕代GC會相對比較頻繁，且採用了copying(複製)算法；

年老代的GC相對比較少，且採用的是tracing算法的一種，

是標記-清除-壓縮。

 

JVM內存限制(最大值)

 

JVM內存的最大值跟操做系統有很大的關係。

簡單的說就32位處理器雖然 可控內存空間有4GB,

可是具體的操做系統會給一個限制，

這個限制通常是2GB-3GB

（通常來講Windows系統下爲1.5G-2G，Linux系統 下爲2G-3G），

而64bit以上的處理器就不會有限制了。

 

Java 監視和管理控制檯：

JConsole 使您可以在運行時監視各類 JVM 資源統計信息。

這種特性特別適用於檢測死鎖、內存泄漏。

它能夠鏈接到一個本地或遠程 JVM 並可用來進行監視：

線程狀態（包括相關的鎖）

內存使用狀況

垃圾收集

運行時信息

JVM 信息

 

jvm的調優?

 

開啓-Server模式，增大堆的大小，以及持久代的大小，從而

提升程序的運行效率，而且將初始堆大小和最大堆大小設置爲

同樣的值從而避免了堆增加會帶來額外壓力。持久代大小的設置

同理，也設置爲初始大小和最大大小同樣大。

 

jvm的類加載機制?  jvm中類的生命週期？

 

生命週期：加載、鏈接、初始化，使用，卸載

 

 

對象基本上都是在jvm的堆區中建立，在建立對象以前，

會觸發類加載（加載、鏈接、初始化），

當類初始化完成後，

根據類信息在堆中實例化類對象，

初始化非靜態變量、非靜態代碼以及默認構造方法，

當對象使用完以後會在合適的時候被jvm垃圾收集器回收。

 

要通過三步：加載（Load），連接（Link），初始化（Initializ）。

其中連接又可分爲校驗（Verify），準備（Prepare），解析（Resolve）三步。

ClassLoader就是用來裝載的。經過指定的className，找到二進制碼，

生成Class實例，放到JVM中。

 

ClassLoader從頂向下分爲 :

 

Bootstrap ClassLoader:引導類加載器，

它負責加載Java的核心類(如rt.jar)

 

Extension ClassLoader:擴展類加載器,

它負責加載JRE的擴展目錄

（JAVA_HOME/jre/lib/ext）中的JAR包

 

System ClassLoader:系統（也稱爲應用）類加載器，

它負責在JVM被啓動時加載來自在命令java中的-classpath

中的JAR包

 

User-Defined ClassLoader：用戶自定義的類加載器

 

linux中的命令：

 

ps -ef | grep :查看進程信息

 

vi:文件編輯命令

 

more:分頁查看命令

 

top:經常使用的性能分析工具,可以實時顯示系統中各個進程的資源佔用情況

 

ifconfig:顯示或配置網絡設備的命令

 

ping:它一般用來測試與目標主機的連通性

 

rsync、scp：文件同步命令

2.雲計算+大數據的具體技術實現方案:

 

Hadoop是一個可以對大量數據進行分佈式處理的軟件框架。

它以並行的方式工做，經過並行處理加快處理速度,

維護多個工做數據副本,

具備可伸縮性，可以處理 PB 級數據.

 

hadoop 由許多元素構成。其最底部是HDFS，

它存儲 Hadoop 集羣中全部存儲節點上的文件。

HDFS的上一層是MapReduce 引擎.

 

hadoop下的子項目:

HDFS:Hadoop分佈式文件系統

MapReduce：並行計算框架（創建在HDFS上的）

HBase: 相似Google BigTable的分佈式NoSQL 列數據庫

Hive：數據倉庫工具

Zookeeper：分佈式鎖設施

Pig: 大數據分析平臺，爲用戶提供多種接口

 

行業知識(瞭解):

存儲容量：是該存儲設備上能夠存儲數據的最大數量，一般使用千字節（kb kilobyte）、兆字節（MB megabyte）、吉字節（GB, gigabyte）、太字節（TB ，terabyte）和PB(Petabyte)、EB(Exabyte)等來衡量。

1KB=2(10)B=1024B； 括號中的數字爲2的指數(即多少次方)

1MB=2(10)KB=1024KB=2(20)B；

1GB=2(10)MB=1024MB=2(30)B。

1TB=2(10) GB=1024GB=2(40)B

1PB=2(10) TB=1024TB=2(50)B

1EB=2(10) PB=1024PB=2(60)B

1Byte(相當於一個英文字母，您的名字相當6Bytes(6B)。

Kilobyte(KB)=1024B相當於一則短篇故事的內容。

Megabyte(MB)=l024KB相當於一則短篇小說的文字內容。

Gigabyte(GB)=1024MB相當於貝多芬第五樂章交響曲的樂譜內容。

Terabyte(TB)=1024GB相當於一家大型醫院中全部的X光圖片資訊量。

Petabyte(PB)=l024TB相當於50%的全美學術研究圖書館藏書資訊內容。

Exabyte (EB)=1024PB；5EB相當於至今全世界人類所講過的話語。

Zettabyte(ZB)=1024EB如同全世界海灘上的沙子數量總和。

Yottabyte(YB)=1024ZB相當於7000位人類體內的微細胞總和。