J2EE筆試面試題

Java工程師（程序員）面題

Struts,Spring,Hibernate三大框架

1.Hibernate工作原理及爲什麼要用？

原理： 1.讀取並解析配置文件 2.讀取並解析映射信息，創建SessionFactory 3.打開Session 4.創建事務Transation 5.持久化操作 6.提交事務 7.關閉Session 8.關閉SesstionFactory

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

2．Hibernate是如何延遲加載?

1. Hibernate2延遲加載實現：a)實體對象 b)集合（Collection）

2. Hibernate3 提供了屬性的延遲加載功能當Hibernate在查詢數據的時候，數據並沒有存在與內存中，當程序真正對數據的操作時，對象才存在與內存中，就實現了延遲加載，他節省了服務器的內存開銷，從而提高了服務器的性能。

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

類與類之間的關係主要體現在表與表之間的關係進行操作，它們都是對對象進行操作，我們程序中把所有的表與類都映射在一起，它們通過配置文件中的many-to-one、one-to-many、many-to-many

4.Struts1流程：

1、客戶端瀏覽器發出HTTP請求。2、根據web.xml配置，該請求被ActionServlet接收。3、根據struts-config.xml配置， ActionServlet先將請求中的參數填充到ActionForm中，然後ActionServlet再將請求發送到Action 進行處理。4、是否驗證，需要驗證則調用ActionForm的validate方法，驗證失敗則跳轉到input，成功則繼續。5、Action從ActionForm獲得數據，調用javabean 中的業務方法處理數據。6、Action返回ActionForward對象，跳轉到相應JSP頁面或Action。7、返回HTTP響應到客戶端瀏覽器。

MVC設計模式：modal：“模型” 也稱業務邏輯，是正真完成任務的代碼,相當與JavaBeanview：視圖，其實就是顯示界面，相當於JSPcontroller：控制器，他控制模型和視圖的交互過程，相當於servletstruts1是基於MVC設計模式hibernate是基於ORM對象關係映射

5.struts是什麼？

struts1是基於JSP和servlet的一個開源的Web應用框架，使用的是MVC的設計模式struts2是基於webwork技術的框架，是sun和webwork公司聯手開發的一個功能非常齊全的框架，struts2和struts1沒有任何關係，是一個全新的框架

6.spring是什麼？

spring是一個集成了許多第三方框架的大雜燴，其核心技術是IOC（控制反轉，也稱依賴注入）和AOP（面向切面編程）

7.hibernate是什麼？

hibernate是基於ORM對象關係映射（完成對象數據到關係數據映射的機制）實現的,做數據持久化的工具

8.JSF是什麼？

JavaServer Face是基於組件的web開發框架，跟sturts差不多的框架

9.數據庫裏面的索引和約束是什麼?

索引是爲了提高數據的檢索速度，索引是建立在數據表上，根據一個或多個字段建立的約束是爲了保持數據的完整性，約束有非空約束，主鍵約束，外鍵約束等等。

10.spring是什麼

這個問題，往往可以通過我們爲什麼要使用spring這個問題來切入：AOP 讓開發人員可以創建非行爲性的關注點，稱爲橫切關注點，並將它們插入到應用程序代碼中。使用 AOP 後，公共服務（比如日誌、持久性、事務等）就可以分解成方面並應用到域對象上，同時不會增加域對象的對象模型的複雜性。 IOC 允許創建一個可以構造對象的應用環境，然後向這些對象傳遞它們的協作對象。正如單詞倒置所表明的，IOC 就像反過來的 JNDI。沒有使用一堆抽象工廠、服務定位器、單元素（singleton）和直接構造（straight construction），每一個對象都是用其協作對象構造的。因此是由容器管理協作對象（collaborator）。 Spring即使一個AOP框架，也是一IOC容器。 Spring 最好的地方是它有助於您替換對象。有了 Spring，只要用 JavaBean 屬性和配置文件加入依賴性（協作對象）。然後可以很容易地在需要時替換具有類似接口的協作對象。

11.用自己的話簡要闡述struts2的執行流程。

Struts 2框架本身大致可以分爲3個部分：核心控制器FilterDispatcher、業務控制器Action和用戶實現的企業業務邏輯組件。核心控制器FilterDispatcher是Struts 2框架的基礎，包含了框架內部的控制流程和處理機制。業務控制器Action和業務邏輯組件是需要用戶來自己實現的。用戶在開發Action和業務邏輯組件的同時，還需要編寫相關的配置文件，供核心控制器FilterDispatcher來使用。

Struts 2的工作流程相對於Struts 1要簡單，與WebWork框架基本相同，所以說Struts 2是WebWork的升級版本。基本簡要流程如下：1、客戶端瀏覽器發出HTTP請求。2、根據web.xml配置，該請求被FilterDispatcher接收。3、根據struts.xml配置，找到需要調用的Action類和方法，並通過IoC方式，將值注入給Aciton。4、Action調用業務邏輯組件處理業務邏輯，這一步包含表單驗證。5、Action執行完畢，根據struts.xml中的配置找到對應的返回結果result，並跳轉到相應頁面。6、返回HTTP響應到客戶端瀏覽器。

1 Action是不是線程安全的？如果不是有什麼方式可以保證Action的線程安全？如果是，說明原因

不是

聲明局部變量，或者擴展RequestProcessor，讓每次都創建一個Action，或者在spring中用scope="prototype"來管理

2.MVC，分析一下struts是如何實現MVC的

m：JavaBean 或結合 EJB 組件或者pojo構成

c：Action 來實現

v：一組 JSP 文件及其標籤構成。

3.struts中的幾個關鍵對象的作用(說說幾個關鍵對象的作用)

Action：控制器類，ActionForm：表單對象，DynaValidatorForm：動態form，ActonMapping：配置文件中action節點的信息......

4.說說AOP和IOC的概念以及在spring中是如何應用的

AOP:面向方面編程，ioc：依賴注入；聲明式事務和編程式事務積極一些通用部分

5.Hibernate有哪幾種查詢數據的方式

hql查詢，sql查詢，條件查詢

6.load()和get()的區別

hibernate對於load方法認爲該數據在數據庫中一定存在，可以放心的使用代理來延遲加載，load默認支持延遲加載，在用到對象中的其他屬性數據時才查詢數據庫，但是萬一數據庫中不存在該記錄，只能拋異常ObjectNotFoundEcception；所說的load方法拋異常是指在使用該對象的數據時，數據庫中不存在該數據時拋異常，而不是在創建這個對象時。由於session中的緩存對於hibernate來說是個相當廉價的資源，所以在 load時會先查一下session緩存看看該id對應的對象是否存在，不存在則創建代理（load時候之查詢一級緩存，不存在則創建代理）。get() 現在一級緩存找，沒有就去二級緩存找，沒有就去數據庫找，沒有就返回null ；而對於get方法，hibernate一定要獲取到真實的數據，否則返回null。

7.談談hibernate的延遲加載和openSessionInView

延遲加載要在session範圍內，用到的時候再加載；opensessioninview是在web層寫了一個

filter來打開和關閉session，這樣就表示在一次request過程中session一直開着，保證了延遲

加載在session中的這個前提。

8.spring的事務有幾種方式？談談spring事務的隔離級別和傳播行爲。

聲明事務和編程事務

隔離級別：

- DEFAULT使用數據庫默認的隔離級別

- READ_UNCOMMITTED會出現髒讀，不可重複讀和幻影讀問題

- READ_COMMITTED會出現重複讀和幻影讀

- REPEATABLE_READ會出現幻影讀

- SERIALIZABLE最安全，但是代價最大，性能影響極其嚴重

和傳播行：

- REQUIRED存在事務就融入該事務，不存在就創建事務

- SUPPORTS存在事務就融入事務，不存在則不創建事務

- MANDATORY存在事務則融入該事務，不存在，拋異常

- REQUIRES_NEW總是創建新事務

- NOT_SUPPORTED存在事務則掛起，一直執行非事務操作

- NEVER總是執行非事務，如果當前存在事務則拋異常

- NESTED嵌入式事務

9.Hibernate中的update()和saveOrUpdate()的區別.

摘自hibernate說明文檔：

saveOrUpdate()做下面的事:

如果對象已經在本session中持久化了，不做任何事

如果另一個與本session關聯的對象擁有相同的持久化標識(identifier)，拋出一個異常

如果對象沒有持久化標識(identifier)屬性，對其調用save()

如果對象的持久標識(identifier)表明其是一個新實例化的對象，對其調用save()

如果對象是附帶版本信息的（通過 <version>或 <timestamp>）並且版本屬性的值表明其是一個新實例化的對象，save()它。否則update() 這個對象

10.Spring對多種ORM框架提供了很好的支持，簡單描述在Spring中使用Hibernate的方法，並結合事務管理。

getHiberanteTemplate裏面提供了save，update，delete，find等方法。

簡單說一個：如果配置了聲明式事務，當執行getHibernateTemplate的各種方法的時候，事務會

自動被加載

如果沒有配置事務，那麼以上操作不會真正的被同步到數據庫，除非配置了hibernate的

autocommit=true

8.spring的事務有幾種方式？談談spring事務的隔離級別和傳播行爲。

spring事務分兩種形式，聲明式事務和編程式事務，spring提供了一個事務的接口

PaltformTractionManager接口，針對不同的事務，spring進行了不同的實現,對hibernate事務

的實現HIbernateTractionManager,對JDBC的JdbcTractionManager，

DataSourceTractionManager以及JdoTractionManager。接口platformTractionManager提供了三

個方法，獲取事務，提交和回滾的方法。

******************************************************************************

分享面試題二】Spring,hibernate,struts的面試筆試題（含答案）

（聲明：這裏不是爲其他商業利益，是爲學習討論使用）

【鄭重聲明】：單純接分將被刪帖，希望大家有自己的感觸

Hibernate工作原理及爲什麼要用？

原理：

1.讀取並解析配置文件

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

3.打開Sesssion

4.創建事務Transation

5.持久化操作

6.提交事務

7.關閉Session

8.關閉SesstionFactory

爲什麼要用：

1. 對JDBC訪問數據庫的代碼做了封裝，大大簡化了數據訪問層繁瑣的重複性代碼。

2. Hibernate是一個基於JDBC的主流持久化框架，是一個優秀的ORM實現。他很大程度的簡化DAO層的編碼工作

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

4. hibernate的性能非常好，因爲它是個輕量級框架。映射的靈活性很出色。它支持各種關係數據庫，從一對一到多對多的各種複雜關係。

2． Hibernate是如何延遲加載?

1. Hibernate2延遲加載實現：a)實體對象 b)集合（Collection）

2. Hibernate3 提供了屬性的延遲加載功能

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

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

類與類之間的關係主要體現在表與表之間的關係進行操作，它們都市對對象進行操作，我們程序中把所有的表與類都映射在一起，它們通過配置文件中的many-to-one、one-to-many、many-to-many、

4．說下Hibernate的緩存機制

1. 內部緩存存在Hibernate中又叫一級緩存，屬於應用事物級緩存

2. 二級緩存：

a) 應用及緩存

b) 分佈式緩存

條件：數據不會被第三方修改、數據大小在可接受範圍、數據更新頻率低、同一數據被系統頻繁使用、非關鍵數據

c) 第三方緩存的實現

5． Hibernate的查詢方式

Sql、Criteria,object comptosition

Hql：

1、屬性查詢

2、參數查詢、命名參數查詢

3、關聯查詢

4、分頁查詢

5、統計函數

6．如何優化Hibernate？

1.使用雙向一對多關聯，不使用單向一對多

2.靈活使用單向一對多關聯

3.不用一對一，用多對一取代

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

5.一對多集合使用Bag,多對多集合使用Set

6. 繼承類使用顯式多態

7. 表字段要少，表關聯不要怕多，有二級緩存撐腰

7． Struts工作機制？爲什麼要使用Struts？

工作機制：

Struts的工作流程:

在web應用啓動時就會加載初始化ActionServlet,ActionServlet從

struts-config.xml文件中讀取配置信息,把它們存放到各種配置對象

當ActionServlet接收到一個客戶請求時,將執行如下流程.

-(1)檢索和用戶請求匹配的ActionMapping實例,如果不存在,就返回請求路徑無效信息;

-(2)如果ActionForm實例不存在,就創建一個ActionForm對象,把客戶提交的表單數據保存到ActionForm對象中;

-(3)根據配置信息決定是否需要表單驗證.如果需要驗證,就調用ActionForm的validate()方法;

-(4)如果ActionForm的validate()方法返回null或返回一個不包含ActionMessage的ActuibErrors對象, 就表示表單驗證成功;

-(5)ActionServlet根據ActionMapping所包含的映射信息決定將請求轉發給哪個Action,如果相應的 Action實例不存在,就先創建這個實例,然後調用Action的execute()方法;

-(6)Action的execute()方法返回一個ActionForward對象,ActionServlet在把客戶請求轉發給 ActionForward對象指向的JSP組件;

-(7)ActionForward對象指向JSP組件生成動態網頁,返回給客戶;

爲什麼要用：

JSP、Servlet、JavaBean技術的出現給我們構建強大的企業應用系統提供了可能。但用這些技術構建的系統非常的繁亂，所以在此之上，我們需要一個規則、一個把這些技術組織起來的規則，這就是框架，Struts便應運而生。

基於Struts開發的應用由3類組件構成：控制器組件、模型組件、視圖組件

8． Struts的validate框架是如何驗證的？

在struts配置文件中配置具體的錯誤提示，再在FormBean中的validate()方法具體調用。

9．說下Struts的設計模式

MVC模式: web應用程序啓動時就會加載並初始化ActionServler。用戶提交表單時，一個配置好的ActionForm對象被創建，並被填入表單相應的數據，ActionServler根據Struts-config.xml文件配置好的設置決定是否需要表單驗證，如果需要就調用ActionForm的 Validate（）驗證後選擇將請求發送到哪個Action，如果Action不存在，ActionServlet會先創建這個對象，然後調用 Action的execute（）方法。Execute（）從ActionForm對象中獲取數據，完成業務邏輯，返回一個ActionForward對象，ActionServlet再把客戶請求轉發給ActionForward對象指定的jsp組件，ActionForward對象指定的jsp生成動態的網頁，返回給客戶。

10． spring工作機制及爲什麼要用?

1.spring mvc請所有的請求都提交給DispatcherServlet,它會委託應用系統的其他模塊負責負責對請求進行真正的處理工作。

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

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

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

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

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

爲什麼用：

{AOP 讓開發人員可以創建非行爲性的關注點，稱爲橫切關注點，並將它們插入到應用程序代碼中。使用 AOP 後，公共服務（比如日誌、持久性、事務等）就可以分解成方面並應用到域對象上，同時不會增加域對象的對象模型的複雜性。

IOC 允許創建一個可以構造對象的應用環境，然後向這些對象傳遞它們的協作對象。正如單詞倒置所表明的，IOC 就像反過來的 JNDI。沒有使用一堆抽象工廠、服務定位器、單元素（singleton）和直接構造（straight construction），每一個對象都是用其協作對象構造的。因此是由容器管理協作對象（collaborator）。

Spring即使一個AOP框架，也是一IOC容器。 Spring 最好的地方是它有助於您替換對象。有了 Spring，只要用 JavaBean 屬性和配置文件加入依賴性（協作對象）。然後可以很容易地在需要時替換具有類似接口的協作對象。}

Struts,Spring,Hibernate優缺點

Struts跟Tomcat、Turbine等諸多Apache項目一樣，是開源軟件，這是它的一大優點。使開發者能更深入的瞭解其內部實現機制。 Struts開放源碼框架的創建是爲了使開發者在構建基於Java Servlet和JavaServer Pages（JSP）技術的Web應用時更加容易。Struts框架爲開放者提供了一個統一的標準框架，通過使用Struts作爲基礎，開發者能夠更專注於應用程序的商業邏輯。Struts框架本身是使用Java Servlet和JavaServer Pages技術的一種Model-View-Controller（MVC）實現.

具體來講,

Struts的優點有:

1. 實現MVC模式，結構清晰,使開發者只關注業務邏輯的實現.

2. 有豐富的tag可以用 ,Struts的標記庫(Taglib)，如能靈活動用，則能大大提高開發效率。另外，就目前國內的JSP開發者而言，除了使用JSP自帶的常用標記外，很少開發自己的標記，或許Struts是一個很好的起點。

3. 頁面導航.頁面導航將是今後的一個發展方向，事實上，這樣做，使系統的脈絡更加清晰。通過一個配置文件，即可把握整個系統各部分之間的聯繫，這對於後期的維護有着莫大的好處。尤其是當另一批開發者接手這個項目時，這種優勢體現得更加明顯。

4. 提供Exception處理機制 .

5. 數據庫鏈接池管理

6. 支持I18N

缺點:

一、轉到展示層時，需要配置forward，每一次轉到展示層，相信大多數都是直接轉到jsp，而涉及到轉向，需要配置forward，如果有十個展示層的jsp，需要配置十次struts，而且還不包括有時候目錄、文件變更，需要重新修改forward，注意，每次修改配置之後，要求重新部署整個項目，而tomcate這樣的服務器，還必須重新啓動服務器，如果業務變更復雜頻繁的系統，這樣的操作簡單不可想象。現在就是這樣，幾十上百個人同時在線使用我們的系統，大家可以想象一下，我的煩惱有多大。

二、 Struts 的Action必需是thread－safe方式，它僅僅允許一個實例去處理所有的請求。所以action用到的所有的資源都必需統一同步，這個就引起了線程安全的問題。

三、測試不方便. Struts的每個Action都同Web層耦合在一起，這樣它的測試依賴於Web容器，單元測試也很難實現。不過有一個Junit的擴展工具Struts TestCase可以實現它的單元測試。

四、類型的轉換. Struts的FormBean把所有的數據都作爲String類型，它可以使用工具Commons-Beanutils進行類型轉化。但它的轉化都是在Class級別，而且轉化的類型是不可配置的。類型轉化時的錯誤信息返回給用戶也是非常困難的。

五、對Servlet的依賴性過強. Struts處理Action時必需要依賴ServletRequest 和ServletResponse，所有它擺脫不了Servlet容器。

六、前端表達式語言方面.Struts集成了JSTL，所以它主要使用JSTL的表達式語言來獲取數據。可是JSTL的表達式語言在Collection和索引屬性方面處理顯得很弱。

七、對Action執行的控制困難. Struts創建一個Action，如果想控制它的執行順序將會非常困難。甚至你要重新去寫Servlet來實現你的這個功能需求。

八、對Action 執行前和後的處理. Struts處理Action的時候是基於class的hierarchies，很難在action處理前和後進行操作。

九、對事件支持不夠. 在struts中，實際是一個表單Form對應一個Action類(或DispatchAction)，換一句話說：在Struts中實際是一個表單只能對應一個事件，struts這種事件方式稱爲application event，application event和component event相比是一種粗粒度的事件。

Struts重要的表單對象ActionForm是一種對象，它代表了一種應用，這個對象中至少包含幾個字段，這些字段是Jsp頁面表單中的input字段，因爲一個表單對應一個事件，所以，當我們需要將事件粒度細化到表單中這些字段時，也就是說，一個字段對應一個事件時，單純使用Struts就不太可能，當然通過結合JavaScript也是可以轉彎實現的。

2．Hibernate

Hibernate是一個開放源代碼的對象關係映射框架，它對JDBC進行了非常輕量級的對象封裝，使得Java程序員可以隨心所欲的使用對象編程思維來操縱數據庫。

Hibernate可以應用在任何使用JDBC的場合，既可以在Java的客戶端程序實用，也可以在Servlet/JSP的Web應用中使用，最具革命意義的是，Hibernate可以在應用EJB的J2EE架構中取代CMP，完成數據持久化的重任。

大多數開發機構經常採取創建各自獨立的數據持久層。一旦底層的數據結構發生改變，那麼修改應用的其餘部分使之適應這種改變的代價將是十分巨大的。 Hibernate適時的填補了這一空白，它爲Java應用提供了一個易用的、高效率的對象關係映射框架。hibernate是個輕量級的持久性框架，功能卻非常豐富。

優點：

a.Hibernate 使用 Java 反射機制而不是字節碼增強程序來實現透明性。

b.Hibernate 的性能非常好，因爲它是個輕量級框架。映射的靈活性很出色。

c.它支持各種關係數據庫，從一對一到多對多的各種複雜關係。

缺點：

它限制您所使用的對象模型。(例如，一個持久性類不能映射到多個表)其獨有的界面和可憐的市場份額也讓人不安，儘管如此，Hibernate 還是以其強大的發展動力減輕了這些風險。其他的開源持久性框架也有一些，不過都沒有 Hibernate 這樣有市場衝擊力。

上面回貼情緒有點激動，希望諒解，我不是因爲有人批評Hibernate而感到不快，而是因爲帖子裏面的觀點實在讓我覺得荒謬。不管覺得 Hibernate好也吧，不好也吧，我唯一覺得遺憾的是，在中文論壇裏面找不到一個對Hibernate的真正高水平的評價。在TSS上有一個關於 Hibernate的hot thread，跟了幾百貼，其中包括Hibernate作者Gavin和LiDO JDO的CTO，對於JDO和Hibernate有過一些激烈的爭論，我曾經耐心的看了一遍，仍然沒有發現針對Hibernate真正有力的攻擊，那些所謂的攻擊無非針對Hibernate沒有一個GUI的配置工具，沒有商業公司支持，沒有標準化等等這些站不住腳的理由。

補充幾點我的意見：

一、Hibernate是JDBC的輕量級的對象封裝，它是一個獨立的對象持久層框架，和App Server，和EJB沒有什麼必然的聯繫。Hibernate可以用在任何JDBC可以使用的場合，例如Java應用程序的數據庫訪問代碼，DAO接口的實現類，甚至可以是BMP裏面的訪問數據庫的代碼。從這個意義上來說，Hibernate和EB不是一個範疇的東西，也不存在非此即彼的關係。

二、Hibernate是一個和JDBC密切關聯的框架，所以Hibernate的兼容性和JDBC驅動，和數據庫都有一定的關係，但是和使用它的Java程序，和App Server沒有任何關係，也不存在兼容性問題。

三、Hibernate不能用來直接和Entity Bean做對比，只有放在整個J2EE項目的框架中才能比較。並且即使是放在軟件整體框架中來看，Hibernate也是做爲JDBC的替代者出現的，而不是Entity Bean的替代者出現的，讓我再列一次我已經列n次的框架結構：

傳統的架構：

1) Session Bean <-> Entity Bean <-> DB

爲了解決性能障礙的替代架構：

2) Session Bean <-> DAO <-> JDBC <-> DB

使用Hibernate來提高上面架構的開發效率的架構：

3) Session Bean <-> DAO <-> Hibernate <-> DB

就上面3個架構來分析：

1、內存消耗：採用JDBC的架構2無疑是最省內存的，Hibernate的架構3次之，EB的架構1最差。

2、運行效率：如果JDBC的代碼寫的非常優化，那麼JDBC架構運行效率最高，但是實際項目中，這一點幾乎做不到，這需要程序員非常精通JDBC，運用 Batch語句，調整PreapredStatement的Batch Size和Fetch Size等參數，以及在必要的情況下采用結果集cache等等。而一般情況下程序員是做不到這一點的。因此Hibernate架構表現出最快的運行效率。 EB的架構效率會差的很遠。

3、開發效率：在有JBuilder的支持下以及簡單的項目，EB架構開發效率最高，JDBC次之，Hibernate最差。但是在大的項目，特別是持久層關係映射很複雜的情況下，Hibernate效率高的驚人，JDBC次之，而EB架構很可能會失敗。

4、分佈式，安全檢查，集羣，負載均衡的支持

由於有SB做爲Facade，3個架構沒有區別。

四、EB和Hibernate學習難度在哪裏？

EB的難度在哪裏？不在複雜的XML配置文件上，而在於EB運用稍微不慎，就有嚴重的性能障礙。所以難在你需要學習很多EJB設計模式來避開性能問題，需要學習App Server和EB的配置來優化EB的運行效率。做EB的開發工作，程序員的大部分精力都被放到了EB的性能問題上了，反而沒有更多的精力關注本身就主要投入精力去考慮的對象持久層的設計上來。

Hibernate難在哪裏？不在Hibernate本身的複雜，實際上Hibernate非常的簡單，難在Hibernate太靈活了。

當你用EB來實現持久層的時候，你會發現EB實在是太笨拙了，笨拙到你根本沒有什麼可以選擇的餘地，所以你根本就不用花費精力去設計方案，去平衡方案的好壞，去費腦筋考慮選擇哪個方案，因爲只有唯一的方案擺在你面前，你只能這麼做，沒得選擇。

Hibernate相反，它太靈活了，相同的問題，你至少可以設計出十幾種方案來解決，所以特別的犯難，究竟用這個，還是用那個呢？這些方案之間到底有什麼區別呢？他們的運行原理有什麼不同？運行效率哪個比較好？光是主鍵生成，就有七八種方案供你選擇，你爲難不爲難？集合屬性可以用Set，可以用 List，還可以用Bag，到底哪個效率高，你爲難不爲難？查詢可以用iterator，可以用list，哪個好，有什麼區別？你爲難不爲難？複合主鍵你可以直接在hbm裏面配置，也可以自定義CustomerType，哪種比較好些？你爲難不爲難？對於一個表，你可以選擇單一映射一個對象，也可以映射成父子對象，還可以映射成兩個1:1的對象，在什麼情況下用哪種方案比較好，你爲難不爲難？

這個列表可以一直開列下去，直到你不想再看下去爲止。當你面前擺着無數的眼花繚亂的方案的時候，你會覺得幸福呢？還是悲哀呢？如果你是一個負責的程序員，那麼你一定會仔細研究每種方案的區別，每種方案的效率，每種方案的適用場合，你會覺得你已經陷入進去拔不出來了。如果是用EB，你第一秒種就已經做出了決定，根本沒得選擇，比如說集合屬性，你只能用Collection，如果是Hibernate，你會在Bag，List和Set之間來回猶豫不決，甚至搞不清楚的話，程序都沒有辦法寫。

3． Spring

它是一個開源的項目，而且目前非常活躍；它基於IoC（Inversion of Control，反向控制）和AOP的構架多層j2ee系統的框架，但它不強迫你必須在每一層中必須使用Spring，因爲它模塊化的很好，允許你根據自己的需要選擇使用它的某一個模塊；它實現了很優雅的MVC，對不同的數據訪問技術提供了統一的接口，採用IoC使得可以很容易的實現bean的裝配，提供了簡潔的AOP並據此實現Transcation Managment，等等

優點：

a. Spring能有效地組織你的中間層對象，不管你是否選擇使用了EJB。如果你僅僅使用了Struts或其他爲J2EE的 API特製的framework，Spring致力於解決剩下的問題。

b. Spring能消除在許多工程中常見的對Singleton的過多使用。根據我的經驗，這是一個很大的問題，它降低了系統的可測試性和麪向對象的程度。

c. 通過一種在不同應用程序和項目間一致的方法來處理配置文件，Spring能消除各種各樣自定義格式的屬性文件的需要。曾經對某個類要尋找的是哪個魔法般的屬性項或系統屬性感到不解，爲此不得不去讀Javadoc甚至源編碼？有了Spring，你僅僅需要看看類的JavaBean屬性。Inversion of Control的使用（在下面討論）幫助完成了這種簡化。

d.通過把對接口編程而不是對類編程的代價幾乎減少到沒有，Spring能夠促進養成好的編程習慣。

e. Spring被設計爲讓使用它創建的應用儘可能少的依賴於他的APIs。在Spring應用中的大多數業務對象沒有依賴於Spring。

f. 使用Spring構建的應用程序易於單元測試。

g.Spring能使EJB的使用成爲一個實現選擇,而不是應用架構的必然選擇。你能選擇用POJOs或local EJBs來實現業務接口，卻不會影響調用代碼。

h. Spring幫助你解決許多問題而無需使用EJB。Spring能提供一種EJB的替換物，它們適用於許多web應用。例如，Spring能使用AOP提供聲明性事務管理而不通過EJB容器，如果你僅僅需要與單個數據庫打交道，甚至不需要一個JTA實現。

i. Spring爲數據存取提供了一個一致的框架,不論是使用的是JDBC還是O/R mapping產品（如Hibernate）。

Spring確實使你能通過最簡單可行的解決辦法來解決你的問題。而這是有有很大價值的。

缺點：

使用人數不多、jsp中要寫很多代碼、控制器過於靈活，缺少一個公用控制器。

6. Java web部分

1、Tomcat的優化經驗

答:去掉對web.xml的監視，把jsp提前編輯成Servlet。

有富餘物理內存的情況，加大tomcat使用的jvm的內存

1、HTTP請求的GET與POST方式的區別

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

在客戶端，Get方式在通過URL提交數據，數據在URL中可以看到；POST方式，數據放置在HTML HEADER內提交。

（2）對於get方式，服務器端用Request.QueryString獲取變量的值，對於post方式，服務器端用Request.Form獲取提交的數據。

（3） GET方式提交的數據最多只能有1024字節，而POST則沒有此限制。

（4）安全性問題。正如在（1）中提到，使用 Get 的時候，參數會顯示在地址欄上，而 Post 不會。所以，如果這些數據是中文數據而且是非敏感數據，那麼使用 get；如果用戶輸入的數據不是中文字符而且包含敏感數據，那麼還是使用 post爲好。

62、解釋一下什麼是servlet;

答:servlet有良好的生存期的定義，包括加載和實例化、初始化、處理請求以及服務結束。這個生存期由javax.servlet.Servlet接口的init,service和destroy方法表達。

1、說一說Servlet的生命週期?

Servlet被服務器實例化後，容器運行其init方法，請求到達時運行其service方法，service方法自動派遣運行與請求對應的doXXX方法（doGet，doPost）等，當服務器決定將實例銷燬的時候調用其destroy方法。

web容器加載servlet，生命週期開始。通過調用servlet的init()方法進行servlet的初始化。通過調用service()方法實現，根據請求的不同調用不同的do***()方法。結束服務，web容器調用servlet的destroy()方法。

4、Servlet的基本架構

public class ServletName extends HttpServlet {

public void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

}

public void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

}

3、SERVLET API中forward() 與redirect()的區別？

答:前者僅是容器中控制權的轉向，在客戶端瀏覽器地址欄中不會顯示出轉向後的地址；後者則是完全的跳轉，瀏覽器將會得到跳轉的地址，並重新發送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉後的鏈接地址。所以，前者更加高效，在前者可以滿足需要時，儘量使用forward()方法，並且，這樣也有助於隱藏實際的鏈接。在有些情況下，比如，需要跳轉到一個其它服務器上的資源，則必須使用

sendRedirect()方法。

60、什麼情況下調用doGet()和doPost()？

Jsp頁面中的FORM標籤裏的method屬性爲get時調用doGet()，爲post時調用doPost()。

66、Request對象的主要方法：

setAttribute(String name,Object)：設置名字爲name的request的參數值

getAttribute(String name)：返回由name指定的屬性值

getAttributeNames()：返回request對象所有屬性的名字集合，結果是一個枚舉的實例

getCookies()：返回客戶端的所有Cookie對象，結果是一個Cookie數組

getCharacterEncoding()：返回請求中的字符編碼方式

getContentLength()：返回請求的Body的長度

getHeader(String name)：獲得HTTP協議定義的文件頭信息

getHeaders(String name)：返回指定名字的request Header的所有值，結果是一個枚舉的實例

getHeaderNames()：返回所以request Header的名字，結果是一個枚舉的實例

getInputStream()：返回請求的輸入流，用於獲得請求中的數據

getMethod()：獲得客戶端向服務器端傳送數據的方法

getParameter(String name)：獲得客戶端傳送給服務器端的有name指定的參數值

getParameterNames()：獲得客戶端傳送給服務器端的所有參數的名字，結果是一個枚舉的實例

getParametervalues(String name)：獲得有name指定的參數的所有值

getProtocol()：獲取客戶端向服務器端傳送數據所依據的協議名稱

getQueryString()：獲得查詢字符串

getRequestURI()：獲取發出請求字符串的客戶端地址

getRemoteAddr()：獲取客戶端的IP地址

getRemoteHost()：獲取客戶端的名字

getSession([Boolean create])：返回和請求相關Session

getServerName()：獲取服務器的名字

getServletPath()：獲取客戶端所請求的腳本文件的路徑

getServerPort()：獲取服務器的端口號

removeAttribute(String name)：刪除請求中的一個屬性

19、forward 和redirect的區別

forward是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL的響應內容讀取過來，然後把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的，所以它的地址欄中還是原來的地址。

redirect就是服務端根據邏輯,發送一個狀態碼,告訴瀏覽器重新去請求那個地址，一般來說瀏覽器會用剛纔請求的所有參數重新請求，所以session,request參數都可以獲取。

4、request.getAttribute() 和 request.getParameter() 有何區別?

1.getAttribute是取得jsp中用setAttribute設定的attribute

2.parameter得到的是string；attribute得到的是object

3.request.getParameter ()方法傳遞的數據，會從Web客戶端傳到Web服務器端，代表HTTP請求數據；request.setAttribute()和 getAttribute()方法傳遞的數據只會存在於Web容器內部，在具有轉發關係的Web組件之間共享。即 request.getAttribute()方法返回request範圍內存在的對象，而request.getParameter()方法是獲取 http提交過來的數據。

1. jsp有哪些內置對象?作用分別是什麼? 分別有什麼方法？

答:JSP共有以下9個內置的對象：

request 用戶端請求，此請求會包含來自GET/POST請求的參數

response 網頁傳回用戶端的迴應

pageContext 網頁的屬性是在這裏管理

session 與請求有關的會話期

application servlet 正在執行的內容

out 用來傳送回應的輸出

config servlet的構架部件

page JSP網頁本身

exception 針對錯誤網頁，未捕捉的例外

request表示HttpServletRequest對象。它包含了有關瀏覽器請求的信息，並且提供了幾個用於獲取cookie, header, 和session數據的有用的方法。

response表示HttpServletResponse對象，並提供了幾個用於設置送回瀏覽器的響應的方法（如cookies,頭信息等）

out對象是javax.jsp.JspWriter的一個實例，並提供了幾個方法使你能用於向瀏覽器回送輸出結果。

pageContext表示一個javax.servlet.jsp.PageContext對象。它是用於方便存取各種範圍的名字空間、servlet相關的對象的API，並且包裝了通用的servlet相關功能的方法。

session表示一個請求的javax.servlet.http.HttpSession對象。Session可以存貯用戶的狀態信息

applicaton 表示一個javax.servle.ServletContext對象。這有助於查找有關servlet引擎和servlet環境的信息

config表示一個javax.servlet.ServletConfig對象。該對象用於存取servlet實例的初始化參數。

page表示從該頁面產生的一個servlet實例

2. jsp有哪些動作?作用分別是什麼?

（這個問題似乎不重要，不明白爲何有此題）

答:JSP共有以下6種基本動作

jsp:include：在頁面被請求的時候引入一個文件。

jsp:useBean：尋找或者實例化一個JavaBean。

jsp:setProperty：設置JavaBean的屬性。

jsp:getProperty：輸出某個JavaBean的屬性。

jsp:forward：把請求轉到一個新的頁面。

jsp:plugin：根據瀏覽器類型爲Java插件生成OBJECT或EMBED標記

59、JSP的常用指令

isErrorPage(是否能使用Exception對象)，isELIgnored(是否忽略表達式)

3. JSP中動態INCLUDE與靜態INCLUDE的區別？

答：動態INCLUDE用jsp:include動作實現

<jsp:include page=included.jsp flush=true />它總是會檢查所含文件中的變化，適合用於包含動態頁面，並且可以帶參數靜態INCLUDE用include僞碼實現,定不會檢查所含文件的變化，適用於包含靜態頁面 <%@ include file=included.htm %>

4、兩種跳轉方式分別是什麼?有什麼區別?

（下面的回答嚴重錯誤，應該是想問forward和sendRedirect 的區別，畢竟出題的人不是專業搞文字藝術的人，可能表達能力並不見得很強，用詞不一定精準，加之其自身的技術面也可能存在一些問題，不一定真正將他的意思表達清楚了，嚴格意思上來講，一些題目可能根本就無人能答，所以，答題時要掌握主動，只要把自己知道的表達清楚就夠了，而不要去推敲原始題目的具體含義是什麼，不要一味想着是在答題）

答：有兩種，分別爲：

<jsp:include page=included.jsp flush=true>

<jsp:forward page= nextpage.jsp/>

前者頁面不會轉向include所指的頁面，只是顯示該頁的結果，主頁面還是原來的頁面。執行完後還會回來，相當於函數調用。並且可以帶參數.後者完全轉向新頁面，不會再回來。相當於go to 語句。

63、頁面間對象傳遞的方法

request，session，application，cookie等

64、JSP和Servlet有哪些相同點和不同點，他們之間的聯繫是什麼？

JSP是Servlet技術的擴展，本質上是Servlet的簡易方式，更強調應用的外表表達。JSP編譯後是"類servlet"。Servlet和JSP最主要的不同點在於，Servlet的應用邏輯是在Java文件中，並且完全從表示層中的HTML裏分離開來。而JSP的情況是Java和HTML可以組合成一個擴展名爲.jsp的文件。JSP側重於視圖，Servlet主要用於控制邏輯。

1、MVC的各個部分都有那些技術來實現?如何實現?

答:MVC是Model－View－Controller的簡寫。Model 代表的是應用的業務邏輯（通過JavaBean，EJB組件實現）， View 是應用的表示面（由JSP頁面產生），Controller 是提供應用的處理過程控制（一般是一個Servlet），通過這種設計模型把應用邏輯，處理過程和顯示邏輯分成不同的組件實現。這些組件可以進行交互和重用。

68、我們在web應用開發過程中經常遇到輸出某種編碼的字符，如iso8859-1等，如何輸出一個某種編碼的字符串？

Public String translate (String str) {

String tempStr = "";

try {

tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");

tempStr = tempStr.trim();

}

catch (Exception e) {

System.err.println(e.getMessage());

}

return tempStr;

}

1．現在輸入n個數字，以逗號，分開；然後可選擇升或者降序排序；按提交鍵就在另一頁面顯示按什麼排序，結果爲，提供reset

7. 實際項目開發

1、在eclipse中調試時，怎樣查看一個變量的值？

在要查看的變量前先設置斷點，然後選中變量，右鍵選debug as-->Java Application，打開debug透視圖，這時在Variables窗口中可以看到變量當前的值。

如果是局部變量，也可以在局部變量窗口中查看。

要知道一個方法被調用的方法調用鏈，可以在方法棧中查看。

2、你們公司使用的代碼配置管理工具是什麼？

除了說以前使用cvs，現在新項目使用svn了，還簡要說一下使用的過程，如果有可能，還說說倉庫的概念和如何使用鎖之類的細節。

3、你們的項目總金額多少，多少人開發，總共花了多少個月？

像巴巴運動網這種規模的項目，可以說是4、5個人、開發了4、5個月，費用則是4、50萬。按每人每月兩萬收入去計算，就差不多了。

7. 數據庫部分

1、用兩種方式根據部門號從高到低，工資從低到高列出每個員工的信息。

employee:

eid,ename,salary,deptid;

select * from employee order by deptid desc,salary

2、列出各個部門中工資高於本部門的平均工資的員工數和部門號，並按部門號排序

創建表：

mysql> create table employee921(id int primary key auto_increment,name varchar(5

0),salary bigint,deptid int);

插入實驗數據：

mysql> insert into employee921 values(null,'zs',1000,1),(null,'ls',1100,1),(null

,'ww',1100,1),(null,'zl',900,1) ,(null,'zl',1000,2), (null,'zl',900,2) ,(null,'z

l',1000,2) , (null,'zl',1100,2);

編寫sql語句：

（）select avg(salary) from employee921 group by deptid;

（）mysql> select employee921.id,employee921.name,employee921.salary,employee921.dep

tid tid from employee921 where salary > (select avg(salary) from employee921 where deptid = tid);

效率低的一個語句，僅供學習參考使用（在group by之後不能使用where，只能使用having，在group by之前可以使用where，即表示對過濾後的結果分組）：

mysql> select employee921.id,employee921.name,employee921.salary,employee921.dep

tid tid from employee921 where salary > (select avg(salary) from employee921 group by deptid having deptid = tid);

（）select count(*) ,tid

from (

select employee921.id,employee921.name,employee921.salary,employee921.deptid tid

from employee921

where salary >

(select avg(salary) from employee921 where deptid = tid)

) as t

group by tid ;

另外一種方式：關聯查詢

select a.ename,a.salary,a.deptid

from emp a,

(select deptd,avg(salary) avgsal from emp group by deptid ) b

where a.deptid=b.deptid and a.salary>b.avgsal;

1、存儲過程與觸發器必須講，經常被面試到?

create procedure insert_Student (_name varchar(50),_age int ,out _id int)

begin

insert into student value(null,_name,_age);

select max(stuId) into _id from student;

end;

call insert_Student('wfz',23,@id);

select @id;

mysql> create trigger update_Student BEFORE update on student FOR EACH ROW

-> select * from student;

觸發器不允許返回結果

create trigger update_Student BEFORE update on student FOR EACH ROW

insert into student value(null,'zxx',28);

mysql的觸發器目前不能對當前表進行操作

create trigger update_Student BEFORE update on student FOR EACH ROW

delete from articles where id=8;

這個例子不是很好，最好是用刪除一個用戶時，順帶刪除該用戶的所有帖子

這裏要注意使用OLD.id

觸發器用處還是很多的，比如校內網、開心網、Facebook，你發一個日誌，自動通知好友，其實就是在增加日誌時做一個後觸發，再向通知表中寫入條目。因爲觸發器效率高。而UCH沒有用觸發器，效率和數據處理能力都很低。

存儲過程的實驗步驟：

mysql> delimiter |

mysql> create procedure insertArticle_Procedure (pTitle varchar(50),pBid int,out

pId int)

-> begin

-> insert into article1 value(null,pTitle,pBid);

-> select max(id) into pId from article1;

-> end;

-> |

Query OK, 0 rows affected (0.05 sec)

mysql> call insertArticle_Procedure('傳智播客',1,@pid);

-> |

Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;

mysql> select @pid;

+------+

| @pid |

+------+

| 3 |

+------+

1 row in set (0.00 sec)

mysql> select * from article1;

+----+--------------+------+

| id | title | bid |

+----+--------------+------+

| 1 | test | 1 |

| 2 | chuanzhiboke | 1 |

| 3 | 傳智播客 | 1 |

+----+--------------+------+

3 rows in set (0.00 sec)

觸發器的實驗步驟：

create table board1(id int primary key auto_increment,name varchar(50),ar

ticleCount int);

create table article1(id int primary key auto_increment,title varchar(50)

,bid int references board1(id));

delimiter |

create trigger insertArticle_Trigger after insert on article1 for each ro

w begin

-> update board1 set articleCount=articleCount+1 where id= NEW.bid;

-> end;

-> |

delimiter ;

insert into board1 value (null,'test',0);

insert into article1 value(null,'test',1);

還有，每插入一個帖子，都希望將版面表中的最後發帖時間，帖子總數字段進行同步更新，用觸發器做效率就很高。下次課設計這樣一個案例，寫觸發器時，對於最後發帖時間可能需要用declare方式聲明一個變量，或者是用NEW.posttime來生成。

1、數據庫三範式是什麼?

第一範式（1NF）：字段具有原子性,不可再分。所有關係型數據庫系統都滿足第一範式）

數據庫表中的字段都是單一屬性的，不可再分。例如，姓名字段，其中的姓和名必須作爲一個整體，無法區分哪部分是姓，哪部分是名，如果要區分出姓和名，必須設計成兩個獨立的字段。

第二範式（2NF）：

第二範式（2NF）是在第一範式（1NF）的基礎上建立起來的，即滿足第二範式（2NF）必須先滿足第一範式（1NF）。

要求數據庫表中的每個實例或行必須可以被惟一地區分。通常需要爲表加上一個列，以存儲各個實例的惟一標識。這個惟一屬性列被稱爲主關鍵字或主鍵。

第二範式（2NF）要求實體的屬性完全依賴於主關鍵字。所謂完全依賴是指不能存在僅依賴主關鍵字一部分的屬性，如果存在，那麼這個屬性和主關鍵字的這一部分應該分離出來形成一個新的實體，新實體與原實體之間是一對多的關係。爲實現區分通常需要爲表加上一個列，以存儲各個實例的惟一標識。簡而言之，第二範式就是非主屬性非部分依賴於主關鍵字。

第三範式的要求如下：

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

所以第三範式具有如下特徵：

1，每一列只有一個值

2，每一行都能區分。

3，每一個表都不包含其他表已經包含的非主關鍵字信息。

例如，帖子表中只能出現發帖人的id，而不能出現發帖人的id，還同時出現發帖人姓名，否則，只要出現同一發帖人id的所有記錄，它們中的姓名部分都必須嚴格保持一致，這就是數據冗餘。

1、說出一些數據庫優化方面的經驗?

用PreparedStatement 一般來說比Statement性能高：一個sql 發給服務器去執行，涉及步驟：語法檢查、語義分析，編譯，緩存

“inert into user values(1,1,1)”-?二進制

“inert into user values(2,2,2)”-?二進制

“inert into user values(?,?,?)”-?二進制

有外鍵約束會影響插入和刪除性能，如果程序能夠保證數據的完整性，那在設計數據庫時就去掉外鍵。（比喻：就好比免檢產品，就是爲了提高效率，充分相信產品的製造商）

（對於hibernate來說，就應該有一個變化：empleyee->Deptment對象，現在設計時就成了employee?deptid）

看mysql幫助文檔子查詢章節的最後部分，例如，根據掃描的原理，下面的子查詢語句要比第二條關聯查詢的效率高：

1. select e.name,e.salary where e.managerid=(select id from employee where name='zxx');

2. select e.name,e.salary,m.name,m.salary from employees e,employees m where

e.managerid = m.id and m.name='zxx';

表中允許適當冗餘，譬如，主題帖的回覆數量和最後回覆時間等

將姓名和密碼單獨從用戶表中獨立出來。這可以是非常好的一對一的案例喲！

sql語句全部大寫，特別是列名和表名都大寫。特別是sql命令的緩存功能，更加需要統一大小寫，sql語句?發給oracle服務器?語法檢查和編譯成爲內部指令?緩存和執行指令。根據緩存的特點，不要拼湊條件，而是用?和PreparedStatment

還有索引對查詢性能的改進也是值得關注的。

備註：下面是關於性能的討論舉例

4航班 3個城市

m*n

select * from flight,city where flight.startcityid=city.cityid and city.name='beijing';

m + n

select * from flight where startcityid = (select cityid from city where cityname='beijing');

select flight.id,'beijing',flight.flightTime from flight where startcityid = (select cityid from city where cityname='beijing')

2、union和union all有什麼不同?

假設我們有一個表Student，包括以下字段與數據：

drop table student;

create table student

(

id int primary key,

name nvarchar2(50) not null,

score number not null

);

insert into student values(1,'Aaron',78);

insert into student values(2,'Bill',76);

insert into student values(3,'Cindy',89);

insert into student values(4,'Damon',90);

insert into student values(5,'Ella',73);

insert into student values(6,'Frado',61);

insert into student values(7,'Gill',99);

insert into student values(8,'Hellen',56);

insert into student values(9,'Ivan',93);

insert into student values(10,'Jay',90);

commit;

Union和Union All的區別。

select *

from student

where id < 4

union

select *

from student

where id > 2 and id < 6

結果將是

1 Aaron 78

2 Bill 76

3 Cindy 89

4 Damon 90

5 Ella 73

如果換成Union All連接兩個結果集，則返回結果是：

1 Aaron 78

2 Bill 76

3 Cindy 89

4 Damon 90

5 Ella 73

可以看到，Union和Union All的區別之一在於對重複結果的處理。

　　UNION在進行錶鏈接後會篩選掉重複的記錄，所以在錶鏈接後會對所產生的結果集進行排序運算，刪除重複的記錄再返回結果。實際大部分應用中是不會產生重複的記錄，最常見的是過程表與歷史表UNION。如：

select * from gc_dfys

union

select * from ls_jg_dfys

　　這個SQL在運行時先取出兩個表的結果，再用排序空間進行排序刪除重複的記錄，最後返回結果集，如果表數據量大的話可能會導致用磁盤進行排序。

　而UNION ALL只是簡單的將兩個結果合併後就返回。這樣，如果返回的兩個結果集中有重複的數據，那麼返回的結果集就會包含重複的數據了。

　從效率上說，UNION ALL 要比UNION快很多，所以，如果可以確認合併的兩個結果集中不包含重複的數據的話，那麼就使用UNION ALL，

3.分頁語句

取出sql表中第31到40的記錄（以自動增長ID爲主鍵）

sql server方案1：

select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id

sql server方案2：

select top 10 * from t where id in (select top 40 id from t order by id) order by id desc

mysql方案：select * from t order by id limit 30,10

oracle方案：select * from (select rownum r,* from t where r<=40) where r>30

--------------------待整理進去的內容-------------------------------------

pageSize=20;

pageNo = 5;

1.分頁技術1（直接利用sql語句進行分頁，效率最高和最推薦的）

mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;

oracle: sql = "select * from " +

"(select rownum r,* from " +

"(select * from articles order by postime desc)" +

"where rownum<= " + pageNo*pageSize +") tmp " +

"where r>" + (pageNo-1)*pageSize;

註釋：第7行保證rownum的順序是確定的，因爲oracle的索引會造成rownum返回不同的值

簡洋提示：沒有order by時，rownum按順序輸出，一旦有了order by，rownum不按順序輸出了，這說明rownum是排序前的編號。如果對order by從句中的字段建立了索引，那麼，rownum也是按順序輸出的，因爲這時候生成原始的查詢結果集時會參照索引表的順序來構建。

sqlserver:sql = "select top 10 * from id not id(select top " + (pageNo-1)*pageSize + "id from articles)"

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql);

ResultSet rs = pstmt.executeQuery()

while(rs.next())

{

out.println(rs.getString(1));

}

2.不可滾動的遊標

pageSize=20;

pageNo = 5;

cn = null

stmt = null;

rs = null;

try

{

sqlserver:sql = "select * from articles";

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql);

ResultSet rs = pstmt.executeQuery()

for(int j=0;j<(pageNo-1)*pageSize;j++)

{

rs.next();

}

int i=0;

while(rs.next() && i<10)

{

i++;

out.println(rs.getString(1));

}

cacth(){}

finnaly

{

if(rs!=null)try{rs.close();}catch(Exception e){}

if(stm.........

if(cn............

}

3.可滾動的遊標

pageSize=20;

pageNo = 5;

cn = null

stmt = null;

rs = null;

try

{

sqlserver:sql = "select * from articles";

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,...);

//根據上面這行代碼的異常SQLFeatureNotSupportedException，就可判斷驅動是否支持可滾動遊標

ResultSet rs = pstmt.executeQuery()

rs.absolute((pageNo-1)*pageSize)

int i=0;

while(rs.next() && i<10)

{

i++;

out.println(rs.getString(1));

}

cacth(){}

finnaly

{

if(rs!=null)try{rs.close();}catch(Exception e){}

if(stm.........

if(cn............

}

3.用一條SQL語句查詢出每門課都大於80分的學生姓名

name kecheng fenshu

張三語文 81

張三數學 75

李四語文 76

李四數學 90

王五語文 81

王五數學 100

王五英語 90

準備數據的sql代碼：

create table score(id int primary key auto_increment,name varchar(20),subject varchar(20),score int);

insert into score values

(null,'張三','語文',81),

(null,'張三','數學',75),

(null,'李四','語文',76),

(null,'李四','數學',90),

(null,'王五','語文',81),

(null,'王五','數學',100),

(null,'王五 ','英語',90);

提示：當百思不得其解時，請理想思維，把小變成大做，把大變成小做，

答案：

A: select distinct name from score where name not in (select distinct name from score where score<=80)

B:select distince name t1 from score where 80< all (select score from score where name=t1);

4.所有部門之間的比賽組合

一個叫department的表，裏面只有一個字段name,一共有4條紀錄，分別是a,b,c,d,對應四個球對，現在四個球對進行比賽，用一條sql語句顯示所有可能的比賽組合.

答：select a.name, b.name

from team a, team b

where a.name < b.name

4.每個月份的發生額都比101科目多的科目

請用SQL語句實現：從TestDB數據表中查詢出所有月份的發生額都比101科目相應月份的發生額高的科目。請注意：TestDB中有很多科目，都有1－12月份的發生額。

AccID：科目代碼，Occmonth：發生額月份，DebitOccur：發生額。

數據庫名：JcyAudit，數據集：Select * from TestDB

準備數據的sql代碼：

drop table if exists TestDB;

create table TestDB(id int primary key auto_increment,AccID varchar(20), Occmonth date, DebitOccur bigint);

insert into TestDB values

(null,'101','1988-1-1',100),

(null,'101','1988-2-1',110),

(null,'101','1988-3-1',120),

(null,'101','1988-4-1',100),

(null,'101','1988-5-1',100),

(null,'101','1988-6-1',100),

(null,'101','1988-7-1',100),

(null,'101','1988-8-1',100);

--複製上面的數據，故意把第一個月份的發生額數字改小一點

insert into TestDB values

(null,'102','1988-1-1',90),

(null,'102','1988-2-1',110),

(null,'102','1988-3-1',120),

(null,'102','1988-4-1',100),

(null,'102','1988-5-1',100),

(null,'102','1988-6-1',100),

(null,'102','1988-7-1',100),

(null,'102','1988-8-1',100);

--複製最上面的數據，故意把所有發生額數字改大一點

insert into TestDB values

(null,'103','1988-1-1',150),

(null,'103','1988-2-1',160),

(null,'103','1988-3-1',180),

(null,'103','1988-4-1',120),

(null,'103','1988-5-1',120),

(null,'103','1988-6-1',120),

(null,'103','1988-7-1',120),

(null,'103','1988-8-1',120);

--複製最上面的數據，故意把所有發生額數字改大一點

insert into TestDB values

(null,'104','1988-1-1',130),

(null,'104','1988-2-1',130),

(null,'104','1988-3-1',140),

(null,'104','1988-4-1',150),

(null,'104','1988-5-1',160),

(null,'104','1988-6-1',170),

(null,'104','1988-7-1',180),

(null,'104','1988-8-1',140);

--複製最上面的數據，故意把第二個月份的發生額數字改小一點

insert into TestDB values

(null,'105','1988-1-1',100),

(null,'105','1988-2-1',80),

(null,'105','1988-3-1',120),

(null,'105','1988-4-1',100),

(null,'105','1988-5-1',100),

(null,'105','1988-6-1',100),

(null,'105','1988-7-1',100),

(null,'105','1988-8-1',100);

答案：

select distinct AccID from TestDB

where AccID not in

(select TestDB.AccIDfrom TestDB,

(select * from TestDB where AccID='101') as db101

where TestDB.Occmonth=db101.Occmonth and TestDB.DebitOccur<=db101.DebitOccur

);

4.統計每年每月的信息

year month amount

1991 1 1.1

1991 2 1.2

1991 3 1.3

1991 4 1.4

1992 1 2.1

1992 2 2.2

1992 3 2.3

1992 4 2.4

查成這樣一個結果

year m1 m2 m3 m4

1991 1.1 1.2 1.3 1.4

1992 2.1 2.2 2.3 2.4

提示：這個與工資條非常類似，與學生的科目成績也很相似。

準備sql語句：

drop table if exists sales;

create table sales(id int auto_increment primary key,year varchar(10), month varchar(10), amount float(2,1));

insert into sales values

(null,'1991','1',1.1),

(null,'1991','2',1.2),

(null,'1991','3',1.3),

(null,'1991','4',1.4),

(null,'1992','1',2.1),

(null,'1992','2',2.2),

(null,'1992','3',2.3),

(null,'1992','4',2.4);

答案一、

select sales.year ,

(select t.amount from sales t where t.month='1' and t.year= sales.year) '1',

(select t.amount from sales t where t.month='1' and t.year= sales.year) '2',

(select t.amount from sales t where t.month='1' and t.year= sales.year) '3',

(select t.amount from sales t where t.month='1' and t.year= sales.year) as '4'

from sales group by year;

5.顯示文章標題，發帖人、最後回覆時間

表：id,title,postuser,postdate,parentid

準備sql語句：

drop table if exists articles;

create table articles(id int auto_increment primary key,title varchar(50), postuser varchar(10), postdate datetime,parentid int references articles(id));

insert into articles values

(null,'第一條','張三','1998-10-10 12:32:32',null),

(null,'第二條','張三','1998-10-10 12:34:32',null),

(null,'第一條回覆1','李四','1998-10-10 12:35:32',1),

(null,'第二條回覆1','李四','1998-10-10 12:36:32',2),

(null,'第一條回覆2','王五','1998-10-10 12:37:32',1),

(null,'第一條回覆3','李四','1998-10-10 12:38:32',1),

(null,'第二條回覆2','李四','1998-10-10 12:39:32',2),

(null,'第一條回覆4','王五','1998-10-10 12:39:40',1);

答案：

select a.title,a.postuser,

(select max(postdate) from articles where parentid=a.id) reply

from articles a where a.parentid is null;

註釋：子查詢可以用在選擇列中，也可用於where的比較條件中，還可以用於from從句中。

3.刪除除了id號不同,其他都相同的學生冗餘信息

2.學生表如下:

id號學號姓名課程編號課程名稱分數

1 2005001 張三 0001 數學 69

2 2005002 李四 0001 數學 89

3 2005001 張三 0001 數學 69

A: delete from tablename where id號 not in(select min(id號) from tablename group by 學號,姓名,課程編號,課程名稱,分數)

實驗：

create table student2(id int auto_increment primary key,code varchar(20),name varchar(20));

insert into student2 values(null,'2005001','張三'),(null,'2005002','李四'),(null,'2005001','張三');

//如下語句，mysql報告錯誤，可能刪除依賴後面統計語句，而刪除又導致統計語句結果不一致。

delete from student2 where id not in(select min(id) from student2 group by name);

//但是，如下語句沒有問題：

select * from student2 where id not in(select min(id) from student2 group by name);

//於是，我想先把分組的結果做成虛表，然後從虛表中選出結果，最後再將結果作爲刪除的條件數據。

delete from student2 where id not in(select mid from (select min(id) mid

from student2 group by name) as t);

或者：

delete from student2 where id not in(select min(id) from (select * from s

tudent2) as t group by t.name);

4.航空網的幾個航班查詢題：

表結構如下：

flight{flightID,StartCityID ,endCityID,StartTime}

city{cityID, CityName)

實驗環境：

create table city(cityID int auto_increment primary key,cityName varchar(20));

create table flight (flightID int auto_increment primary key,

StartCityID int references city(cityID),

endCityID int references city(cityID),

StartTime timestamp);

//航班本來應該沒有日期部分纔好，但是下面的題目當中涉及到了日期

insert into city values(null,'北京'),(null,'上海'),(null,'廣州');

insert into flight values

(null,1,2,'9:37:23'),(null,1,3,'9:37:23'),(null,1,2,'10:37:23'),(null,2,3,'10:37:23');

1、查詢起飛城市是北京的所有航班，按到達城市的名字排序

參與運算的列是我起碼能夠顯示出來的那些列，但最終我不一定把它們顯示出來。各個表組合出來的中間結果字段中必須包含所有運算的字段。

select * from flight f,city c

where f.endcityid = c.cityid and startcityid =

(select c1.cityid from city c1 where c1.cityname = "北京")

order by c.cityname asc;

mysql> select flight.flightid,'北京' startcity, e.cityname from flight,city e wh

ere flight.endcityid=e.cityid and flight.startcityid=(select cityid from city wh

ere cityname='北京');

mysql> select flight.flightid,s.cityname,e.cityname from flight,city s,city e wh

ere flight.startcityid=s.cityid and s.cityname='北京' and flight.endCityId=e.cit

yID order by e.cityName desc;

2、查詢北京到上海的所有航班紀錄（起飛城市，到達城市，起飛時間，航班號）

select c1.CityName,c2.CityName,f.StartTime,f.flightID

from city c1,city c2,flight f

where f.StartCityID=c1.cityID

and f.endCityID=c2.cityID

and c1.cityName='北京'

and c2.cityName='上海'

3、查詢具體某一天（2005-5-8）的北京到上海的的航班次數

select count(*) from

(select c1.CityName,c2.CityName,f.StartTime,f.flightID

from city c1,city c2,flight f

where f.StartCityID=c1.cityID

and f.endCityID=c2.cityID

and c1.cityName='北京'

and c2.cityName='上海'

and 查幫助獲得的某個日期處理函數(startTime) like '2005-5-8%'

mysql中提取日期部分進行比較的示例代碼如下：

select * from flight where date_format(starttime,'%Y-%m-%d')='1998-01-02'

5.查出比經理薪水還高的員工信息：

Drop table if not exists employees;

create table employees(id int primary key auto_increment,name varchar(50)

,salary int,managerid int references employees(id));

insert into employees values (null,' lhm',10000,null), (null,' zxx',15000,1

),(null,'flx',9000,1),(null,'tg',10000,2),(null,'wzg',10000,3);

Wzg大於flx,lhm大於zxx

解題思路：

根據sql語句的查詢特點，是逐行進行運算，不可能兩行同時參與運算。

涉及了員工薪水和經理薪水，所有，一行記錄要同時包含兩個薪水，所有想到要把這個表自關聯組合一下。

首先要組合出一個包含有各個員工及該員工的經理信息的長記錄，譬如，左半部分是員工，右半部分是經理。而迪卡爾積會組合出很多垃圾信息，先去除這些垃圾信息。

select e.* from employees e,employees m where e.managerid=m.id and e.sala

ry>m.salary;

6、求出小於45歲的各個老師所帶的大於12歲的學生人數

數據庫中有3個表 teacher 表，student表，tea_stu關係表。

teacher 表 teaID name age

student 表 stuID name age

teacher_student表 teaID stuID

要求用一條sql查詢出這樣的結果

1.顯示的字段要有老師name, age 每個老師所帶的學生人數

2 只列出老師age爲40以下，學生age爲12以上的記錄

預備知識：

1.sql語句是對每一條記錄依次處理，條件爲真則執行動作（select,insert,delete,update）

2.只要是迪卡爾積，就會產生“垃圾”信息，所以，只要迪卡爾積了，我們首先就要想到清除“垃圾”信息

實驗準備：

drop table if exists tea_stu;

drop table if exists teacher;

drop table if exists student;

create table teacher(teaID int primary key,name varchar(50),age int);

create table student(stuID int primary key,name varchar(50),age int);

create table tea_stu(teaID int references teacher(teaID),stuID int references student(stuID));

insert into teacher values(1,'zxx',45), (2,'lhm',25) , (3,'wzg',26) , (4,'tg',27);

insert into student values(1,'wy',11), (2,'dh',25) , (3,'ysq',26) , (4,'mxc',27);

insert into tea_stu values(1,1), (1,2), (1,3);

insert into tea_stu values(2,2), (2,3), (2,4);

insert into tea_stu values(3,3), (3,4), (3,1);

insert into tea_stu values(4,4), (4,1), (4,2) , (4,3);

結果：2?3,3?2,4?3

解題思路：（真實面試答題時，也要寫出每個分析步驟，如果紙張不夠，就找別人要）

1要會統計分組信息，統計信息放在中間表中：

select teaid,count(*) from tea_stu group by teaid;

2接着其實應該是篩除掉小於12歲的學生，然後再進行統計，中間表必須與student關聯才能得到12歲以下學生和把該學生記錄從中間表中剔除，代碼是：

select tea_stu.teaid,count(*) total from student,tea_stu

where student.stuid=tea_stu.stuid and student.age>12 group by tea_stu.teaid

3.接着把上面的結果做成虛表與teacher進行關聯，並篩除大於45的老師

select teacher.teaid,teacher.name,total from teacher ,(select tea_stu.tea

id,count(*) total from student,tea_stu where student.stuid=tea_stu.stuid and stu

dent.age>12 group by tea_stu.teaid) as tea_stu2 where teacher.teaid=tea_stu2.tea

id and teacher.age<45;

7.求出發帖最多的人：

select authorid,count(*) total from articles

group by authorid

having total=

(select max(total2) from (select count(*) total2 from articles group by authorid) as t);

select t.authorid,max(t.total) from

（select authorid,count(*) total from articles ）as t

這條語句不行，因爲max只有一列，不能與其他列混淆。

select authorid,count(*) total from articles

group by authorid having total=max(total)也不行。

10、一個用戶表中有一個積分字段，假如數據庫中有100多萬個用戶，若要在每年第一天凌晨將積分清零，你將考慮什麼，你將想什麼辦法解決?

alter table drop column score;

alter table add colunm score int;

可能會很快，但是需要試驗，試驗不能拿真實的環境來操刀，並且要注意，

這樣的操作時無法回滾的，在我的印象中，只有inert update delete等DML語句才能回滾，

對於create table,drop table ,alter table等DDL語句是不能回滾。

解決方案一，update user set score=0;

解決方案二，假設上面的代碼要執行好長時間，超出我們的容忍範圍，那我就alter table user drop column score;alter table user add column score int。

下面代碼實現每年的那個凌晨時刻進行清零。

Runnable runnable =

new Runnable(){

public void run(){

clearDb();

schedule(this,new Date(new Date().getYear()+1,0,0));

}

};

schedule(runnable,

new Date(new Date().getYear()+1,0,1));

10、一個用戶具有多個角色，請查詢出該表中具有該用戶的所有角色的其他用戶。

select count(*) as num,tb.id

from

tb,

(select role from tb where id=xxx) as t1

where

tb.role = t1.role and tb.id != t1.id

group by tb.id

having

num = select count(role) from tb where id=xxx;

8. xxx公司的sql面試

Table EMPLOYEES Structure:

EMPLOYEE_ID NUMBER Primary Key,

FIRST_NAME VARCHAR2(25),

LAST_NAME VARCHAR2(25),

Salary number(8,2),

HiredDate DATE,

Departmentid number(2)

Table Departments Structure:

Departmentid number(2) Primary Key,

DepartmentName VARCHAR2(25).

(2）基於上述EMPLOYEES表寫出查詢：寫出僱用日期在今年的，或者工資在[1000,2000]之間的，或者員工姓名（last_name）以’Obama’打頭的所有員工，列出這些員工的全部個人信息。（4分）

select * from employees

where Year(hiredDate) = Year(date())

or (salary between 1000 and 200)

or left(last_name,3)='abc';

(3) 基於上述EMPLOYEES表寫出查詢：查出部門平均工資大於1800元的部門的所有員工，列出這些員工的全部個人信息。（4分）

mysql> select id,name,salary,deptid did from employee1 where (select avg(salary)

from employee1 where deptid = did) > 1800;

(4) 基於上述EMPLOYEES表寫出查詢：查出個人工資高於其所在部門平均工資的員工，列出這些員工的全部個人信息及該員工工資高出部門平均工資百分比。（5分）

select employee1.*,(employee1.salary-t.avgSalary)*100/employee1.salary

from employee1,

(select deptid,avg(salary) avgSalary from employee1 group by deptid) as t

where employee1.deptid = t.deptid and employee1.salary>t.avgSalary;

1、註冊Jdbc驅動程序的三種方式

1、用JDBC如何調用存儲過程

代碼如下：

package com.huawei.interview.lym;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Types;

public class JdbcTest {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

Connection cn = null;

CallableStatement cstmt = null;

try {

//這裏最好不要這麼幹，因爲驅動名寫死在程序中了

Class.forName("com.mysql.jdbc.Driver");

//實際項目中，這裏應用DataSource數據，如果用框架，

//這個數據源不需要我們編碼創建，我們只需Datasource ds = context.lookup()

//cn = ds.getConnection();

cn = DriverManager.getConnection("jdbc:mysql:///test","root","root");

cstmt = cn.prepareCall("{call insert_Student(?,?,?)}");

cstmt.registerOutParameter(3,Types.INTEGER);

cstmt.setString(1, "wangwu");

cstmt.setInt(2, 25);

cstmt.execute();

//get第幾個，不同的數據庫不一樣，建議不寫

System.out.println(cstmt.getString(3));

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

finally

{

/*try{cstmt.close();}catch(Exception e){}

try{cn.close();}catch(Exception e){}*/

try {

if(cstmt != null)

cstmt.close();

if(cn != null)

cn.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

1、JDBC中的PreparedStatement相比Statement的好處

答：一個sql命令發給服務器去執行的步驟爲：語法檢查，語義分析，編譯成內部指令，緩存指令，執行指令等過程。

select * from student where id =3----緩存--?xxxxx二進制命令

select * from student where id =3----直接取-?xxxxx二進制命令

select * from student where id =4--- -?會怎麼幹？

如果當初是select * from student where id =?--- -?又會怎麼幹？

上面說的是性能提高

可以防止sql注入。

1. 寫一個用jdbc連接並訪問oracle數據的程序代碼

2、Class.forName的作用?爲什麼要用?

答：按參數中指定的字符串形式的類名去搜索並加載相應的類，如果該類字節碼已經被加載過，則返回代表該字節碼的Class實例對象，否則，按類加載器的委託機制去搜索和加載該類，如果所有的類加載器都無法加載到該類，則拋出ClassNotFoundException。加載完這個Class字節碼後，接着就可以使用Class字節碼的newInstance方法去創建該類的實例對象了。

有時候，我們程序中所有使用的具體類名在設計時（即開發時）無法確定，只有程序運行時才能確定，這時候就需要使用Class.forName去動態加載該類，這個類名通常是在配置文件中配置的，例如，spring的ioc中每次依賴注入的具體類就是這樣配置的，jdbc的驅動類名通常也是通過配置文件來配置的，以便在產品交付使用後不用修改源程序就可以更換驅動類名。

3、大數據量下的分頁解決方法。

答：最好的辦法是利用sql語句進行分頁，這樣每次查詢出的結果集中就只包含某頁的數據內容。再sql語句無法實現分頁的情況下，可以考慮對大的結果集通過遊標定位方式來獲取某頁的數據。

sql語句分頁，不同的數據庫下的分頁方案各不一樣，下面是主流的三種數據庫的分頁sql：

sql server:

String sql =

"select top " + pageSize + " * from students where id not in" +

"(select top " + pageSize * (pageNumber-1) + " id from students order by id)" +

"order by id";

mysql:

String sql =

"select * from students order by id limit " + pageSize*(pageNumber-1) + "," + pageSize;

oracle:

String sql =

"select * from " +

(select *,rownum rid from (select * from students order by postime desc) where rid<=" + pagesize*pagenumber + ") as t" +

"where t>" + pageSize*(pageNumber-1);

4、用 JDBC 查詢學生成績單, 把主要代碼寫出來（考試概率極大）.

Connection cn = null;

PreparedStatement pstmt =null;

Resultset rs = null;

try

{

Class.forname(driveClassName);

cn = DriverManager.getConnection(url,username,password);

pstmt = cn.prepareStatement(“select score.* from score ,student “ +

“where score.stuId = student.id and student.name = ?”);

pstmt.setString(1,studentName);

Resultset rs = pstmt.executeQuery();

while(rs.next())

{

system.out.println(rs.getInt(“subject”) + “ ” + rs.getFloat(“score”) );

}

}catch(Exception e){e.printStackTrace();}

finally

{

if(rs != null) try{ rs.close() }catch(exception e){}

if(pstmt != null) try{pstmt.close()}catch(exception e){}

if(cn != null) try{ cn.close() }catch(exception e){}

}

5、這段代碼有什麼不足之處?

try {

Connection conn = ...;

Statement stmt = ...;

ResultSet rs = stmt.executeQuery("select * from table1");

while(rs.next()) {

}

} catch(Exception ex) {

}

答：沒有finally語句來關閉各個對象，另外，使用finally之後，要把變量的定義放在try語句塊的外面，以便在try語句塊之外的finally塊中仍可以訪問這些變量。

36、說出數據連接池的工作機制是什麼?

J2EE服務器啓動時會建立一定數量的池連接，並一直維持不少於此數目的池連接。客戶端程序需要連接時，池驅動程序會返回一個未使用的池連接並將其表記爲忙。如果當前沒有空閒連接，池驅動程序就新建一定數量的連接，新建連接的數量有配置參數決定。當使用的池連接調用完成後，池驅動程序將此連接表記爲空閒，其他調用就可以使用這個連接。

實現方式，返回的Connection是原始Connection的代理，代理Connection的close方法不是真正關連接，而是把它代理的Connection對象還回到連接池中。

4、爲什麼要用 ORM? 和 JDBC 有何不一樣?

orm是一種思想，就是把object轉變成數據庫中的記錄，或者把數據庫中的記錄轉變成objecdt，我們可以用jdbc來實現這種思想，其實，如果我們的項目是嚴格按照oop方式編寫的話，我們的jdbc程序不管是有意還是無意，就已經在實現orm的工作了。

現在有許多orm工具，它們底層調用jdbc來實現了orm工作，我們直接使用這些工具，就省去了直接使用jdbc的繁瑣細節，提高了開發效率，現在用的較多的orm工具是hibernate。也聽說一些其他orm工具，如toplink,ojb等。

8. XML部分

1、xml有哪些解析技術?區別是什麼?

答:有DOM,SAX,STAX等

DOM:處理大型文件時其性能下降的非常厲害。這個問題是由DOM的樹結構所造成的，這種結構佔用的內存較多，而且DOM必須在解析文件之前把整個文檔裝入內存,適合對XML的隨機訪問SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶通過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問

STAX:Streaming API for XML (StAX)

講解這些區別是不需要特別去比較，就像說傳智播客與其他培訓機構的區別時，我們只需說清楚傳智播客有什麼特點和優點就行了，這就已經間接回答了彼此的區別。

2、你在項目中用到了xml技術的哪些方面?如何實現的?

答:用到了數據存貯，信息配置兩方面。在做數據交換平臺時，將不能數據源的數據組裝成XML文件，然後將XML文件壓縮打包加密後通過網絡傳送給接收者，接收解密與解壓縮後再同XML文件中還原相關信息進行處理。在做軟件配置時，利用XML可以很方便的進行，軟件的各種配置參數都存貯在XML文件中。

3、用jdom解析xml文件時如何解決中文問題?如何解析?

答:看如下代碼,用編碼方式加以解決

package test;

import java.io.*;

public class DOMTest

{

private String inFile = "c:\\people.xml"

private String outFile = "c:\\people.xml"

public static void main(String args[])

{

new DOMTest();

}

public DOMTest()

{

try

{

javax.xml.parsers.DocumentBuilder builder =

javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();

org.w3c.dom.Document doc = builder.newDocument();

org.w3c.dom.Element root = doc.createElement("老師");

org.w3c.dom.Element wang = doc.createElement("王");

org.w3c.dom.Element liu = doc.createElement("劉");

wang.appendChild(doc.createTextNode("我是王老師"));

root.appendChild(wang);

doc.appendChild(root);

javax.xml.transform.Transformer transformer =

javax.xml.transform.TransformerFactory.newInstance().newTransformer();

transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312");

transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");

transformer.transform(new javax.xml.transform.dom.DOMSource(doc),

new

javax.xml.transform.stream.StreamResult(outFile));

}

catch (Exception e)

{

System.out.println (e.getMessage());

}

4、編程用JAVA解析XML的方式.

答:用SAX方式解析XML，XML文件如下：

<?xml version=1.0 encoding=gb2312?>

<notes>男,1955年生,博士，95年調入海南大學</notes>

</person>

事件回調類SAXHandler.java

import java.io.*;

import java.util.Hashtable;

import org.xml.sax.*;

public class SAXHandler extends HandlerBase

{

private Hashtable table = new Hashtable();

private String currentElement = null;

private String currentValue = null;

public void setTable(Hashtable table)

{

this.table = table;

}

public Hashtable getTable()

{

return table;

}

public void startElement(String tag, AttributeList attrs)

throws SAXException

{

currentElement = tag;

}

public void characters(char[] ch, int start, int length)

throws SAXException

{

currentValue = new String(ch, start, length);

}

public void endElement(String name) throws SAXException

{

if (currentElement.equals(name))

table.put(currentElement, currentValue);

}

JSP內容顯示源碼,SaxXml.jsp:

<HTML>

<HEAD>

<TITLE>剖析XML文件people.xml</TITLE>

</HEAD>

<BODY>

<%@ page errorPage=ErrPage.jsp

contentType=text/html;charset=GB2312 %>

<%@ page import=java.io.* %>

<%@ page import=java.util.Hashtable %>

<%@ page import=org.w3c.dom.* %>

<%@ page import=org.xml.sax.* %>

<%@ page import=javax.xml.parsers.SAXParserFactory %>

<%@ page import=javax.xml.parsers.SAXParser %>

<%@ page import=SAXHandler %>

File file = new File(c:\people.xml);

FileReader reader = new FileReader(file);

Parser parser;

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser sp = spf.newSAXParser();

SAXHandler handler = new SAXHandler();

sp.parse(new InputSource(reader), handler);

Hashtable hashTable = handler.getTable();

out.println(<TABLE BORDER=2><CAPTION>教師信息表</CAPTION>);

out.println(<TR><TD>姓名</TD> + <TD> +

(String)hashTable.get(new String(name)) + </TD></TR>);

out.println(<TR><TD>學院</TD> + <TD> +

(String)hashTable.get(new String(college))+</TD></TR>);

out.println(<TR><TD>電話</TD> + <TD> +

(String)hashTable.get(new String(telephone)) + </TD></TR>);

out.println(<TR><TD>備註</TD> + <TD> +

(String)hashTable.get(new String(notes)) + </TD></TR>);

out.println(</TABLE>);

</BODY>

</HTML>

70、XML文檔定義有幾種形式？它們之間有何本質區別？解析XML文檔有哪幾種方式？

a: 兩種形式 dtd schema，b: 本質區別:schema本身是xml的，可以被XML解析器解析(這也是從DTD上發展schema的根本目的)，c:有DOM,SAX,STAX等

DOM:處理大型文件時其性能下降的非常厲害。這個問題是由DOM的樹結構所造成的，這種結構佔用的內存較多，而且DOM必須在解析文件之前把整個文檔裝入內存,適合對XML的隨機訪問

SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶通過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問

STAX:Streaming API for XML (StAX)

9. 流行的框架與新技術

1、談談你對Struts的理解。

答:

1. struts是一個按MVC模式設計的Web層框架，其實它就是一個大大的servlet，這個Servlet名爲ActionServlet，或是ActionServlet的子類。我們可以在web.xml文件中將符合某種特徵的所有請求交給這個Servlet處理，這個Servlet再參照一個配置文件（通常爲/WEB-INF/struts-config.xml）將各個請求分別分配給不同的action去處理。

一個擴展知識點：struts的配置文件可以有多個，可以按模塊配置各自的配置文件，這樣可以防止配置文件的過度膨脹；

2. ActionServlet把請求交給action去處理之前，會將請求參數封裝成一個formbean對象（就是一個java類，這個類中的每個屬性對應一個請求參數），封裝成一個什麼樣的formbean對象呢？看配置文件。

3.要說明的是， ActionServlet把formbean對象傳遞給action的execute方法之前，可能會調用formbean的validate方法進行校驗，只有校驗通過後纔將這個formbean對象傳遞給action的execute方法，否則，它將返回一個錯誤頁面，這個錯誤頁面由input屬性指定，（看配置文件）作者爲什麼將這裏命名爲input屬性，而不是error屬性，我們後面結合實際的運行效果進行分析。

4.action執行完後要返回顯示的結果視圖，這個結果視圖是用一個ActionForward對象來表示的，actionforward對象通過struts-config.xml配置文件中的配置關聯到某個jsp頁面，因爲程序中使用的是在struts-config.xml配置文件爲jsp頁面設置的邏輯名，這樣可以實現action程序代碼與返回的jsp頁面名稱的解耦。

你對struts可能還有自己的應用方面的經驗，那也要一併說出來。

2、談談你對Hibernate的理解。

答:

1. 面向對象設計的軟件內部運行過程可以理解成就是在不斷創建各種新對象、建立對象之間的關係，調用對象的方法來改變各個對象的狀態和對象消亡的過程，不管程序運行的過程和操作怎麼樣，本質上都是要得到一個結果，程序上一個時刻和下一個時刻的運行結果的差異就表現在內存中的對象狀態發生了變化。

2.爲了在關機和內存空間不夠的狀況下，保持程序的運行狀態，需要將內存中的對象狀態保存到持久化設備和從持久化設備中恢復出對象的狀態，通常都是保存到關係數據庫來保存大量對象信息。從Java程序的運行功能上來講，保存對象狀態的功能相比系統運行的其他功能來說，應該是一個很不起眼的附屬功能，java採用jdbc來實現這個功能，這個不起眼的功能卻要編寫大量的代碼，而做的事情僅僅是保存對象和恢復對象，並且那些大量的jdbc代碼並沒有什麼技術含量，基本上是採用一套例行公事的標準代碼模板來編寫，是一種苦活和重複性的工作。

3.通過數據庫保存java程序運行時產生的對象和恢復對象，其實就是實現了java對象與關係數據庫記錄的映射關係，稱爲ORM（即Object Relation Mapping），人們可以通過封裝JDBC代碼來實現了這種功能，封裝出來的產品稱之爲ORM框架，Hibernate就是其中的一種流行ORM框架。使用Hibernate框架，不用寫JDBC代碼，僅僅是調用一個save方法，就可以將對象保存到關係數據庫中，僅僅是調用一個get方法，就可以從數據庫中加載出一個對象。

4.使用Hibernate的基本流程是：配置Configuration對象、產生SessionFactory、創建session對象，啓動事務，完成CRUD操作，提交事務，關閉session。

5.使用Hibernate時，先要配置hibernate.cfg.xml文件，其中配置數據庫連接信息和方言等，還要爲每個實體配置相應的hbm.xml文件，hibernate.cfg.xml文件中需要登記每個hbm.xml文件。

6.在應用Hibernate時，重點要了解Session的緩存原理，級聯，延遲加載和hql查詢。

3、AOP的作用。

3、你對Spring的理解。

1.Spring實現了工廠模式的工廠類（在這裏有必要解釋清楚什麼是工廠模式），這個類名爲BeanFactory（實際上是一個接口），在程序中通常BeanFactory的子類ApplicationContext。Spring相當於一個大的工廠類，在其配置文件中通過<bean>元素配置用於創建實例對象的類名和實例對象的屬性。

2. Spring提供了對IOC良好支持，IOC是一種編程思想，是一種架構藝術，利用這種思想可以很好地實現模塊之間的解耦。IOC也稱爲DI（Depency Injection），什麼叫依賴注入呢？

譬如，Class Programmer

{

Computer computer = null;

public void code()

{

//Computer computer = new IBMComputer();

//Computer computer = beanfacotry.getComputer();

computer.write();

}

public void setComputer(Computer computer)

{

this.computer = computer;

}

另外兩種方式都由依賴，第一個直接依賴於目標類，第二個把依賴轉移到工廠上，第三個徹底與目標和工廠解耦了。在spring的配置文件中配置片段如下：

</bean>

</bean>

3. Spring提供了對AOP技術的良好封裝， AOP稱爲面向切面編程，就是系統中有很多各不相干的類的方法，在這些衆多方法中要加入某種系統功能的代碼，例如，加入日誌，加入權限判斷，加入異常處理，這種應用稱爲AOP。實現AOP功能採用的是代理技術，客戶端程序不再調用目標，而調用代理類，代理類與目標類對外具有相同的方法聲明，有兩種方式可以實現相同的方法聲明，一是實現相同的接口，二是作爲目標的子類在，JDK中採用Proxy類產生動態代理的方式爲某個接口生成實現類，如果要爲某個類生成子類，則可以用CGLI B。在生成的代理類的方法中加入系統功能和調用目標類的相應方法，系統功能的代理以Advice對象進行提供，顯然要創建出代理對象，至少需要目標類和Advice類。spring提供了這種支持，只需要在spring配置文件中配置這兩個元素即可實現代理和aop功能，例如，

</bean>

11、談談Struts中的Action servlet。

12、Struts優缺點

優點：

1. 實現MVC模式，結構清晰,使開發者只關注業務邏輯的實現.

2．有豐富的tag可以用 ,Struts的標記庫(Taglib)，如能靈活動用，則能大大提高開發效率

3. 頁面導航

使系統的脈絡更加清晰。通過一個配置文件，即可把握整個系統各部分之間的聯繫，這對於後期的維護有着莫大的好處。尤其是當另一批開發者接手這個項目時，這種優勢體現得更加明顯。

4. 提供Exception處理機制 .

5. 數據庫鏈接池管理

6. 支持I18N

缺點

一、轉到展示層時，需要配置forward，如果有十個展示層的jsp，需要配置十次struts，而且還不包括有時候目錄、文件變更，需要重新修改forward，注意，每次修改配置之後，要求重新部署整個項目，而tomcate這樣的服務器，還必須重新啓動服務器

二、二、 Struts 的Action必需是thread－safe方式，它僅僅允許一個實例去處理所有的請求。所以action用到的所有的資源都必需統一同步，這個就引起了線程安全的問題。

五、對Servlet的依賴性過強. Struts處理Action時必需要依賴ServletRequest 和ServletResponse，所有它擺脫不了Servlet容器。

七、對Action執行的控制困難. Struts創建一個Action，如果想控制它的執行順序將會非常困難。甚至你要重新去寫Servlet來實現你的這個功能需求。

八、對Action 執行前和後的處理. Struts處理Action的時候是基於class的hierarchies，很難在action處理前和後進行操作。

119、STRUTS的應用(如STRUTS架構)

Struts是採用Java Servlet/JavaServer Pages技術，開發Web應用程序的開放源碼的framework。採用Struts能開發出基於MVC(Model-View-Controller)設計模式的應用構架。 Struts有如下的主要功能：一.包含一個controller servlet，能將用戶的請求發送到相應的Action對象。二.JSP自由tag庫，並且在controller servlet中提供關聯支持，幫助開發員創建交互式表單應用。三.提供了一系列實用對象：XML處理、通過Java reflection APIs自動處理JavaBeans屬性、國際化的提示和消息。

110、說說struts1與struts2的區別。

1.都是MVC的WEB框架,

2 struts1的老牌框架，應用很廣泛，有很好的羣衆基礎，使用它開發風險很小，成本更低！struts2雖然基於這個框架，但是應用羣衆並多，相對不成熟，未知的風險和變化很多，開發人員相對不好招，使用它開發項目的風險係數更大，用人成本更高！

3.struts2畢竟是站在前輩的基礎設計出來，它會改善和完善struts1中的一些缺陷，struts1中一些懸而未決問題在struts2得到了解決。

4.struts1的前端控制器是一個Servlet，名稱爲ActionServlet，struts2的前端控制器是一個filter，在struts2.0中叫FilterDispatcher，在struts2.1中叫StrutsPrepareAndExecuteFilter。

5.struts1的action需要繼承Action類，struts2的action可以不繼承任何類；struts1對同一個路徑的所有請求共享一個Action實例，struts2對同一個路徑的每個請求分別使用一個獨立Action實例對象，所有對於struts2的Action不用考慮線程安全問題。

6.在struts1中使用formbean封裝請求參數，在struts2中直接使用action的屬性來封裝請求參數。

7.struts1中的多個業務方法放在一個Action中時（即繼承DispatchAction時），要麼都校驗，要麼都不校驗；對於struts2，可以指定只對某個方法進行校驗，當一個Action繼承了ActionSupport且在這個類中只編寫了validateXxx()方法，那麼則只對Xxx()方法進行校驗。

（一個請求來了的執行流程進行分析，struts2是自動支持分模塊開發，並可以不同模塊設置不同的url前綴，這是通過package的namespace來實現的；struts2是支持多種類型的視圖；struts2的視圖地址可以是動態的，即視圖的名稱是支持變量方式的，舉例，論壇發帖失敗後回來還要傳遞boardid。視圖內容顯示方面：它的標籤用ognl，要el強大很多，在國際化方面支持分模塊管理，兩個模塊用到同樣的key，對應不同的消息；）

與Struts1不同，Struts2對用戶的每一次請求都會創建一個Action，所以Struts2中的Action是線程安全的。

給我印象最深刻的是：struts配置文件中的redirect視圖的url不能接受參數，而struts2配置文件中的redirect視圖可以接受參數。

110、hibernate中的update()和saveOrUpdate()的區別，session的load()和get()的區別。

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

7、iBatis與Hibernate有什麼不同?

相同點：屏蔽jdbc api的底層訪問細節，使用我們不用與jdbc api打交道，就可以訪問數據。

jdbc api編程流程固定，還將sql語句與java代碼混雜在了一起，經常需要拼湊sql語句，細節很繁瑣。

ibatis的好處：屏蔽jdbc api的底層訪問細節；將sql語句與java代碼進行分離;提供了將結果集自動封裝稱爲實體對象和對象的集合的功能，queryForList返回對象集合，用queryForObject返回單個對象；提供了自動將實體對象的屬性傳遞給sql語句的參數。

Hibernate是一個全自動的orm映射工具，它可以自動生成sql語句,ibatis需要我們自己在xml配置文件中寫sql語句，hibernate要比ibatis功能負責和強大很多。因爲hibernate自動生成sql語句，我們無法控制該語句，我們就無法去寫特定的高效率的sql。對於一些不太複雜的sql查詢，hibernate可以很好幫我們完成，但是，對於特別複雜的查詢，hibernate就很難適應了，這時候用ibatis就是不錯的選擇，因爲ibatis還是由我們自己寫sql語句。

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

9、hibernate的inverse屬性的作用?