java web 整合開發王者歸來學習總結

時間 2019-11-11
標籤 java web 整合開發歸來學習總結欄目 Java 简体版
原文原文鏈接
第一章java web開發概述
胖客戶端CS，瘦客戶端BS（Browser）
網址請求---服務器處理響應-----返回結果-----瀏覽器顯示
CGI能夠動態生成頁面，可是每一個進程都要啓動一個CGI程序的系統進程，並在系統進程中啓動一個jvm，開銷大，執行效率低；java servlet只須要啓動一次服務器進程，加載一次JVM，以後再加載另外的類，這樣下降了開銷，加載類能夠處理多個相同請求，servlet能直接與web服務器交互。可是servlet嵌入了HTML標籤和表達式，修改文件，就須要從新編譯源文件。JSP（java server page）servlet結合了動靜態的HTML技術，jsp先被jsp引擎轉換成java源代碼，在編譯成可執行的二進制字節碼，接收到客戶請求後，執行上面的二進制字節碼的jsp文件。
第二章 搭建javaweb開發環境
    JDK包括JRE。Myeclipse 包括eclipse，還增長了一些封裝好的插件，更好用。
環境搭建步驟：安裝jdk，設置環境變量JAVA_HOME爲安裝目錄，添加到Path環境變量 jdk的bin路徑----安裝eclipse+myeclipse插件，或者直接安裝myeclipse程序，下載tomcat服務器，解壓設置環境變量CATALINE_HOME爲安裝路徑，添加bin目錄路徑到Path環境變量。---新建工程，在myeclipse上新建web工程-----部署到tomcat，手動複製到tomcat的webapp文件夾下，或者在myeclipse上window|preferences添加tomcat，將工程add到tomcat-----運行tomcat服務器，輸入網址訪問網頁。
    也能夠導出爲war文件複製到webapp文件夾，tomcat自動完成解包部署工做。
    在myeclipse中window|perference中設置tomcat爲debug模式，在myeclipse中啓動tomcat，能夠調試程序。
第三章 深刻servlet技術
    GET方式經常使用於查詢信息，查詢內容顯示在地址欄中，信息不安全，且提交內容不能超過256個字節。Post方式經常使用於提交數據，須要提供數據類型和長度，無長度限制，不顯示在地址欄，安全。
    Web.xml配置：servle-name（建立的servlet類的名稱HelloServlet，文件中惟一），servle-class（帶包名稱的類路徑：com.bclfirst.HelloServlet），在servlet-mapping中配置url-pattern（/servlet/HelloServlet）設置servlet的訪問方式，http://ip:port/webapp下文件夾名稱/url-pattern （http://127.0.0.1/FirstWeb//servlet/HelloServlet.jsp）即爲url訪問路徑。HelloServlet.jsp的後綴能夠用通配符*表示任意的後綴。
    請求和響應：HttpServletRequest中包含了發出請求的客戶端的ip端口、系統、tomcat服務器、servlet路徑、類名等信息。HttpServletresponse響應用戶請求，PrintWrite out=response.getWtiter(); out.println()打印輸出html顯示輸出結果。
    生成圖片驗證碼的關鍵步驟：Random對象生成隨機數和隨機顏色RGB值，BufferImage建立一個彩色圖片，Graphic2D對象繪製圖片顏色和驗證碼字符串。JPEGImageEncoder對象轉換格式，ServletOutputStream對象的flush（）函數打印輸出。
    獲取web文件參數：getInitParameter(Stirng param)獲取web.xml中經過<init-param><init-param>配置的指定名稱的參數，getInitParameters（）獲取全部的<init-param名稱；getServletCofig().getServletContext()來獲取一個ServletContext對象sc，用getInitParameters（）和getInitParameter(Stirng param)函數獲取全部的參數名稱和單個參數值。
資源注射（@Resourse）：private @Resourse（name =」addas」） String message;自動獲取web.xml文件中的變量，配置方式是<env-entry><env-entry-name><env-entry-type><env-entry-value>.
搜索引擎：採用雅虎的yahoo_search-2.0.1.jar加入到lib文件夾下，import com.search.SearchClient ,調用SearchClient.imageSearch(ImageSearchRequest )檢索。
    上傳文件：FORM默認的數據類型enctype是application/x-www-form-urlencoded 表示ASCII碼，上傳文件時應該設置爲multipart/form-data二進制文件格式。使用Apache Commons Upload類庫。

上傳進度讀取：

Servlet生命週期：在服務器啓動（load-on-startup爲1）或第一次請求（load-on-startup爲0）初始化一個servlet對象，執行init（）函數；在服務器關閉時銷燬對象，執行destory（） 函數。中間每一個請求啓動一個線程執行service方法。
    註解@PostConstruct在servlet構造函數和init之間運行，註解函數@PreDestory在destory（）函數以後執行。Web.xml中設置metadata-complete=「true」表示啓動服務器時要去檢測工程class文件和jar是否使用了註解。
    轉向（Forward）RequestDispatcher rd = request.getRequestDispatcher(String to)能夠跳轉到文件、jsp、其餘servlet，rd.forward(request,response)轉向指定的;
    重定向（Redirect）：response。sendRedirect（String loacation）集合了setStatus()（設置重定向狀態爲302臨時重定向，301永久重定向。）和setHeader()（設置重定向的地址）。客戶端請求兩次，第一次返回狀態和地址，第二次訪問訪問真實地址。
自動刷新：Response.setHeader(「Refresh」,」1000;URL=http://localhost:8080/servlet」);
    Servlet線程不安全問題：由於servlet只有一個實例，多線程時調用相同的doGet方法，若是多個線程同時寫一個公共的私有變量，獲取變量值時會出現不一樣步的問題。只讀沒問題。
第四章深刻JSP技術
4.1JSP概述
JSP（java server page）也是一種servlet，是HTML代碼和java代碼的混合，無需使用out.println函數。直接複製到tomcat文件夾下，經過路徑名稱訪問，無需web.xml文件。第一次請求jsp文件時，先被轉換爲java源代碼，而後被編譯爲class類文件，運行class文件響應請求。之後再也不從新編譯。除了init和destroy外還有本身的_jspInit()和_jspDestory()方法。
4.2JSP語法
Jsp分爲模板數據，指HTML輸出樣式；元素指java部分，包括腳本scriptlet、指令derective、標籤tag；
Jap腳本：腳本用<% %>括起來，中間是java代碼。使用out.println輸出。
<%@ page language=」java」  contentType=」text/html,charset=utf-8」%>
<html>
<body>
<% 
int num=10;
out.println(「數字」+num+「階乘爲：」+resault)；
%>
</body>
</html>

jsp輸出：或者用<% =%>輸出，例如：數字<% = num%>的階乘爲：<% = resault %>
jsp註釋：用//或者/**/或者<% --      --%>
jsp聲明方法和全局變量：在<%！ %>內聲明一個或多個方法和變量。
Jsp if for while return break語句：這些語句能夠和HTML語句混合，但必須被<% %>包括在內，才能穿插其中。Return 以後的代碼不會執行，包括</html>。
Jsp訪問：將jspx項目部署到tomcat下，瀏覽器輸入http：localhost：8080/jsp/greeting.jsp?param=3, param表示參數，能夠經過request.getParameter(「param」)獲取。
4.3jsp指令
4.3.1Page指令
 <%@ page language=」java」  contentType=」text/html, charset=utf-8」%>，一個或者多個屬性。
Page常見屬性：
language 採用的語言；
extends 指明繼承於那個類，繼承普通類時須要實現sevlet的init和destory方法；
import 引入jsp中用到的類、包，惟一能夠聲明屢次的屬性；
session 是否內置session對象，默認true；
autoFlush是否運行緩存，超出緩衝區大小或者執行out.flush（）後輸出到客戶端顯示，默認爲true；
buffer指定緩存大小；
isThreadSafe 是否線程安全，true表示能夠多個線程同時運行jsp，默認爲false；
isErrorPage  是否爲錯誤處理界面，若是true，jsp內置一個Exception對象exception，默認false；
errorPage 指明出現錯誤後轉向的錯誤顯示頁面。
contentType 有效的文檔類型，HTML格式爲text/html，純文本text/plain,jpg圖像爲image/jpeg，GIF圖像爲image/gif，word文檔爲application/msword；
info 傳入jsp的任意字符串，用Servlet.getServletInfo（）獲得；
4.3.2include指令
格式爲<%@ include  file=」relative jspurl」%> ,能夠引入其餘的jsp文件，路徑爲相對路徑，便於jsp頁面的區塊化，例如將導航塊放入head.jsp，將版權放在foot.jsp中。在jsp首尾include這兩個文件；
JSP包含文件行爲與Jsp包含指令不一樣,<jsp:incude page= 「relative url 」/></jsp:incude>,指令是先包含在編譯，行爲是先運行，再包含；
4.3.3taglib指令
標籤技術支持視圖代碼重用，<%@ taglib  uri=」http://java.sun.com/jsp/core 「  prefix=」c」%>，uri指定類庫地址，prefix指定標籤的前綴；
4.4JSP行爲
4.4.1jsp:incude行爲
<jsp:incude flush=」true」  page= 「/head.jsp 」/></jsp:incude>, page指定本程序內的文件，flush爲true表示讀入文件前先清空緩存；
4.4.2jspjava bean 行爲
（1）在useBean.Html文件用表單<form action="useBean.jsp" method="post">，用戶輸入person的信息後，提交表單，傳給useBean.jsp
（1）在jsp文件中用jsp:useBean聲明普通類對象
<%-- 聲明 Person 類對象 person --%>
<jsp:useBean id="person" class="com.helloweenvsfei.jspweb.bean.Person" scope="page"></jsp:useBean>  id對象名稱，calss類名稱， scope對象範圍（page在當前jsp內,request本次請求中有效,session當前用戶有效,application當前web程序內有效）。
（2）在jsp文件中用jsp:setProperty設置值，提交後request中含有提交的值，根據輸入的名稱對應值，保存到person對象中。
<%-- 設置 person 的全部屬性，全部的屬性值從 request 中自動取得 --%>
<jsp:setProperty name="person" property="*" />
（4）經過<jsp:getProperty name="person" property="name" />獲取屬性值
4.4.3scope能夠用於網頁訪問次數計數
session當前用戶訪問次數,application總的訪問次數）。
4.4.4<jsp:plugin/>嵌入Applet
4.4.5<jsp:forward/>跳轉行爲
<%
    out.clear();
    if("1".equals(request.getParameter("param"))){
%>
<jsp:forward page="/somepage.jsp">
    <jsp:param name="param1" value="value1"/>
    <jsp:param name="param2" value="value2"/>
</jsp:forward>
<%
    }
%>
4.4.6 <jsp:directive/>行爲
Jsp行爲和指令之間能夠相互改寫，實現相同的功能。

4.5jsp中隱藏對象
Jsp中內置的隱藏對象有out,request,reponse,config,session, application,page, pageContext, exception.
4.6jsp配置
Jsp文件能夠直接訪問，也能夠經過web.xml配置文件來映射訪問路徑。標籤採用<jsp-file>,其餘一致。也能夠添加初始化參數<init-param>,採用隱藏對象config的getInitParamter(String name)獲取。
4.7EL（Expression language）表達式
用${}括起來的腳本在HTML中，不可再<%%>中，能夠方便的讀取對象的屬性。例如${person.age}。EL能夠方便的讀取隱藏對象的屬性。EL支持運算符，邏輯運算符，比較運算符。
第五章會話跟蹤
由於HTTP協議是無狀態的協議，請求響應結束後，鏈接關閉，再次請求響應時創建新的鏈接，服務器沒法從鏈接上判斷是哪一個用戶，即沒法進行會話跟蹤。會話跟蹤用於記錄客戶的登錄信息，Cookie是在客戶端記錄信息，session是在服務器端記錄信息。
5.1Cookie機制
客戶端向服務器發出第一次請求，服務器向客戶端頒發一個cookie，用於確認用戶的身份，再次請求時瀏覽器將請求的網址連同頒發的cookie一塊兒發給服務器，服務器能夠修改cookie的內容在返回給瀏覽器。
Cookie經過request.getCookie()獲取，經過response.addCookie()設置。Cookie是一個key-value的鍵-值對。
能夠包含多個cookie。Cookie能夠保存用戶的訪問次數。Cookie不能跨越域名去訪問，瀏覽器判斷一個網站是否能夠操縱另外一個網站的Cookie的判斷依據是Cookie的屬性域名，百度和谷歌不能相互訪問。
    Cookie在保存中文時，須要用java.net.URLEncoder和java.net.URLDecoder進行獲取的解碼和寫入時的編碼。
    Cookie還能夠保存圖片數據，先用InputStream讀取文件數據到內存，而後用BASE64Encoder進行編碼，添加到Cookie中，客戶端獲得、Cookie後用response.getOutputStream().write(binary)輸出到界面顯示；可是每次請求都會攜帶Cookie，因此內容不宜過多，不然影響速度。
    Cookie除了name（名稱）和value（值）外，還有maxAge（失效時間，負數表示關閉瀏覽器時刪除，0表示當即刪除，能夠添加maxAge=0同名的Cookie來刪除該名稱的Cookie，整數表示超過秒數後刪除），secure（是否按安全協議傳輸，默認false），path（設置cookie的容許訪問的程序路徑），domain（能夠訪問cookie的域名，必須以.開頭，例如.goole.com）,還有comment（描述）和version（版本）屬性。
document.cookie返回cookie，每一個載入瀏覽器的 HTML 文檔都會成爲 Document 對象。Document 對象使咱們能夠從腳本中對 HTML 頁面中的全部元素進行訪問。
 

5.2 Session機制
    Session是在服務器端保存用戶信息，訪問時經過查詢客戶明細表來確認身份。也是一個鍵值對加屬性，jsp含隱藏的session對象，或者用request和response對象的方法獲取。Seeion能夠直接保存person對象與data對象。比cookie方便。
    訪問jsp、servlet時纔會建立Session，只訪問HTML等靜態資源不會建立session。
    Session的有效期經過設置MaxInactiveInterval活躍超時時間。
    Session須要依賴於cookie來辨識客戶，服務器向客戶端發送一個名稱爲JSESSIONID的cookie，依據此Session來識別是不是同一用戶。
    地址重寫，Response.encodeURL()方法自動判斷瀏覽器是否支持cookie，支持則原樣輸出，不支持則將jsessionid重寫到url地址中。
若是是頁面重定向，用 response.sendRedirect(response.encodeRedirectURL (admini strator.jsp))重定向，支持cookie時，返回原url，若是不支持，加上jsessionid後返回。
第一次請求不會攜帶cookie，經過地址重寫攜帶jsessionid，第二次請求時，若是攜帶了值爲jsessionid的cookie，則url地址不會帶有jsessionid了；能夠在conntext.xml中設置是否禁用自動維護jsessionid的cookie。
5.3Session與cookie的比較
Session能夠保存任何類型的數據，cookie只能保存ASCII字符串，不能直接存儲java對象。
Session比cookie安全性更好；
Cookie能夠實現登錄消息長期有效，session依賴於cookie，不能實現長期登錄有效的效果。
服務器訪問數量多的採用cookie比較合適。不然服務器的負擔過重。


第七章監聽器listener
    監聽器listener用於監聽session、context、request的建立和刪除，屬性的變化。先在配置文件中配置<listener><listener-class>com.helloweenvsfei.listener.listenertest </listener></listener-class>,映射listener指向的文件，當session等建立銷燬使會自動調用listenertest類裏的方法，listenertest實現方法繼承於httpsessionlistener的接口，接口固定。
    監聽session、context、request屬性變化，接口名稱爲XxxAttributeListener，當監聽到對象添加、更新、移除會調用函數XxxAdded，Xxxreplaced，XxxRemove方法。
除了上述六個listener外，還有兩個listener，無需在web.xml中配置，新建類時，實現listener的接口；分別爲HttpSessionBindingListener和HttpSessionActivationListener，當對象放入Session中時，執行valueBound方法，刪除時執行valueUNBound方法；服務器關閉時，Session內容保存到硬盤中，執行sessionWillPassivate方法，服務器重啓時，從新加載Session，執行sessionDidActive方法。
第八章jstl標籤庫
8.1JSTL概述
JSTL（java standard tag library）爲標準標籤庫。Java採用分層結構MVC（model-view-control）model用於處理業務邏輯，view用來顯示，control用於鏈接這兩個；標籤就是用於顯示數據的；JSTL採用xml格式，與HTML代碼相似，可讀性強；
標籤包括前綴、標籤名稱、標籤屬性以及標籤體；
8.2JSTL的core標籤庫
文件頭包含<%@ taglib uri=」http://java.sun.com/jsp/jstl/core」  prefix=」c」>
c:out與EL表達式一塊兒使用輸出<c:out value=」&{para.action}」></c:out>
實現if的功能
<c:if test=」${param.action==’add’}」></c:if> test能夠是boolean類型的true，也能夠是字符串的true（ingore case）；
實現if else的功能
<c:choose>
<c:when test=」true」>
When 標籤的輸出
</c:when>
<c:otherwise>
Otherwise  標籤的輸出
</c:otherwise>
 </c:choose>
<c:forEach>實現循環
<c:forEach var=」num」  begin=」2」  end =」100」  step=」2」>
<div>${num}</div>
</c:forEach>
Var定義變量名稱，begin初始值，end結束值，step步長；向對於for（int num=2;num<=100;num+=2）;
<c:forEach items=」${personlist}」  var=」person」></c:forEach>遍歷list或者map
<c:forEach>有一個varStatus屬性。





第16章 struts2.0 概述
16.1structs實例
添加類庫
Struts2須要下載類庫，即jar包，放在lib文件中。若是沒有plaxus、Sitergraph、Spring，須要將對應的插件刪掉，不然會出錯；
建立文件
    建立loginaction.java，繼承於com.opensymphony.xwork2.ActionSupport類，在類中建立set和get方法獲取類的成員變量值；最重要的是execute（）方法，爲action的主方法，提交數據會調用該方法，返回值表明顯示頁面的名稱，在struts2配置文件中配置action的結果的名稱與顯示頁面的名稱對應，調用對應jsp文件顯示名稱對應的界面。
配置文件
    Struts配置文件以下所示，每一個action都有一個配置結點，result name即爲上述中action返回界面的名稱，後面的jsp文件即爲顯示的界面，package name用於繼承特性，子package裏的action可以使用父package裏的資源；struts-default包含攔截器；global-results是全局的結構，任何action均可以調用；
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <!-- 聲明 Struts2 的屬性  例如將 Struts2 後綴改成 .helloween -->
    <!-- 
        <constant name="struts.action.extension" value="helloween"></constant>
    -->
<!—package name-->
    <package name="main" extends="struts-default">
        <global-results>
            <result name="login">/login.jsp</result>
        </global-results>
        <action name="login"
            class="com.helloweenvsfei.struts2.action.LoginAction">
            <result name="success">/welcome.jsp</result>
        </action>
        <action name="logout"
            class="com.helloweenvsfei.struts2.action.LoginAction"
            method="logout">
            <result name="success">/welcome.jsp</result>
        </action>
    </package>
</struts>

用struts2標籤的jsp頁面文件
    使用標籤先加入<%@ taglib uri="/struts-tags" prefix="struts"%>標籤庫，而後用struts:head和struts:form等標籤，theme="ajax"是主題，ajax主題會加載struts2的dojo庫；/struts-tags位於struts2-core-2.0.6.jar包中，不須要複製到WEB_INF下面，直接使用便可，使用主題，頁面會根據主題自動佈局，無需html佈局標籤；
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ taglib uri="/struts-tags" prefix="struts"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
    <struts:head theme="ajax" />
  </head>
  
  <body>
  
          <struts:fielderror />
  
          <struts:form action="loginPerson">
              <struts:label value="登陸系統"></struts:label>
              <struts:textfield name="account" label="賬號"></struts:textfield>
              <struts:password name="password" label="密碼"></struts:password>
              <struts:submit value="登陸"></struts:submit>
          </struts:form>
  
      helloween, 1234
  
  </body>
</html>

配置web.xml文件
Struts1使用ActionServlet做爲分發器，struts2使用filter做爲分發器，需在web.xml的最後面配置struts的filter；修改action後綴可在web.xml或者struts.properties內配置struts.action.extension爲其餘值；
<!-- Struts2的Filter的URI配置 -->
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

<filter>
        <filter-name>struts</filter-name>
        <filter-class>
            org.apache.struts2.dispatcher.FilterDispatcher
        </filter-class>
        <!-- 
            <init-param>
            <param-name>actionPackages</param-name>
            <param-value>com.helloweenvsfei.struts2.action</param-value>
            </init-param>
            <init-param>
            <param-name>struts.action.extension</param-name>
            <param-value>helloween</param-value>
            </init-param>
        -->
    </filter>
Struts2工做流程
    新建loginaction.java------在struts.xml配置該action名稱爲loginperson------登錄界面提交表單給名稱爲「loginperson」的action-----struts截獲請求-----查找struts.xml中名稱爲loginperson的action，建立名稱爲loginperson的action實例-----將提交的數據經過set方法設置到實例中----調用action的主方法execute（）------根據結果跳轉到配置的對應的welcome.jsp顯示界面。
Struts線程安全
    每次請求都會建立一個action實例，實例間彼此獨立，處理完後銷燬，因此線程安全；
16.2struts配置文件
Web.xml配置struts2的分發器filter，struts.properties配置struts2的默認屬性，可不添加該文件，struts.xml配置struts2的action；
Package有繼承的特性，子package能夠引用父package內的全部資源；package內能夠配置命名空間，訪問時須要加上命名空間；
16.3action詳解
Actionsupport類中實現了一些基本方法，例如數據校驗可直接被繼承的action的使用；action接口只定義了execute方法，和幾個經常使用的結果名稱（success，error等），action類能夠經過繼承action接口來實現，Actionsupport類也繼承與action接口；也能夠不繼承任何類和接口，只要實現execute方法便可；
自定義的action可執行方法
Action的可執行方法能夠是其餘方法，但必須是無參數返回值爲string的方法；
用login！loginout.action的url訪問；
或者須要在struts.xml中配置class後面加上method=「logout」， login爲配置文件中的action的名稱，loginout爲方法名稱；
還能夠經過通配符*來配置，避免配置login和logout兩種action輸出；
<action name =」*Person」   class=」」  method=」{1}」>
<result  name=」success」>/welcome.jsp</result >
<result  name=」{1}」>/{1}.jsp</result >
</action>

16.4用註解@代替struts.xml的配置
    直接在定義action的文件中經過註解的方式來實現action的配置，以下
@namespace (value=」/test」)             //命名空間
@Results({                          //結果集
@result（name=」success」, value =」/success.jsp」）,
@result（name=」redirect」, value =」/redirect.jsp」,type=ServletRedirectResult.class）
})

註解方式配置的action的訪問方式
    ，由於沒有訪問路徑的配置，須要去掉類名中的action，而且首字母小寫，例如Annotated Action的訪問方式爲annotated.action.annotated!login.action;
    零配置須要在web.xml中配置action包的位置，指定了actionPackage後，只會加載註解action，struts.xml配置文件中配置將失效；註解配置和strutsxml文件配置只能二選一；
<init-param>
<param-name>actionPackages</param-name>
<param-value>com.helloweenvsfei.struts2.action</param-value>
</init-param>

16.5 action中的pojo（簡單普通java對象，plain ordinary java object）
    Action中的定義的pojo類須要定義get和set方法，struts2會自動完成pojo屬性的賦值；使用struts：url標籤來標示，action的方法，調用時會自動添加.action的後綴，無需主動添加；以下所示；
<a href="<struts:url action="initAddBook" />">添加書籍</a>
<a href="<struts:url action="listBook" />">書籍列表</a>
<a href="<struts:url action="clearBook" />">清空書籍列表</a>
    禁用自動添加，能夠以下
<a href="<struts:url action="initAddBook"  includeParams=」none」/>">
或者直接在struts.properties中禁用全部的自動追加特性
Struts.url.includeParams=none

第16章 struts2.x高級應用
17.1日期時間轉換器
繼承與DefaultTypeConverter類，實現convertValue接口，三種日期格式和兩種時間格式放入數組內，而後根據輸入數據的類型，循環調用每種格式轉換，正確的返回值；
    在配置文件xwork-conversion.properties中配置數據類型對應的轉換器（或者在struts的action中配置convertor=「com.helloweenvsfei.struts2.convertor.DatatimeConvertor」,這樣只能被該action使用）------輸入界面輸入提交信息給action-----struts截獲請求查找配置文件中action將提交的數據（是string類型，經過配置的轉換器轉化爲對應的時間日期類型）注入到action的屬性中，-----根據提交時的方法名稱convert調用方法convert（）-------返回success------action根據返回結果跳轉到對應的jsp顯示界面。
17.2ServletActionContext類
    需包含import org.apache.struts2.SeveletActionContext；該類中包含request、Response、ServletContext等對象；
    或者實現*Aware（ServletContextAware、ServletRequestAware、ServletResponseAware、SessionAware）接口來，並實現set*方法（session的方法是setSession(Map sessionValues),map表示內部存儲的各類數據，），將數據注入action的屬性中；
17.3validator校驗數據
    支持校驗必須繼承Validateable接口，actionsupport類就繼承該接口；在package內添加校驗配置文件，名稱按照格式Action類名-validation.xml或者Action類名-Action別名-validation.xml;例以下：
!DOCTYPE validators PUBLIC
"-//OpenSymphony Group//XWork Validator 1.0//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
    <!-- 檢查書名，必須非空 -->
    <field name="book.name">
        <field-validator type="requiredstring">
            <param name="trim">true</param>
            <message>請輸入書籍名稱</message>
        </field-validator>
    </field>
    <!-- 檢查做者，必須非空 -->
    <field name="book.author">
        <field-validator type="requiredstring">
            <message>請輸入書籍做者</message>
        </field-validator>
    </field>
    <!-- 檢查出版日期。 -->
    <field name="book.publishedDate">
        <field-validator type="date">
            <param name="min">1900-01-01</param>
            <param name="max">2200-01-01</param>
            <message><![CDATA[ 日期格式必須位於 1900-01-01 與 2200-01-01 之間 ]]></message>
        </field-validator>
    </field>
</validators>

    客戶端validator校驗配置，<struts:form>標籤添加validate=「true」屬性；
    或者經過註解來添加校驗；

 
第18章 struts 標籤
18.1struts2標籤
統一包含在struts-tags-tld文件中，位於Struts-core-2.0.11.1.jar的META-INF中；
18.2ognl語言
（object-graph navigation language）是操做對象屬性的語言，能夠用#獲取上下文的資源；
#parameters表示request提交的全部參數，#request表示request的全部屬性；
流程
先action繼承ServletContextAware、ServletRequestAware、SessionAware接口，定義對象屬性，和set方法，execute（）方法設置對象的一些屬性值；在ognlSUCCESS.jsp中直接經過<struts:property  value=」#request.account」>顯示值；
18.3控制標籤
<struts:if  test=」name= ‘ kuto’ 」> hello kuto </struts:if> 
<struts:elseif test=」name= ‘ fvssd’ 」> hello fvssd </ struts:elseif >
<struts:else> hello other </ struts:elseif >


第19章 struts2攔截器和文件上傳
19.1 使用攔截器
面向切面的開發思想，把相對獨立的代碼抽象出來，如數據轉換和數據校驗，action在struts.xml中配置的時候，package中須要繼承struts-default才能使用struts的攔截器，以下
<package name="main" extends="struts-default">
Struts有不少現成的攔截器
Timer計時攔截器計算action執行的時間
<action name="timer"
            class="com.helloweenvsfei.struts2.action.TimerAction">
            <interceptor-ref name="timer"></interceptor-ref>
            <result>/timerSuccess.jsp</result>
        </action>
Token防重複提交攔截器
<action name="token"
            class="com.helloweenvsfei.struts2.action.TokenAction">
            <interceptor-ref name="token"></interceptor-ref>
            <interceptor-ref name="basicStack" />//必須的，自動賦值攔截器集合
            <result>/tokenSuccess.jsp</result>
            <result name="input">/tokenInput.jsp</result>
            <result name="invalid.token">/tokenInvalid.jsp</result>//失敗跳轉界面，必須
        </action>
表單中要加一個<struts:token />標記，纔會觸發token攔截器；這個標記在Session中生成表單的惟一標示，提交一次後失效；
execAndWait執行等待攔截器顯示等待頁面
<action name="wait"
            class="com.helloweenvsfei.struts2.action.WaitAction">
            <interceptor-ref name="completeStack" />//完成後觸發
            <interceptor-ref name="execAndWait" />等待觸發
            <result>/waitSuccess.jsp</result>
            <result name="wait">/waiting.jsp</result>
        </action>

自定義權限驗證攔截器
自定義攔截器要繼承interceptor接口或者abstractInterceptor抽象類，是一個java文件，須要實現intercept（ActionInvocation  invocation）return invocation.invoke();表示繼續調用action，不然權限不經過返回登錄界面return action.LOGIIN；定義好intercept類後須要在struts.xml中配置該攔截器，以下
<interceptors>
            <interceptor name="authentication"
                class="com.helloweenvsfei.struts2.interceptor.AuthenticationInterceptor">
            </interceptor>
</interceptors>
而後在須要使用該攔截器的action中配置該攔截器，與struts2的默認攔截器配置相同；
<action name="authentication"
            class="com.helloweenvsfei.struts2.action.AuthenticationAction">
            <interceptor-ref name="authentication"></interceptor-ref>
            <result>/authenticationSuccess.jsp</result>
        </action>

19.2上傳文件
Struts2文件封裝在java.io.File中，須要定義一個對象用於接收表單上傳的文件，struts2會將文件複製到一個臨時文件夾中，以時間戳爲名，後綴爲|.tmp，避免重複，File屬性保存的就是這個臨時文件的路徑加名字；要獲取該文件的原始名稱和原始屬性，須要定義string類型的屬性，命名格式爲XXFileName和XXContentType，struts2會將原文件名和類型輸入到這兩個屬性上;須要用循環寫入的方式複製文件數據；
package com.helloweenvsfei.struts2.action;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

public class UploadAction extends ActionSupport {

    private static final long serialVersionUID = -60950803930068947L;

    private File picture;//定義file屬性保存臨時文件名

    private String pictureContentType; //保存數據類型File對象名字+ContentType

    private String pictureFileName;//保存文件的真實名字File對象名字+FileName
    public String execute() {
        return "input";
    }

    public String upload() throws Exception {

        System.out.println("Context: "
                + ServletActionContext.getServletContext()
                        .getRealPath("upload"));

        System.out.println("File: " + picture);

        System.out.println("FileName: " + pictureFileName);

        File saved = new File(ServletActionContext.getServletContext()
                .getRealPath("upload"), pictureFileName);//建立保存的文件

        InputStream ins = null;
        OutputStream ous = null;

        try {
            saved.getParentFile().mkdirs();

            ins = new FileInputStream(picture);
            ous = new FileOutputStream(saved);

            byte[] b = new byte[1024];
            int len = 0;

            while ((len = ins.read(b)) != -1) {//循環讀取臨時文件數據保存到服務器的文件中
                ous.write(b, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ous != null)
                ous.close();
            if (ins != null)
                ins.close();
        }

        return "list";
    }

    public File getPicture() {
        return picture;
    }

    public void setPicture(File file) {
        this.picture = file;
    }

    public String getPictureContentType() {
        return pictureContentType;
    }

    public void setPictureContentType(String fileContentType) {
        this.pictureContentType = fileContentType;
    }

    public String getPictureFileName() {
        return pictureFileName;
    }


    public void setPictureFileName(String fileFileName) {
        this.pictureFileName = fileFileName;
    }

}

上傳文件的設置
    默認使用javax.servlet.context.tempdir做爲工做目錄，能夠經過設置struts.multipart.saveDir屬性修改目錄，struts.multipart.maxSize來修改最大上傳文件大小，默認2097152byte；自帶的攔截器能夠設置
<interceptor-ref name="fileUpload">
                <param name="allowedTypes">
                    image/bmp,image/x-png,image/gif,image/jpeg
                </param>
                <param name="maximumSize">20480</param>
            </interceptor-ref>
 
第20章 hibernate入門
20.1hibernate簡介
Hibernate是一種對象-關係數據庫-映射（ORM，object-relative database-mapping），將pojo拆分紅各類屬性自動組織sql語句，保存到數據庫；或者將數據中數據抽取出來，拼裝成pojo對象返回；
20.2使用hibernate步驟
新建webproject------右鍵addhibernateCapabilities------添加hibernate包------配置實體類----在hibernate.cfg.xml中配置數據庫鏈接信息，還有註解實體類信息或者無註解的實體類+類配置文件信息；-----建立CatTest.java文件，severlet的main函數中建立Session至關於數據庫鏈接------建立Transaction至關於任務-------而後用Session的函數去實現對象與數據庫記錄之間的映射； 
能夠將Hibernate的的數據庫操做封裝成一個類，將Session和transaction的建立和銷燬封裝起來；建立BaseDAO.java文件內部參數採用object，能夠接收任意的實體類，hibernate實現實體類和數據庫之間的數據交互；在severlet的doPost函數中根據不一樣的參數來調用不一樣的函數，函數中調用BaseDAO中封裝的數據庫操做函數；
package com.helloweenvsfei.hibernate.bean;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.QueryHint;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

//@NamedQuery(name = "all cat", query = " select c from Cat c ")
//@NamedNativeQuery(name = "all cat", query = "select * from tb_cat")
@NamedQueries(value = {
        @NamedQuery(name = "all cat", query = " select c from Cat c "),
        @NamedQuery(name = "cat by name", query = " select c from Cat c where c.name = :name ", hints = { @QueryHint(name = "org.hibernate.callable", value = "true") }),
        @NamedQuery(name = "cat by mother", query = " select c from Cat c ") })
//@NamedNativeQueries(value = {
//        @NamedNativeQuery(name = "all cat", query = "select * from tb_cat"),
//        @NamedNativeQuery(name = "all cat", query = "select * from tb_cat"),
//        @NamedNativeQuery(name = "all cat", query = "select * from tb_cat") })
@Entity
// 註解Entity表示該類能被Hibernate持久化
@Table(name = "tb_cat")
// 指定該Entity對應的數據表名
public class Cat {

    @Id
    @Column(name = "id")
    // 指定該列爲主鍵
    @GeneratedValue(strategy = GenerationType.AUTO)
    // 主鍵類型, auto爲數據庫自增加類型
    private Integer id;

    @Column(name = "name")
    // 指定屬性對應的數據庫表的列爲「name」
    private String name;

    @Column(name = "description")
    // 同上。@Column與name都可省略
    private String description;

    @ManyToOne
    // 指定POJO之間的關係，本例爲多對一關係
    @JoinColumn(name = "mother_id")
    // 該屬性對應的列
    private Cat mother;

    @Temporal(TemporalType.TIMESTAMP)
    // 日期類型（DATE, TIME仍是TIMESTEMP）
    @Column(name = "createDate")
    private Date createDate;

    @OneToMany(mappedBy = "cat")
    // @JoinColumns(value = { @JoinColumn(name = "cat_id", referencedColumnName
    // = "id") })
    private List<Event> events = new ArrayList<Event>();
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Cat getMother() {
        return mother;
    }
    public void setMother(Cat mother) {
        this.mother = mother;
    }
    public Date getCreateDate() {
        return createDate;
    }
    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public List<Event> getEvents() {
        return events;
    }
    public void setEvents(List<Event> events) {
        this.events = events;
    }
}
Hibernate操做數據庫
    // 開啓一個 Hibernate 對話
        Session session = HibernateSessionFactory.getSessionFactory()
                .openSession();
        // 開啓一個事務
        Transaction trans = session.beginTransaction();

        // 將三隻貓的資料保存到數據庫
        session.persist(mother);
        session.persist(kitty);
        session.persist(mimmy);

        // 查詢數據中的全部的貓
        @SuppressWarnings("all")
        List<Cat> catList = session.createQuery(" from Cat ").list();

        StringBuffer result = new StringBuffer();
        result.append("數據庫裏的全部的貓：\r\n\r\n");

        // 遍歷 輸出貓與貓媽媽
        for (Cat cc : catList) {
            result.append("貓: " + cc.getName() + ",          ");
            result.append("貓媽媽: "
                    + (cc.getMother() == null ? "沒有記錄" : cc.getMother()
                            .getName()));
            result.append("\r\n");
        }
    trans.commit();//結束事物
    session.close();//關閉Session


第21章 從宏觀上把握hibernate
SessionFactory是一個線程安全的Session工廠類，爲不一樣的線程提供Session，維護這Session的相關德爾資源，包括數據庫鏈接池等、緩存信息；
Transaction表明一次事物，事物提交後，修改的數據操做纔會生效。
在hibernate.properties中配置數據庫的類型和鏈接信息，在hibernate.cfg.xml中配置註解實體類或者實體類的配置文件；
第22章hibernate實體映射
主鍵配置（用@id申明主鍵，用@cloumn申明該列的名稱，@GeneratedValue指定生成策略，能夠是自增加、源於其餘表格、sequence等）；主鍵生成規則（GenerationType.AUTO、GenerationType.TABLE、GenerationType.SEQUENCE、 GenerationType.INDENTITY）、
普通屬性配置，使用@Cloumn配置，屬性nullable（是否容許爲null）、unique（是否惟一）、insertable（是否容許插入）updateable（是否容許更新）、length（列長度）、cloumnDefinition（列類型）、scale（整數長度）、precision（小數點精度）；
@Cloumn（name=「salry」，nullable=true，cloumnDefinition=「number」，insertable=true）
用@Basic爲普通屬性配置加載方式，默認及時加載，若是數據比較大，可設置爲延時加載,optional配置該列是否能夠爲null；
@Basic（fetch=FetchType.LAZY,optional=true）// FetchType.EAGER
配置日期屬性配置；若是日期類型是java.util.Date類型，必須用@temporal配置日期類型。若是是java.sql.Date、 java.sql. Time、java.sql.TimeStamp，則無需申明；
@Temporal（TemporalType.TIMESTAMP）
@Cloumn(name=」createDate」)
Private java.util.Date createDate;
    臨時屬性；@Transient標註，表示臨時爲了方便計算而建立的屬性，不會寫入數據庫；對應的getset方法也要配置；而對於全部沒有配置到配置文件中都是臨時屬性；
    版本屬性；樂觀鎖和悲觀鎖@Version；悲觀鎖操做時鎖住，完成後釋放；樂觀鎖採用Version屬性來判斷是否被修改，是否要從新讀取；容許多條線程同時訪問數據；
@version
Private int version；//註解配置
<version name =」version」></version>//要配置在主鍵後，普通屬性前
<version type「timestamp」 column=」version」></version>//配置文件配置能夠是int、long、Timestamp；
第24章 Hibernate查詢語言HQL
    HQL是面向對象的語言，直接將對象用於數據庫查詢語句，大小寫不敏感，同名時用package區分；
查詢數量計數
Number num=（Number）Session.createQuery(「select count(c) from Cat c」).uniqueResult();
返回集合屬性
List<stirng[]> namelist =session.createQuery(「select c.name,c.mother.name from Cat c」).list();
List<Cat> catlist=session.createQuery(select c.mother from Cat c).list();
返回不一樣的多個對象,對象數組
List<Object[]> olist=session.createQuery(「select c.name,c.mother ,c.createDate from Cat c」).list();
返回list類型
List<List> list2=session.createQuery(「Select new list（c.name,c.mother,c.createDate）from Cat c」).list();
返回map類型
List listmap=Session.createQuery(「select new map(c.name as name,c.mother as mother, c.createDate as createDate ) from Cat c)」).list();
返回java實體對象
List<Cat> catlist=session.createQuery(「select new Cat(cat.name,cat.createDate) from Cat c」).list();
條件語句
Session.createQuery(「select c from Cat c where c.mother=null and c.createDate <:createDate」).setParameter(「createDate」,new Date()).list();
統計函數
語句中Count（）、sum（）min（）、max()，avg（）、count（）；返回 uniqueResault（）類型與主鍵類型相同；
分頁查詢數據，獲取查到的數據
List<Cat> cslist =session.createQuery(「from Cat」).setFirstResult(0).setMaxResault(10).list();
跨表查詢
Select e From event e where e.cat.name=’ketty’   查詢Event和cat表；
級聯查詢
List<Cat> blist=session.createQuery(「Select c from Cat c left join c.events e where e.description like :description」).setParameter(「description」,」%吃早飯%」).List();
SQL查詢
Session.createSQLQuery(「select * from tb_cat」);
@配置命名查詢
將經常使用的查詢用一個字符串來代替，至關於宏定義,在實體類的定義的前面配置
@NameQuery（name=」all cat」,query=」select c from Cat c」）//配置HQL查詢
@NameNativeQuery（name=「all cat」，query=「select * from tb_cat」）
在xml配置文件中配置命名查詢,name配置查詢的名稱，<return/>配置返回數據類型；
<sql_query name=」cat all」><![CDATA[]]><return alias=」」,class=com.helloweenvsfei. hibernate.bean.Cat/></sql_query>；

第26章 Spring概述
26.1Spring 框架
Spring是一種輕量級的框架或容器，通常的程序是從外到內的過程，即程序應用層（main函數實例化服務對象，調用服務的接口函數）、service層（實現服務接口函數，實例化DAO對象，並調用其方法）、DAO層（實現真正的業務邏輯）；而Spring則是從內到外的一個過程；
Spring使用流程，定義IDao的接口和實現類DaoImpl，定義IService接口和ServiceImpl實現類，在ServiceImpl定義IDao變量和set、get方法；而不是調用DAOimpl對象；經過配置文件將serviceImpl與DaoImpl類關聯起來，創建依賴關係,至關於service.setDao(DaoImpl);Spring在運行時，根據配置注入依賴的對象，Spring實例化對象並維護對象，在編碼階段沒有實例化，而是在運行階段注入對象，並實例化、組裝對象、維護對象，與傳統的寫代碼，實例化、組裝對象，執行方法方向相反；
<bean id="serviceImpl"
        class="com.helloweenvsfei.spring.example.ServiceImpl">
        <property name="dao">    
<bean class="com.helloweenvsfei.spring.example.DaoImpl"></bean>
        </property>
    </bean>
或者按照下面的配置
<!-- dao 實例 -->
<bean id="daoimpl" class="com.helloweenvsfei.spring.example.DaoImpl">
</bean>
<bean id="serviceImpl"
        class="com.helloweenvsfei.spring.example.ServiceImpl">
        <property name="dao" ref=」 daoimpl」></property>
</bean>
26.3面向切面的編程
面向切面編程（Aspect oriented programming）將程序分紅獨立的幾段，能夠按不一樣順序執行，方便添加刪除功能；Spring實現了特定的AOP便可的類稱爲攔截器；
package com.helloweenvsfei.spring.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class MethodBeforeInterceptor implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object instance)方法、參數、實例；
            throws Throwable {
        System.out.println("即將要執行方法：" + method.getName());
        if (instance instanceof AopServiceImpl) {
            String name = ((AopServiceImpl) instance).getName();
            if (name == null)
                throw new NullPointerException("name屬性不能爲null");
        }
    }
}
第27章 Spring的core模塊
Core的主要功能是實現反向控制、依賴注入、beans配置和加載；有Beans、BeanFactory（加載beans）、BeanDefinition（beans的定義）ApplicationContext（配置文件）；
27.1BeanFactory工廠
BeanFactory根據配置實例化beans對象，並設置相互依賴性，將beans注入sevelet、struts的Action中、Hibernate資源中；web程序無需實例化BeanFactory，自動實例化；java桌面程序中須要根據配置文件加載實例化，用ClassPathResourse加載ClassPath下的文件，或者用FileInputStream加載任意路徑的配置文件，或者用ClassPathXmlApplicationContext加載多個配置文件；
27.2 配置java bean
配置文件中用id配置名稱，class配置類名，必須兩個參數；若是爲工廠類（無類名構造函數），須要用factory-bean配置類名，factory-method配置構造函數名稱；若是構造函數有參數，須要用<constroctor-arg><ref bean =」yetBean」/></constroctor-arg>配置參數；
單態模式singleton，默認爲單態模式，非單態模式須要設置bean屬性singleton=「false」；
屬性設置，經過<property  name=」」, value=」」></property>配置，Spring根據set方法設置；
<bean id="dataSource"//id和class必須
        class="org.apache.commons.dbcp.BasicDataSource"
<constroctor-arg><ref bean =」yetBean」/><constroctor-arg>//配置構造函數的兩個參數，一個bean參數，一個數值參數， ref表示引用配置文件中其餘的bean；yetBean爲id
<constroctor-arg><value>1</value></constroctor-arg>
        destroy-method="close" （關閉方法，析構函數）singleton=」true」>//單態模式
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />//配置屬性
        <property name="url"
            value="jdbc:mysql://localhost:3306/spring?characterEncoding=UTF-8" />
        <property name="username" value="root" />
        <property name="password" value="admin" />
</bean>
配置list、set、map屬性
<property name="interceptorNames">//list屬性配置
            <list>
                <value>aopMethodBeforeInterceptor</value>
                <value>aopMethodAfterInterceptor</value>
                <value>aopThrowsInterceptor</value>
            </list>
</property>
<property name="interceptorNames">
            <set>//set屬性配置
                <value>aopMethodBeforeInterceptor</value>
            </set>
</property>

<property name="someMap">
            <map>//map屬性配置
            <entry key="yup an entry">//map鍵值對的鍵
            <value>just some string</value>//map鍵值對的值
            </entry>
            <entry key-ref="myDataSource">//bean map
            <ref bean="myDataSource" />
            </entry>
            </map>
</property>
depend-on設置依賴關係，加載以前先加載依賴的對象；
<bean id="personDao"
        class="com.helloweenvsfei.spring.dao.PersonDaoImpl"
        depends-on="dataSource" init-method="initDatabase">//依賴關係和初始化方法
        <property name="dataSource" ref="dataSource"></property>
</bean>
27.3屬性自動裝填autowire
<bean id="d" class="examples.D" autowire="byType"></bean>設置bean爲自動裝填後，會根據設置的規則去自動設置，不用<property  name=」」 value=」」>設置；
27.4依賴檢查dependency
檢查bean的屬性是否被設置，還能夠設置爲no、simple、object、all；
<bean id="bean" class="examples.Bean" dependency-check="all"></bean>，
27.5Bean的高級特性
繼承Spring的一些接口BeanNameAware和BeanFactoryAware，設置或獲取bean的id、BeanFactory和初始化和銷燬函數，可是會使程序與Spring耦合，依賴Spring的類庫；
27.6BeanFactory高級特性
若是實現了BeanFactoryAware接口，能夠獲取BeanFactory對象，能夠調用他的方法判斷是否包含Bean，獲取指定名稱的bean，是否配置爲singleton等；
第28章 Spring的AOP模塊
28.1攔截器的使用
AOP是面向切面的編程方法，將一個業務流程分紅幾部分實現，再組裝成一個完整的流程；
先定義IAopServiceAop.java接口，定義兩個函數withaop和withoutaop；建立IAopServiceAopImpl.java實現類，實現兩個方法；建立文件*interceptor.java實現MethodBeforeAdvice、AfterReturningAdvice、ThrowsAdvice接口，實現三種攔截器；在配置文件ApplicationContext.xml中配置三種攔截器和攔截的方法，配置service對象，並採用list配置三種攔截器；在main函數中執行方法；
    Spring沒法將service實現類和攔截器直接組裝，須要把攔截器安裝到代理類NameMatchMethodPointcutAdvisor，把自定義的Service安裝到ProxyFactoryBean中，
<!-- 攔截器 在 withAop() 方法前運行 -->
    <bean id="aopMethodBeforeInterceptor"
        class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="advice">
            <bean
                class="com.helloweenvsfei.spring.aop.MethodBeforeInterceptor" />
        </property>
        <property name="mappedName" value="withAop"></property>
    </bean>

    <!-- 攔截器 在 withAop() 返回後運行 -->
    <bean id="aopMethodAfterInterceptor"
        class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="advice">
            <bean
                class="com.helloweenvsfei.spring.aop.MethodAfterInterceptor" />
        </property>
        <property name="mappedName" value="withAop"></property>
    </bean>

    <!-- 攔截器 在異常拋出後運行 -->
    <bean id="aopThrowsInterceptor"
        class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="advice">
            <bean
                class="com.helloweenvsfei.spring.aop.ThrowsInterceptor" />
        </property>
        <property name="mappedName" value="withAop"></property>
    </bean>
<bean id="aopService"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 攔截器 -->
        <property name="interceptorNames">
            <list>//用list配置三種攔截器
                <value>aopMethodBeforeInterceptor</value>
                <value>aopMethodAfterInterceptor</value>
                <value>aopThrowsInterceptor</value>
            </list>
        </property>
        <!-- 被攔截的對象 -->
        <property name="target">
            <bean
                class="com.helloweenvsfei.spring.aop.AopServiceImpl">
                <!-- 
                    <property name="name"><null /></property>
                    <property name="name" value="Helloween"></property>
                -->
            </bean>
        </property>
    </bean>
在main函數中執行函數
package com.helloweenvsfei.spring.aop;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class AopRun {
    public static void main(String[] args) throws Exception {
        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource(
                "applicationContext.xml"));
        IAopService hello = (IAopService) factory.getBean("aopService");
        hello.withAop();
        hello.withoutAop();
        factory.destroySingletons();
    }
}

28.2攔截器和Filter區別
二者都是基於AOP的編程思想；在程序應用範圍、使用容器、使用資源、使用深度上有所區別；Filter只能用於web程序，攔截器還能夠用於Application和swing；filter適用Servlet容器，攔截器適用於Spring容器；攔截器可使用的資源更多；filter只能在servlet先後使用，Spring更深刻，能在方法先後使用；


第29章 Spring的DAO模塊
29.1數據庫操做封裝
    Spring對jdbc進行了封裝，不須要進行數據庫鏈接和事物提交等工做；直接用jdbcTemplate執行SQL語句；
    實現步驟 定義Person.java文件實現Person類，定義屬性和set、get方法；建立IPersonDao.java文件，定義操做接口；建立PersonDaoImpl.java文件，實現IPersonDao接口並繼承與JdbcDaoSupport類，實現接口函數是對象與數據庫的映射關係，並定義初始化initDateBase（）函數用於建立數據庫表格，JdbcDaoSupport類封裝了數據庫鏈接和任務，經過jdbcTemplate執行sql語句，getJdbcTemplate（）獲取對象，調用方法queryForList（sql），update（sql，new object[]{}）；在ApplicationContext.xml配置文件中配置數據源，即數據庫的類型、名稱、url、登錄用戶名和密碼等信息；在配置文件的DAO中配置數據源和初始化函數；運行程序，建立DaoRun.java文件，在main函數中建立BeanFactory對象，加載
29.2實體對象與數據庫映射
繼承MappingSqlQurry抽象類，實現mapRow接口，接口內將查詢結果賦值給對象，須要調用setDateSource()、setsql（）函數設置數據源和sql語句，調用compile（）執行編譯，調用declareParameter（）設置參數，調用execute（）返回結果；
ApplicationContext.xml文件，獲取IPersonDao對象，調用對象的函數實現對象到數據庫的操做；
package com.helloweenvsfei.spring.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.object.MappingSqlQuery;
public class PersonMappingQuery extends MappingSqlQuery {
    @Override
    protected Object mapRow(ResultSet rs, int columnIndex) throws SQLException {
        Person person = new Person();
        person.setId(rs.getInt("id"));
        person.setName(rs.getString("name"));
        person.setSex(rs.getString("sex"));
        person.setAge(rs.getInt("age"));
        person.setBirthday(rs.getTimestamp("birthday"));
        return person;
    }
}

繼承SqlUpdate類，執行SQL更新語句。繼承SqlDunction返回單一結果；
29.3Spring的事物管理
Spring默認在DAO的方法上加事物，一個方法算一個事物；可是一個方法執行失敗不會讓上一個方法回滾；
先配置一個事物管理者jdbcTransactionManager，傳入數據源信息，在ApplicationContext.xml按照bean配置；爲事物管理者配置事物屬性transactionAttributeSource；爲IPersonDao類配置管理者和管理屬性；run方法中某個調用函數失敗，整個run方法會回滾；
    <!-- JDBC 事務管理 -->
    <bean id="jdbcTransactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">//事物管理者
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 爲全部的方法配置事務 -->
    <bean id="transactionAttributeSource"
    class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
        <property name="properties">
            <props>
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>

    <!-- 
        <bean id="transactionRun"
        class="com.helloweenvsfei.spring.dao.TransactionRun">
        <property name="personDao" ref="personDao"></property>
        </bean>
    -->

    <!-- TransactionRun ,被管理的對象-->
    <bean id="transactionRun"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager"
            ref="jdbcTransactionManager" />
        <property name="target">
            <bean
                class="com.helloweenvsfei.spring.dao.TransactionRun">
                <property name="personDao" ref="personDao"></property>
            </bean>
        </property>
        <property name="transactionAttributeSource"
            ref="transactionAttributeSource" />
    </bean>
第30章 Spring的ORM模塊
30.1Spring保存實體類
Spring封裝了hibernate的Session和transation，內部管理這些資源；讓用戶只需關心對象與數據庫之間的關係映射（Object-Relational Mapping）；
使用步驟
建立Cat.java文件，定義Cat實體類，加註解；建立ICatDao.java文件定義ICatDao接口；建立CatDaoImpl.java文件實現ICatDao接口並繼承HibernateDaoSupport類，該類提供HibernateTemplate對象對實體類進行操做；
package com.helloweenvsfei.spring.orm;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class CatDaoImpl extends HibernateDaoSupport implements ICatDao {
    public void createCat(Cat cat) {
        this.getHibernateTemplate().persist(cat);
    }
    public Cat findCatByName(String name) {
        List<Cat> catList = this.getHibernateTemplate().find(
                " select c from Cat c where c.name = ? ", name);
        if (catList.size() > 0)
            return catList.get(0);
        return null;
    }
    public int getCatsCount() {
        return (Integer) this.getSession(true).createQuery(
                " select count(c) from Cat c ").uniqueResult();
    }
    public List<Cat> listCats() {
        return this.getHibernateTemplate().find(" select c from Cat c ");
    }
}
30.2Spring中配置Hibernate
須要在ApplicationContext.xml中配置數據源、SessionFactory及CatDaoImpl、實體類；先配置數據源，而後配置SessionFactory，在SessionFactory中配置數據源，和加載的實體類路徑和實體類名稱，最後配置實體類操做類DAOImpl，設置SessionFactory屬性；也能夠加載配置文件配置的實體類；
<bean id="dataSource"配置數據源
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url"
            value="jdbc:mysql://localhost:3306/spring?characterEncoding=UTF-8" />
        <property name="username" value="root" />
        <property name="password" value="admin" />
    </bean>
<!-- Spring SessionFactory -->配置SessionFactory
    <bean id="sessionFactory"
    class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
        destroy-method="destroy">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedPackages"配置實體類的加載路徑
            value="classpath:/com/helloweenvsfei/spring/orm">
        </property>
        <property name="annotatedClasses">配置實體類
            <list>
                <value>com.helloweenvsfei.spring.orm.Cat</value>
            </list>
        </property>
        <property name="hibernateProperties">配置Hibernate屬性
            <props>
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.MySQLDialect
                </prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>
    </bean>

    <bean id="catDao"
        class="com.helloweenvsfei.spring.orm.CatDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>設置SessionFactory
    </bean>
30.3管理Hibernate事物
Spring默認在DAO層添加事物，每一個方法一個事物。在DAO層添加service，在service層添加事物；
先定義一個HibernateTransactionManager管理器，在管理器中添加SessionFactory；而後添加事物管理規則，爲全部的方法添加事物；藉助Spring的代理類TransactionProxyFactoryBean，爲DAOimpl配置事物管理器和管理規則
<bean id="hibernateTransactionManager"配置事物管理器
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />配置SessionFactory
    </bean>
    <bean id="hibernateTransactionAttributeSource"//配置事物管理規則
    class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">//使用代理類
        <property name="properties">
            <props>
                <prop key="*">PROPAGATION_REQUIRED</prop>//全部方法加上事物
            </props>
        </property>
    </bean>

    <bean id="catService"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager"
            ref="hibernateTransactionManager">
        </property>
        <property name="target">
            <bean
                class="com.helloweenvsfei.spring.orm.CatServiceImpl"> CatServiceImpl不能直接加事物，須要藉助TransactionProxyFactoryBean代理類
                <property name="catDao" ref="catDao"></property>//設置DAO依賴關係catDao是.CatServiceImpl的一個屬性
            </bean>
        </property>
        <property name="transactionAttributeSource"
            ref="hibernateTransactionAttributeSource">
        </property>
    </bean>

第31章 Spring的web模塊
31.1整合strut1.x:繼承方式
CatAction直接繼承ActionSupport類，GetWebApplicationContext().getBean(「iCatService」)先獲取beanFactory，而後再獲取各類資源；在CatAction中添加execute方法，做爲action的主方法，根據action的動做執行方法；而後在struts配置文件中配置action對應的文件名稱。
Spring和struts須要配置到web.xml文件中，Spring要配置ApplicationContext.xml的位置，以及加載配置文件的ContextLoadLisener