JavaWeb平常筆記

時間 2019-11-09

標籤 javaweb 平常筆記欄目 Java 简体版

原文原文鏈接

1. XML文檔的做用和解析

1. XML的基本概述：css

XML的主要是用來存儲一對多的數據，另外還能夠用來當作配置文件存儲數據。XML的表頭以下：html

<?xml version='1.0' encoding='UTF-8' ?>前端

使用代碼獲取此項目在電腦中的絕對路徑方法以下所示：java

URL path = 類名.class.getResource("/");mysql

使用此方法能獲取此項目的scr目錄在電腦中的絕對地址。jquery

2. XML約束的注意事項：linux

後綴名爲.xsd的約束文檔中的關鍵內容c++

<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'git

//標準的名稱空間程序員

targetNamespace='http://www.itheima.com'

//將該schema文檔綁定到http://www.itheima.com名稱空間>

後綴名爲.xml的XML文檔中的關鍵內容

<itheima:書架 xmlns:itheima="http://www.itheima.com"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.itheima.com book.xsd">

如上加粗所示，爲在XML文檔中引用約束文檔中的約束，使用名稱空間引用。

3. 解析XML文件

XML中有兩種經常使用的解析方式，分別是DOM解析和SAX解析，因爲DOM解析功能強大，因此通常使用DOM下的DOM4J來解析XML文檔。DOM解析是將整棵樹一口氣所有加載到內存當中, 咱們能夠很是方便的操做任意的標籤和屬性.可是, 若是整棵樹特別大的時候, 會出現內存溢出的問題。

DOM4J的解析步驟以下：

//1.建立XML解析器

SAXReader saxReader = new SAXReader();

//2.使用解析器加載XML文檔數據，並獲取Document對象

Document document = saxReader.read(new File("person.xml"));

//3.根據document對象獲取xml文檔根節點

Element rootElt = document.getRootElement();

//輸出根節點對象

System.out.println(rootElt);

DOM4J解析中的經常使用方法以下：

element.elmennts(),獲取父標籤全部的子元素對象列表

element.element(標籤名)，根據指定的標籤名獲取元素標籤的直接子元素對象

element.elements(標籤名)，父標籤根據指定標籤名獲取子元素標籤列表對象

element.elementText(標籤名)，父標籤根據指定標籤名直接獲取子標籤文本

Element.attributes(),後期標籤全部屬性對象列表

Element.attribute(屬性名)，獲取指定的屬性對象

Element.attributeValue(屬性名)，直接獲取指定的屬性的值

4. 使用代碼建立XML文件

建立XML中需注意以下問題：

//緊湊型格式,建議在企業工做開發中使用

OutputFormat format1 = OutputFormat.createCompactFormat();

//漂亮的格式，建議學習測試的時候使用

OutputFormat format2 = OutputFormat.createPrettyPrint();

使用代碼建立XML文檔有2種方式，一種是讀取一個XML文件獲取document對象，再使用這個document對象進行XML的建立，還有一種是構建一個全新的document對象，再進行寫出，第二種的實現代碼以下所示。

//1.建立Document對象

Document document = DocumentHelper.createDocument();

//1.1.設置文檔的編碼

document.setXMLEncoding("UTF-8");

//2.構建Document對象數據

//2.1.構建根節點

Element rootElt = document.addElement("books");//addElement方法返回添加的標籤節點對象

//2.2.構建子節點book

Element bookElt =rootElt.addElement("book");

//2.2.建立子節點屬性id

bookElt.addAttribute("id", "001");

//2.3.構建子子節點數據

bookElt.addElement("title").setText("《java開發實戰》");

bookElt.addElement("price").setText("88");

bookElt.addElement("pubDate").setText("2016年12月27日");

//3.建立文件輸出流

FileOutputStream out = new FileOutputStream(new File("books.xml"));

//4.建立XML文件寫出器

//4.1.建立格式化器

OutputFormat format1 = OutputFormat.createCompactFormat();//緊湊型格式,建議在企業工做開發中使用

OutputFormat format2 = OutputFormat.createPrettyPrint(); //漂亮的格式，建議學習測試的時候使用

XMLWriter writer = new XMLWriter(out,format2);

//5.xml文件寫出

writer.write(document);

//6.關閉流資源

writer.close();

System.out.println("books.xml生成成功");

2. HTML的基本標籤

1. <meta charset="utf-8" /> 指定網頁的字符集

2. <meta name="keywords" content="Java培訓,Android培訓,安卓培訓"> 告訴搜索引擎，當前網頁的搜索關鍵字

3. <meta name="Description" content="描述信息..."/> 用於對整個網頁信息概要描述的

4. <h1></h1> 標題標籤 h1~h6，數字越小，字越大。如h1表明1級標題。

align屬性：標題對齊的方式。left,向左對齊，默認；right,向右對齊；center，居中對齊。

5. <hr size="7" width="400" color="red" align="center"/> 水平線標籤，能夠設置大小，寬度，顏色和對其方式。

6. <font color="blue" size="30" face="楷體">內容</font> 用於設置字體、大小、顏色。HTML5中這個標籤已經淘汰

7. <strong></strong> <b></b> 這兩個標籤的功能徹底相同，都是用於字體的加粗

8. <i></i> 用於將字體設置爲斜體

9. <br/> 換行，沒有主體的標籤

10. <p title="段落"> 段落內容 </p> 用來表示一個段落，段落之間有段間距，段前沒有首行縮進。

title屬性：當鼠標移到段落上面的時候，會顯示提示文字。

11. 2<sup>3</sup> H<sub>2</sub>O sup和sub 上標和下標標籤

12. <pre>內容</pre> 在網頁上原樣輸出一段純文本，例：在網頁中原樣輸出一段Java代碼。

13. 有序標籤

</ol>

<ol></ol>: 有序列表的容器，會自動產生編號。orderly-label

<li></li>: 列表中的每一項

type屬性：默認取值爲數字編號，能夠取字母編號和羅馬數字編號。

14. 無序標籤

</ul>

<ul></ul>：無序列表的容器，會根據type的值產生樣式。unorderly-label

type屬性：（disc：實心圓）（circle：空心圓）（square：實心正方形）

15. 項目列表，後期主要用於網頁的佈局

<dl>

</dl>

dl: 列表容器

dt: 列表標題

dd：列表描述 describe

16. <span>內容</span> 行內標籤(內聯標籤)，只是在邏輯上將一段文字分紅不一樣的部分。通常用於對部分文字的操做。

17. <div>內容</div> 塊標籤，在邏輯上將網頁分紅不一樣的部分。每一個div會單獨佔一行。

18. 網頁上顯示的特殊字符：（<：<）（>：>）（版權符號：©）（人民幣符號：¥）（空格： ）

19. <a href="http://www.itcast.cn" target="_self">傳智播客</a>

(1) 用於在網頁上建立一個連接，點擊某個文字跳轉到其它頁面去。

href爲指定網頁的地址；target取值：_self 在當前網頁中打開地址，默認值，_blank：在新的頁面中打開地址。

(2) 打開發送郵件的客戶端，給指定的郵件發郵件。如：FoxMail。

例：<a href="mailto: newboy@itcast.cn">給我發郵件</a>

(3) 做爲錨點使用，當一個網頁特別長時，或者想要跳轉到網頁中不一樣的位置時(包括其餘網頁)，能夠使用錨點

定義錨點：<a name=」名字」>文字</a>

跳轉時href的寫法：<a href=」#名字」>文字</a>

20. <img src="img/girl1.jpg"/> 圖像標籤：用於在網頁上顯示圖片

src：指定圖片的地址 width：指定圖片寬 height：指定圖片高，能夠只指定一個，另外一個屬性按等比縮放

alt：若是圖片丟失，用於替代圖片的文字 title：當鼠標移到圖片上面的時候，出現的信息提示

21. 表格標籤

<caption>學生成績表</caption>

<thead>

<tr>

</tr>

</thead>

<tr>

</tr>

<tr>

</tr>

</table>

表格的結構：

標籤名	做用
table	表格的容器
tr	表格一行
th	列標題，特色：加粗，居中
td	單元格，顯示數據，默認左對齊
caption	表格的標題
thead	在邏輯上將表格分紅不一樣的部分，表示表格的頭部
tbody	不管代碼中是否加上，在瀏覽器上生成tbody標籤
tfoot	在邏輯上將表格分紅不一樣的部分，表示表格的腳部-

經常使用的表格屬性：

屬性名	做用
width	表格寬度
border	邊框的粗細
align	表格的對齊
rowspan	合併行，跨多少行
colspan	合併列，跨多少列
cellspacing	單元格之間的間隔
cellpadding	單元格邊框與內容之間間距
border-collapse: collapse	將整個表格的邊框和單元格合併

22. <frameset rows="30%,50%,*"><frameset> <frame src="main.html" name="main" />

框架標籤能夠將一個頁面劃分紅N個組成部分，每一個組成部分都是一個獨立html網頁。框架標籤主要用於將多個網頁組合成一個網頁顯示，這種功能叫欄式佈局，（一個頁面能夠分紅多個欄）。上述前段代碼將整個頁面分紅了3個部分，上面一部分佔百分之30，中間一部分佔百分之50，剩餘的是下面部分。

上述後段代碼爲將前段代碼分紅的3部分的具體顯示，frameset中不只能夠放frame，還能夠放frameset。

注意：frameset框架標籤所在的頁面不能有body標籤，必須將body刪除掉。

屬性名	做用
rows	每一行佔多高，*星號表示佔用剩下全部的空間。能夠用百分比或者px像素點表示。
cols	每列佔多寬，規則同上。
src	當前框架顯示的網頁地址
name	當前框架的名字

23. 表單標籤，若是瀏覽器端要將數據發送給服務器，使用表單標籤封裝全部的數據發送給服務器

<form action="https://www.baidu.com" method="post"> </form>

action屬性：要提交給服務器的地址URL。 method：提交的方法，取值：get和post。

（1）get和post方法的區別：

	GET方法	POST方法
服務器獲得數據的方式	以請求頭的方式發送數據	以請求體的方式發送數據
地址欄	在地址欄上顯示發送的數據	在地址欄上看不到數據的
大小	限制爲1K的大小	在理論上沒有限制，如文件上傳
安全性	相對比較差	相對比較高

（2）使用表單標籤的注意事項：

A.表單元素數據能提交給服務器端的前提：第一個是必須有action（服務器地址），第二個是要有submit（進行提交的觸發），第三個是須要提交的每一個表單元素數據必須有name屬性，服務器根據name識別表單元素數據，編寫時要給每一個表單元素設置name屬性。

B.提交數據要注意的表單元素：

表單元素提交的數據就是表單元素value屬性，全部的表單默認都有value，只有以下兩個沒有：

單選框，必需要設置value屬性；多選框，必需要設置value屬性。

C. 表單標籤中需注意的屬性：

placeholder="請輸入用戶名"屬性：會在text或者password類型的標籤中插入提示信息。

style="width:60%"：表單元素中也能夠在樣式中設置寬度。

（3）表單標籤中的元素：

表單項	代碼	屬性	說明
文本框	<input type=」text」/>	name: 文本框的名字 value: 文本框的默認值 readonly: 文本框只讀 disabled: 不可用	用戶能夠輸入單行文本的表單元素
密碼框	<input type="password"/>		輸入的文本不可見
單選框	<input type=」radio」/>	checked：默認選中	同一組單選框名字要相同
複選框	<input type="checkbox"/>	checked：默認選中	同一組複選框名字要相同，在服務器上能夠經過名字獲得一組值
下拉列表	<select> <option>一項</option> </select>	option:表示其中一項 multiple：多選，按ctrl或shift能夠多選 value: 其中一項的值
隱藏表單域	<input type=」hidden」/>		在表單上不可見，能夠將數據提交給服務器。
單行文本域	<input type=」file」/>		上傳文件給服務器
多行文本域	<textarea rows="5" cols="50"></textarea>	rows: 行數 cols: 列數	主體部分是文本的內容
提交按鈕	<input type=」submit」/>	value: 指定按鈕的文本	提交表單
重置按鈕	<input type=」reset」/>		重置表單的數據
普通按鈕	<input type=」button」/> <button>		普通按鈕
圖片按鈕	<input type=」image」/>	src: 指定圖片的地址 x和y，表示點擊圖片的位置	功能與submit同樣，用於提交表單，外觀是一張圖片

3. CSS

1. CSS的概述：

層疊樣式表(英文全稱：Cascading Style Sheets)，也是一遍代碼言語，是專門用於操做html元素進行效果展示的。html控制樣式經過添加標籤逐個控制很是麻煩，然而css不須要添加任何標籤就能夠靈活簡潔的控制樣式。

CSS的功能更增強大，能夠實現HTML中一些標籤不能實現的功能，CSS專門用來進行裝飾，HTML專門用來建立結構，一般咱們會將CSS作成一個單獨的文件存在，下降耦合度。

2. CSS的編寫方式（三種）：

編寫方式	格式	特色
內部方式	<style type="text/css"> a{color: red;} </style>	使用<style></style>標籤括起來，一個網頁內能夠有多個style標籤；type="text/css"，以文本代碼方式存在的css代碼，這個能夠不寫，可是建議寫上，爲了各個瀏覽器兼容性
內嵌方式	<a href="#" style="color: green;">新聞標題2</a><br />	直接將css代碼寫在html標籤裏面，以style屬性方式存在
外部方式（推薦）	特色：css代碼寫在外部的文件中，文件的擴展名.css。實現步驟：在外部建立一個css文件,編寫樣式代碼；再在當前網頁引用外部的css文件。格式：<link rel="stylesheet" type="text/css" href="外部樣式文件路徑"/>。優勢：代碼分離，html代碼與css代碼分離；複用性強。

3. CSS的使用：

在HTML中使用CSS的優先級：使用CSS時，均是按照就近原則使用，哪一個離調用的HTML標籤進就使用哪一個。

CSS的註釋：/*註釋內容*/，CSS中的註釋與java中的多行註釋如出一轍。

CSS的學習方式：分爲2步進行，第一步爲選擇出要進行樣式控制的html元素---css選擇器；第二步爲對html元素進行樣式操做---css樣式（經常使用樣式與高級樣式）。

4. CSS選擇器

(1) 基本選擇器

具體選擇器名

格式

代碼

標籤選擇器

就是根據標籤名稱選擇要操做的html元素

標籤名{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

a{color:red;}

/*操做全部a標籤的字體顏色爲紅色*/

p{color:yellow;}

/*操做全部p標籤的字體顏色爲黃色*/

類選擇器

能夠對html元素進行分類控制樣式，給每種類型定義一個類選擇器，以後html元素經過class=」類型名字」使用

.類型名字{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

.one{

font-size: 30px;

color: green;

/*在類選擇器裏面設置的字體顏色*/

}

ID選擇器

對頁面上指定一個元素操做樣式。html標籤都有一個id屬性，這個id屬性值必須惟一，用於區別同名標籤。

#ID值 {

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

#new5{

color:yellow;

}

基本選擇器總結：ID>類>標籤，仍是使用就近原則來使用選擇器。

(2) 擴展選擇器（複合選擇器）

擴展選擇器就是將多個基本選擇器進行組合以後就是複合選擇器，一個複合選擇器是由多個基本選取組成的。擴展選擇器中包括（並集），（交集），（層級），（屬性），（僞類）選擇器。

做用

格式

代碼

並集選擇器

同時操做多個選擇器擁有同樣的樣式，html元素只要符合其中一個選擇器就能夠應用到樣式。選擇器中以逗號隔開。

選擇器名稱1, 選擇器名稱2…{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

/*同時設置a標籤，p標籤的字體大小爲30px*/

a,p{

font-size: 30px;

}

交集選擇器

選擇的html元素須要同時具備多個選擇器纔會應用到樣式。選擇器之間沒有任何分隔符。

選擇器名稱選擇器名稱{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

/*設置span標籤而且類樣式是oushuA的html元素的字體大小爲30px*/

span.oushuA{

font-size: 30px;

}

層級選擇器

操做指定層級結構的html元素樣式。選擇器名稱之間使用「」空格隔開。

選擇器名稱選擇器名稱……{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

/*操做div裏面span標籤的字體顏色爲藍色樣式*/

div span{

color:blue;

}

屬性選擇器

根據html元素屬性選擇html元素設置樣式。屬性使用"[]"括起來。

選擇器名稱[屬性名=「屬性值」]{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

/*設置input標籤屬性type="text"的html元素背景顏色爲紅色*/

input[type="text"]{

background: red;

}

(3) 僞類選擇器（操做html元素不一樣狀態下樣式效果）

任何html元素都有以下狀態：未訪問過狀態；已訪問過狀態；鼠標懸浮狀態；鼠標按下狀態。

格式

代碼

選擇器名稱:狀態行爲{

樣式屬性1：樣式屬性值1；

樣式屬性2：樣式屬性值2；

……

}

狀態行爲示例格式以下：

a:link {color: yellow}/* 未訪問的連接 */

a:visited {color:blue} /* 已訪問的連接 */

a:hover {color: red}/* 鼠標移動到連接上 */

a:active {color: black} /* 選定的連接 */

/*未訪問狀態：顯示紅色*/

a:link { color:red; }

/*已訪問狀態：顯示灰色*/

a:visited{ color: gray; }

/*鼠標懸浮狀態：顯示藍色*/

a:hover{ color: blue; }

/*激活狀態：顯示綠色*/

a:active{ color: green; }

注意：在 CSS 定義中，a:hover 必須被置於 a:link 和 a:visited 以後，纔是有效的； a:active 必須被置於 a:hover 以後，纔是有效的。

5. 經常使用樣式：

(1) 邊框：

屬性	描述
border	簡寫屬性，用於把針對四個邊的屬性設置在一個聲明。
border-style	用於設置元素全部邊框的樣式，或者單獨地爲各邊設置邊框樣式。
border-width	簡寫屬性，用於爲元素的全部邊框設置寬度，或者單獨地爲各邊邊框設置寬度。
border-color	簡寫屬性，設置元素的全部邊框中可見部分的顏色，或爲 4 個邊分別設置顏色。

注意：必須把單邊屬性放在簡寫屬性以後。由於若是把單邊屬性放在 border-style 以前，簡寫屬性的值就會覆蓋單邊值 none。

style中的經常使用屬性有：solid（實線）， dotted（點線）， dashed（虛線）， double（雙線）。

width通常使用px，color能夠直接使用英語單詞描述。

(2) 背景：

屬性	描述	屬性
background	簡寫屬性，做用是將背景屬性設置在一個聲明中。
background-attachment	背景圖像是否固定或者隨着頁面的其他部分滾動。	默認值是 scroll，會滾動，fixed屬性是不滾動的。
background-color	設置元素的背景顏色。	直接使用英語單詞表示
background-image	把圖像設置爲背景。	需統計url值
background-position	設置背景圖像的起始位置。	10px，center，百分比都可
background-repeat	設置背景圖像的平鋪方式。	repeat-x，repeat-y，no-repeat

(3) 文本

屬性	描述
color	設置文本顏色
direction	設置文本方向。
line-height	設置行高。
letter-spacing	設置字符間距。
text-align	對齊元素中的文本。
text-decoration	向文本添加修飾。
text-indent	縮進元素中文本的首行。
text-shadow	設置文本陰影。CSS2 包含該屬性，可是 CSS2.1 沒有保留該屬性。
text-transform	控制元素中的字母。

(4) 字體

屬性	描述
font	簡寫屬性。做用是把全部針對字體的屬性設置在一個聲明中。
font-family	設置字體系列。
font-size	設置字體的尺寸。
font-style	設置字體風格。
font-variant	以小型大寫字體或者正常字體顯示文本。
font-weight	設置字體的粗細。

(5) 列表

屬性	描述
list-style	簡寫屬性。用於把全部用於列表的屬性設置於一個聲明中。
list-style-image	將圖象設置爲列表項標誌。
list-style-position	設置列表中列表項標誌的位置。
list-style-type	設置列表項標誌的類型。

6. 高級樣式：

(1) 浮動屬性：

設置浮動屬性

清除浮動屬性

Div {

/*設置左浮動屬性*/

float: left;

}

div {

/*清除左側浮動*/

clear: left;

}

left：左浮動；right：右浮動；none：沒有，默認。

left：清除左浮動；right：清除右浮動；both：左右浮動都清除；

當將一個或幾個div設置成浮動後，再在下方取消浮動，再設置大量文字，會發現文字會環繞上面的div，造成文字環繞的效果。

(2) 盒子模型：

介紹：css認爲html的標籤每一個標籤都是盒子，標籤的嵌套，css認爲就是盒子嵌套。因此css認爲標籤之間關係能夠使用盒子模型來解決。

做用：盒子模型就是用於解決html標籤與標籤裏面文本距離和標籤與直接相鄰標籤距離的。

內邊距：用於設置標籤與標籤裏面內容的距離，內邊距會改變當前標籤的大小。

外邊距：用於設置標籤與直接相鄰標籤的距離。

外邊距四邊	屬性名	內邊距四邊	屬性名
margin-top	頂部外邊距	padding-left	左內邊距
margin-bottom	底部外邊距	padding-right	右內邊距
margin-left	左邊外邊距	padding-top	頂部內邊距
margin-right	右邊外邊距	padding-bottom	底部內邊距

div1{
         background-color: green;
         color: white;
         padding: 15px;/*設置上、右、下、左內邊距各爲15px*/
         margin: 10px;/*設置上、右、下、左外邊距各爲10px*/
}

4. JavaScript基礎

1. JavaScript基本概述

(1) JavaScript和Java的不一樣

	Java	JavaScript
出品公司	Sun	網景
面向對象	徹底面向對象（封裝、繼承、多態）	基於對象，不徹底面向對象
運行方式	編譯型，生成中間文件，字節碼，運行字節碼	解釋型語言，不會生成中間文件，解釋一行就運行一行。
數據類型	強類型語言，數據類型必須同樣 int num=」abc」; 錯誤	弱類型語言，不一樣的數據類型之間能夠賦值 var num=5; var num=」abc」; 正確

(2) JavaScript三大組成部分：

ECMA Script：一種腳本語言規範，構成了JS的核心語法基礎。

BOM：Browser Object Model 瀏覽器對象模型，用來操做瀏覽器上的各類對象。

DOM：Document Object Model 文檔對象模型，用來操做網頁中的各類元素。

(3) JavaScript的引入方式：

內部方式：寫在HTML的內部，全部的JS代碼要寫在script標籤中。建議寫在html的末尾。

內嵌方式：寫在html標籤的屬性裏面寫js代碼

外部方式：寫在HTML的外部，以JS文件的方式存在。經過script標籤導入，之後比較經常使用。同上。

2. JavaScript中的數據類型和函數：

(1) 數據類型：

數據類型	關鍵字	typeof操做符
數值類型	number (包含整數和小數)	做用：判斷一個變量的數據類型；寫法：typeof(變量名) 或 typeof 變量名；返回值：這個變量的數據類型的字符串形式； null與undefined的區別：null是一個值爲空的對類型，undefined是一個未定義的類型。
字符串類型	string(包含了字符和字符串)
布爾類型	boolean (true/false)
對象類型	object 表明一個對象
未定義類型	undefined 變量沒有初始化

(2) 全局函數：

parseInt()：將字符串類型轉成整形；

parseFloat()：將字符串類型轉成浮動型；

3. JavaScript中的流程控制語句：

(1) JS中的調試（JS是在瀏覽器中進行調試），調試步驟以下：

a.打開瀏覽器，打開開發者工具（F12）,任何瀏覽器都有開發者工具

b.開發者工具中點擊「source」並點擊你要調試的頁面

c.單擊代碼左側邊框位置設置斷點，刷新網頁（從新運行網頁），就會程序運行到斷點位置

d.逐行調試，觀察變量運行的結果，觀察發現c變量是undefined未定義，因此結果錯誤了

e.若是想觀察某個表達式的值，能夠在右側watch裏面點擊「+」複製表達式到裏面，觀察結果

f.調試完成，點擊跳過斷點

(2) JS中的判斷（JS中的判斷能夠不爲boolean類型）：

數據類型	爲真	爲假	數據類型	爲真	爲假
number	非0	0	undefined		爲假
string	非空字符串	空字符串	object	非null	null

(3) JS中使用switch函數時，case後面能夠寫常量，也能夠寫變量，還能夠寫表達式，可是在case後面使用表達式時，前提switch後面要寫成switch(true)。

(4) Java中的while，do-while，for，加強for在JS中都能使用，但加強for使用變化以下：

for( var 數組索引或對象的屬性名 in 數組或對象){ /*循環體*/ }

JS中訪問對象的屬性名有2中方式：js對象.屬性和js對象["屬性名"]。

4. JavaScript中的函數：

(1) 函數的種類：

命名式函數：function 函數名(造成) { //函數體代碼 }
匿名式函數：var 變量 = function(形參){ //函數體代碼 };

調用函數時，直接調用函數名或者變量名傳入實參便可。例：函數名/變量函數名(實參);

(2) 注意：

函數不須要定義返回值,有返回值在函數體內直接使用return返回便可.

js函數中不存在方法重載,在js裏面同名方法都是下面覆蓋上面的

js調用函數傳遞實參的原理是會將實參數據封裝到一個arguments數組裏,再由數組按照次序給每一個形參賦值

5. BOM對象（經常使用windos，location，history這三個對象）：

(1) Windos（瀏覽器窗口）對象中的經常使用方法：

方法名	做用
alert()	彈出一個信息框，只有一個確認按鈕。
string prompt(「提示信息」, 「默認值」)	彈出一個輸入框，返回用戶輸入的字符串。若是點取消，獲得一個null。
boolean confirm("提示信息")	彈出一個信息框，有確認和取消2個按鈕，點確認返回true，點取消false
eval("")	直接執行括號中字符串中的JS代碼
parseInt()	把字符串轉成整數，若是是小數會取整
parseFloat()	把字符串轉成小數，若是不能轉換。返回NaN=Not a Number
isNaN()	判斷是否非數字，非數字返回true，數字返回false
window.setTimeout(「函數名」, 時間)	函數名：要調用的函數時間：以毫秒爲單位做用：過指定的時間之後，調用1次指定的函數
var 計時器= window.setInterval(「函數名」, 時間)	函數名：要調用的函數時間：以毫秒爲單位做用：每隔指定的毫秒數調用1次函數，不停的調用
clearInterval(計時器)	清除Interval的計時器
clearTimeout(計時器)	清除Timeout的計時器

(2) location（地址欄對象）中的方法

location.href：能夠獲得瀏覽器訪問的地址（右邊）或者給瀏覽器地址賦新的值，至關於頁面的跳轉（左邊）

reload()方法：從新加載當前的頁面，至關於刷新當前的網頁。

(3) history（歷史記錄對象）中的方法

方法	做用
forward()	至關於瀏覽器上的前進按鈕 ->
back()	至關於瀏覽器上後退按鈕 <-
go(正整數/負整數)	正數至關於前進，負數至關於後退。如：-2，至關於後退2個頁面

6. DOM對象

(1) DOM中的經常使用方法以下：

方法名	做用
document.getElementById("id") 方法	經過元素的id獲得元素對象
innerHTML屬性	獲取/設置元素的HTML內容
innerText 屬性	獲取/設置元素的純文本內容

(2) DOM中還經常使用Date對象，Date date = new Date(); 能夠獲取當前的系統時間。

getFullYear()：獲取年份； getMonth()：獲取月份(0-11)； getDate()：獲得日期；

getHours():獲得小時(0-23)； getMinutes()：獲得分(0-59); getSeconds()：獲得秒； getMilliseconds()：獲得毫秒； getTime()：獲得1970-1-1到如今之間的毫秒數；

toLocaleString()：將日期轉成當地格式的日期； getDay()：獲得一週中的第幾天，0-6，0表示週日，1週一；

5. JavaScript提升

1. JS中事件的處理

事件名	做用	事件名	做用
onclick	鼠標單擊事件	onmouseover	鼠標移上
ondblclick	鼠標雙擊事件	onmouseout	鼠標移出
onchange	改變事件	onmouseup	鼠標鬆開
onload	在頁面加載完畢激活的事件	onmousedown	鼠標按下
onfocus	獲得焦點	onkeyup	鍵盤按鍵鬆開
onblur	失去焦點	onkeydown	鍵盤按鍵按下
onsubmit	表單提交數據以前執行的事件

2. JS中的正則表達式

(1) 正則表達式的基本語法：

建立正則表達式的語法：var reg = /正則表達式/匹配模式;

正則表達式的匹配模式：i,忽略大小寫匹配（需掌握）； g,全局匹配(瞭解)； m,多行匹配（沒用）。

正則表達式中的方法：正則表達式對象.test(「字符串」)，若是匹配則返回true，若是不匹配則返回false。

示例代碼：

reg=/abc/i; //定義一個正則表達式忽略大小寫匹配含有abc

var str ="ABC123"; //建立目標字符串str

if(reg.test(str)){ //驗證字符串str是否含有abc或者ABC

document.write("str含有忽略大小寫abc<br/>");

}else{

document.write("str不含有忽略大小寫abc<br/>");

}

(2) 正則表達式的經常使用符號：

符號	做用	符號	做用2	經常使用正則表達式：
{n}	匹配n個	\d	數字
{n,}	匹配大於等於n	\D	非數字
{n,m}	匹配在n和m之間，包頭包尾	\w	單詞字符：大小寫字母，數字，下劃線[0-9a-zA-Z_]
+	1~n次	\W	非單詞字符（上面\w取反）
*	0~n次	\s	空白字符：空格，製表符Tab，換行，分頁符
?	0~1次	\S	非空白
^	匹配開頭	.	任意字符，注：若是要使用點號，轉義\.
$	匹配結尾

3. JS中的數字對象Array：

(1) 數組的概述和建立方式：

//1. 建立一個長度爲0的數組 var arr = new Array();

//2. 建立指定長度的數組 var arr = new Array(5);

//3. 指定數組中的每一個元素建立 var arr = new Array(5,10,20,12);

//4. 使用中括號建立數組 var arr = [3,10,2,6,9];

由於JS是一種弱類型的語言，因此在JS的數組中，每一個元素的類型均可以不一樣；

在JS中，數組的長度能夠變化，若是將長度設置爲0，至關於清空數組

(2) 數組中的經常使用方法以下：

concat()：用於數組的拼接，將多個數組或元素拼接成一個數組 array=array1.concat(array2);

reverse()：將數組的元素逆轉

join(separator)：將一個數組按指定的分隔符，拼成一個字符串。與split(分隔符)的功能相反。

sort()：用於數組的排序,在JS的數組中，排序比的是ASCII碼值，若是想按照其餘標準進行排序，就須要提供比較函數，該函數要比較兩個值，而後返回一個用於說明這兩個值的相對順序的數字。比較函數應該具備兩個參數 a 和 b，其返回值以下：

若 a 小於 b，在排序後的數組中 a 應該出如今 b 以前，則返回一個小於 0 的值。

若 a 等於 b，則返回 0。

若 a 大於 b，則返回一個大於 0 的值。

例：//若是n>m，則返回正整數，若是n<m返回負整數，若是n==m則返回0，此時會將arr數組安裝從小到大排序

arr.sort(function (n, m) {

return n-m;

});

4. JS中的DOM編程：

(1) DOM的概念：Document Object Model，文檔對象模型。就是瀏覽器加載數據會在內存中構建DOM樹；瀏覽器會從上往下一次性加載數據，每遇到一個標籤就會在內存中建立一個節點對象，直到全部的標籤對象建立完成。（若是遇到其餘因素，如網絡問題等致使圖片等內容加載不出來，也會先將全部的節點封裝到內存的document對象中）

(2) 經過document對象獲取Dom對象的方法：

獲取元素的方法	做用
document.getElementById(「id」)	經過id獲得惟一的元素，若是有相同的id，則獲得第1個。
document.getElementsByName(「name」)	經過name屬性獲得一組元素，返回一個數組
document.getElementsByTagName (「input」)	經過標籤名，獲得一組元素
document.getElementsByClassName(className)	根據標籤類樣式屬性名字獲取一組節點對象

(3) DOM修改CSS樣式：

方法一：直接修改每個樣式；例：pNode.style.fontSize="30px";

方法二：直接使用類樣式的名字；例：pNode.className="first";//與在標籤上加class="first"效果同樣

(4) DOM修改標籤元素操做的方法：

元素操做的方法	做用
document.createElement("標籤名")	建立一個元素 input
element.setAttribute("屬性名", "屬性值")	給元素添加屬性 type=」text」
document.createTextNode("文本節點")	建立文本節點如：<h1>文本</h1>
parent.appendChild(child)	將child元素追加成parent的最後一個子元素
parent.insertBefore(new,old)	將new元素插入到old元素的前面
parent.removeChild(child)	將parent中的子元素child刪除

(5) event.keyCode：獲取當前鍵盤中當前當前按下鍵的鍵碼值。

6.JQuery基礎

1. JQuery框架概述：

使用簡單，容易上手，體積小，佔用資源少；jquery的宗旨是write less do more。jquery插件網：https://www.jq22.com/。

2. JS和JQuery的區別和轉換：

區別：JS 的頁面加載完畢：window.onload = function(){ ... ... }

JQuery 的頁面加載完畢：$(document).ready(function(){ ... ... })，通常簡寫： $( function(){ ... ... } )

轉換：JS對象轉換成 jQuery 對象，語法：$(js 對象)

JQuery對象轉換成js對象，語法：jQuery 對象[索引]或 jQuery 對象.get(索引)；JQuery本質上是數組對象

3. JQuery中的選擇器：

(1) 基本選擇器：

標籤選擇器（元素選擇器）：$("html標籤名"); 例：$("div").css("background","red");

id選擇器：$("#id的屬性值"); 例：$("#one").css("background","red");

類選擇器：$(".class的屬性值"); 例：$(".mini").css("background","red");

(2) 層級選擇器：

得到 A 元素內部的全部的 B 元素：$("A B")；子，孫例：$("body div").css("background","red");

得到 A 元素下面的全部 B 子元素：$("A > B")；只是子例：$("body>div").css("background","red");

得到 A 元素同級，下一個 B 元素：$("A + B")；例：$("#one+div").css("background","red");

得到 A 元素同級，全部後面 B 元素：$("A ~ B")；例：$("#two~div").css("background","red");

(3) 屬性選擇器：

1) 得到有屬性名的元素：$("A[屬性名]")

含有屬性 title 的 div 元素背景色爲紅色：$("div[title]").css("backgroundColor","red");

2) 得到屬性名等於值元素：$("A[屬性名=值]")

屬性 title 值等於 test 的 div 元素背景色爲紅色：$("div[title='test']").css("backgroundColor","red");

3) 得到屬性名不等於值元素：$("A[屬性名!=值]")

屬性 title 值不等於 test 的 div 元素(沒有 title 屬性的也將被選中)背景色爲紅色：

$("div[title!='test']").css("backgroundColor","red");

4) 得到屬性名以值開頭元素：$("A[屬性名^=值]")

屬性 title 值以 te 開始的 div 元素背景色爲紅色：

$("div[title^='te']").css("backgroundColor","red");

5) 得到屬性名以值結尾元素：$("A[屬性名$=值]")

屬性 title 值以 est 結束的 div 元素背景色爲紅色：

$("div[title$='est']").css("backgroundColor","red");

6) 得到屬性名含有值元素：$("A[屬性名*=值]")

屬性 title 值含有 es 的 div 元素背景色爲紅色：

$("div[title*='es']").css("backgroundColor","red");

7) 複合屬性選擇器，多個屬性同時過濾：$("A[屬性名=值][屬性名=值][屬性名=值]")

選取有屬性 id 的 div 元素，而後在結果中選取屬性 title 值含有「es」的 div 元素背景色爲紅色：

$("div[id][title*='es']").css("backgroundColor","red");

(4) 基本過濾選擇器

1) 得到選擇元素中的第一個元素： :first

改變第一個 div 元素的背景色爲紅色： $("div:first").css("background","red");

2) 得到選擇的元素中的最後一個元素： :last

3) 不包括指定內容的元素例如： :not(selecter)

改變 class 不爲 one 的全部 div 元素的背景色爲紅色：$("div:not(.one)").css("background","red");

4) 偶數，從 0 開始計數， :even

改變索引值爲偶數的 div 元素的背景色爲紅色：$("div:even").css("background","red");

5) 奇數，從 0 開始計數， :odd

6) 大於第 n 個，不含第 index 個： :gt(index)

改變索引值爲大於 3 的 div 元素的背景色爲紅色： $("div:gt(3)").css("background","red");

7) 小於第 n 個，不含第 index 個： :lt(index) 等於第n個：div:eq(3)

8) 得到標題全部標題元素（<h1> /<h2> ....） :header

改變全部的標題元素的背景色爲紅色： $(":header").css("background","red");

(5) 表單屬性過濾選擇器

可用： :enabled 例：$("input[type='text']:enabled").val("黑馬程序員");

不可用： :disabled 例：$("input[type='text']:disabled").val("黑馬程序員");

選中（單選 radio ，多選 checkbox）:checked 例：var items = $("input[name='items']:checked");

選擇（下列列表 <select>中的<option>）： :selected 例：$("select option:selected").text()

4. JQuery中的方法：

(1) DOM操做方法：

html() 至關於 innerHTML； text() 至關於 innerText； val() 至關於 value； ()中沒有值爲獲取，有值爲賦值。

(2) HTML屬性操做方法：

attr(name),獲取屬性name的值

prop(name),獲取屬性name的值

attr與prop的區別：

相同點:都是獲取設置屬性的方法

不一樣點:

attr設置通常屬性均可以

prop用於設置選中狀態的屬性

prop專門用於設置屬性值爲boolean類型的屬性

attr(name,value),設置屬性name的值爲value

prop(name,value),設置屬性name的值爲value

removeAttr(name);刪除指定的name屬性

removeProp(name),刪除指定的name屬性

(3) HTML的class屬性操做(至關於對 className 的操做) ：

addClass(類樣式名) 添加類樣式

removeClass(類樣式名) 刪除類樣式

toggleClass(類樣式名) 若是存在類樣式名就刪除，若是不存在樣式名就添加。切換類樣式

(4) html的樣式的操做 css()：

獲取：$("#one").css("background-color") 和 $("#one").css("backgroundColor") ：2種方式都可。

設置：$("#one").css("background-color","green");和$("#one").css("backgroundColor","green"); ：2種方式都可

(5) html的內部插入：

append(): 至關於 appendChild()，添加元素爲當前元素的最後一個子元素。與當前元素是父子關係。

prepend()：添加元素爲當前元素的第一個子元素。與當前元素是父子關係

before()：在當前元素的前面插入一個元素，與當前的元素是兄弟關係。

after(): 在當前元素的後面插入一個元素，與當前的元素是兄弟關係。

例：$("#city").append($("#fk"));

補充：$("#fk").clone() 克隆,複製一個如出一轍的對象；$("#tj").after($("#fk").clone());將複製的fk插入tj後面

(6) html元素的刪除操做：

remove(): 刪除自己例：$("#bj").remove();

empty()：刪除全部的子節點，自己仍是存在例：$("#city").empty();

5. JQuery的動畫效果：

方法	做用	方法	做用	方法	做用
show(speed ,fn)	顯示	slideDown(speed,fn)	下滑顯示	fadeIn(speed ,fn)	淡入顯示
hide(speed ,fn)	隱藏	slideUp(speed ,fn)	上滑隱藏	fadeOut(speed ,fn)	淡出隱藏
toggle(speed ,fn)	切換	slideToggle(speed ,fn)	切換	fadeToggle(speed ,fn)	切換

Speed：設置速度，單位毫秒，能夠指定常量：fast，normal，slow； fn:回調函數，動畫執行後運行的函數。

6. JQuery的循環遍歷：

(1) 原始方式：var $lis = $("#city li"); 再使用for循環遍歷$lis；

(2) jquery對象each方法方式(推薦)：jq對象.each(function(index,element){ //代碼 }); element：js對象

例：$("#city li").each(function (i,item) { alert($(item).text()); });

(3) jquery全局each方法方式：$.each(jq對象,function(index,element){ //代碼 });

7. HTTP和Tomcat

1. HTTP協議基本概述：

Hyper Text Transfer Protocol 超文本傳輸協議；用於規定瀏覽器與服務器傳輸數據的格式與內容。由於瀏覽器與服務器交互的時候都遵循http協議因此瀏覽器能夠認識服務器響應過來的數據，服務器端也認識客戶端瀏覽器的請求數據，最後得以交互識別。

2. 查看http協議數據方法：

(1) 瀏覽器開發者工具查看：能夠經過瀏覽器「開發者工具」——「network網絡」——提交請求——觀察network下面請求url並點擊——觀察network的右邊就是http協議數據（請求與響應）；

(2) 專業Fiddler抓包工具軟件查看：選擇抓取到的數據->點擊Inspection->點擊Raw；

3. HTTP基礎講述：

(1) 網絡的三要素：協議、IP地址、端口號； http協議默認端口號爲80；

(2) HTTP請求組成：

請求消息行：請求方法 + url？get提交數據 + http協議版本

請求消息頭：key：value格式

請求正文：用於傳送post方法請求數據

(3) HTTP響應組成：

響應消息行：HTTP協議版本 + HTTP通訊狀態碼 + 狀態碼翻譯（HTTP/1.1 200 OK）

響應消息頭：key：value格式

響應正文：傳輸用戶看的網頁數據

4. URL組成：

Uniform Resource Locator 統一資源定位符（就是定位哪臺服務器上具體資源）

http://www.itcast.cn:8080/news/index.jsp?boardid=5&id=24618&page=1

組成部分	功能
http	訪問的協議
www.itcast.cn	服務器域名或IP地址。http://119.75.216.20/ 訪問百度
8080	端口號，默認瀏覽器http協議端口號是：80,https默認端口443
news	服務器上的一個項目訪問地址(資源目錄)
index.jsp	web資源，能夠是HTML、JSP、圖片
?	分隔符，前面是URL訪問地址，後面是參數
boardid=5&id=24618&page=1	客戶端提交參數數據，多個參數之間使用&分隔

本地的hosts文件或者運營商的DNS能夠對域名進行解析，將域名轉爲對應的IP地址。

5. Web服務器基本概述：

(1) 經常使用的Web服務器：Weblogic，Oracle公司的一款服務器；WebSphere，IBM公司；Tomcat：經常使用服務器；

(2) 服務器有能力將本地的web資源提供給外界用戶使用瀏覽器去訪問。

當瀏覽器請求靜態資源，服務器會使用io流讀取本地靜態資源文件響應給瀏覽器；

當瀏覽器請求動態資源，服務器會調用java程序，java程序獲取動態資源數據響應給瀏覽器；

6. Tomcat使用( http://tomcat.apache.org/ ) ：

(1) Tomcat目錄結構：

目錄名	做用
bin	命令目錄，啓動和關閉的可執行文件；啓動：startup.bat；關閉：shutdown.bat；
conf	config配置文件夾，配置文件在這個目錄下，如：server.xml,修改端口號等信息
logs	服務器啓動或出現異常的一些日誌記錄文件
webapps	咱們項目部署和發佈資源的文件夾如：/webapps/hello/1.html 訪問：http://localhost:8080/hello/1.html 注意：全部發布的資源文件必須放在資源目錄裏面若是放到指定的資源目錄，訪問的時候就要「資源目錄/資源文件」，若是放到了ROOT目錄下面，能夠直接訪問「/資源文件」。ROOT是資源根目錄，放在這裏的資源能夠直接訪問。

(2) Tomcat的啓動常見的問題：

啓動界面一閃而過現象：需配置好JAVA_HOME(JVM環境遍歷)或者CATALINA_HOME(服務器環境遍歷)；

端口被佔用問題：能夠啓動DOS，輸入netstat -aov目錄，找到8080端口號的進程，在進行清除；

或者將服務器的端口號進行修改。

7. 使用IDEA開發Web應用程序：

(1) idea使用初始化設置工做：、

統一idea碼錶：File->Setting->File Encodings->修改碼錶爲UTF-8

找到idea安裝目錄，打開idea64.exe.vmoptions文件，在最後一行添加：-Dfile.encoding=UTF-8

點擊edit config進入部署項目設置，在其中的VM options中添加：-Dfile.encoding=UTF-8

(2) idea綁定Tomcat

點擊edit config進入部署項目設置，向下拖拽找到Tomcat Server中的Local選項點擊，點擊右上角config配置tomcat的路徑，點擊OK配置完成。

(3) 修改項目部署位置：

當咱們運行項目時，會發現項目部署到C:\Users\用戶\.IntelliJIdea2017.3\system目錄下去了，此時需更改位置：

鼠標右擊模塊名->點擊Open Modulel Setting->點擊Artifacts->選中項目->右上角修改成Archive->點擊OK；
點擊edit config進入部署項目設置->選中當前Tomcat->點擊Deployment->選中當前項目->修改右方/；

(原來只有/.修改成/項目名字，這樣會將整個項目加載到服務器webapps中，若是不改會將當前項目下的全部文件部署到ROOT裏面)。

8. Web項目結構

8. Servlet

1. Servlet概述：

全稱server applet，是sun公司提供開發動態資源的技術。Servlet類技術，與普通java類是有區別的，servlet具備處理請求與響應的能力。普通java類必須有程序的入口main方法才能夠運行，而servlet類是web服務器調用運行的，用戶訪問的服務器，請求交給服務器，服務器調用servlet程序處理，servlet處理響應完成交給服務器，服務器交給瀏覽器。

在javaee中，存在Servlet接口和ServletConfig接口，做爲Servlet功能最原始的接口，而後GenericServlet抽象類實現了這2個接口，HttpServlet抽象類又繼承了GenericServlet抽象類。因此咱們使用Servlet功能時能夠建立類繼承GenericServlet抽象類，能夠能夠繼承HttpServlet抽象類；咱們通常是繼承Http抽象類(子類的功能更多)。

2. 使用Servlet功能的三種方式：

(1) 手動開發Servlet程序和配置web.xml方式（配置web.xml的2中方式）：

方式一：右擊模塊名->點擊Open Module Settings->點擊左側facets->點擊右側+生成web.xml文件

方式二：點擊File->New->Module->選中Java Enterprise->選中JavaEE5和WebApplication->點擊建立會自動生成

在web.xml配置文件中有<servlet>標籤和<servlet-mapping>標籤，需建立完成。

(2) 建立一個類，該類繼承自HttpServlet抽象類，在該類名上方手動加上註解：

@WebServlet(name = "Hello2Servlet", urlPatterns = "/Hello2")； name爲類名， urlPatterns爲url值；

此時經過urlPatterns就能夠訪問該Servlet了。

(3) 使用IDEA的模板自動建立Servlet並生成註解：

鼠標右鍵->new->Servlet就能夠自動生成Servlet，並在類上方自動生成以本類名爲url的註解。

3. Servlet的運行原理：

服務器實例化了Servlet對象；並調用了service方法處理請求(HttpServlet抽象類在service內部對請求方式進行了分類，不一樣的請求調用不一樣的方法進行處理)；將客戶端的全部的請求的數據封裝在request對象中；全部要響應給客戶端的數據封裝在response對象中。

4. Servlet的生命週期：

(1) servlet對象的從建立到銷燬的過程，概念相似於對象做用域。Servlet中的主要方法以下：

方法	做用	運行次數
void init(ServletConfig config)	初始化的方法	1次
void service(ServletRequest req, ServletResponse res)	服務的方法	每次請求都會執行
void destroy()	銷燬的方法，Web容器關閉或重啓的時候執行	1次

(2) Servlet中每一個方法的具體生命週期：

a. 默認狀況以下：

當第一個用戶訪問該Servlet時服務器會建立這個Servlet對象，此時會調用init方法，而後會調用這次訪問的service方法，之後每次訪問都會調用一次service方法，當服務器關閉或者重啓時會調用destroy方法。

b. 當在web.xml配置文件中對應的<Servlet>標籤中加上<load-on-startup>1</load-on-startup>子標籤時以下：

該標籤中間的取值是正整數（大於0），值越小就越先加載。若是配置成負數或0，則與不寫這個參數是同樣的。當該值是一個小於等於0或者沒有指定時，則指示容器在該servlet第一次被訪問時才加載建立對象。

當服務器啓動時就會建立Servlet這個對象，並在此時調用了init方法，之後每次有瀏覽器訪問這個Servlet時都會調用service方法，當服務器關閉或者重啓時會調用destroy方法，此時這個Servlet也會被GC回收。

5. Servlet中的配置文件對象ServletConfig：

此對象能夠讀取web.xml中對當前servlet配置的參數數據。web.xml中的參數形態以下所示：

<init-param>

<param-name>param1</param-name> <param-value>123456</param-value>

</init-param>

ServletConfig對象中的方法以下：

String getInitParamter(String name)：獲得web.xml中有關Servlet的配置參數，經過參數名獲得參數值

getInitParameterNames()：會獲得web.xml中有關這個Servlet的全部的配置參數的名字，返回一個枚舉類

6. Servlet映射路徑配置：

(1) 能夠配置多個url-pattern：

<servlet-mapping>

<servlet-name>Demo1Servlet</servlet-name>

<url-pattern>/demo1</url-pattern>

<url-pattern>/hello</url-pattern>

<url-pattern>/hello.html</url-pattern>

</servlet-mapping>

(2) 能夠配置多個servlet-mapping：

同一個servlet能夠配置多個訪問映射servlet-mapping標籤配置；

<servlet-name>LoginServlet</servlet-name>

<servlet-class>com.itheima.servlet.LoginServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>LoginServlet</servlet-name>

<url-pattern>/login</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>LoginServlet</servlet-name>

<url-pattern>/hello</url-pattern>

</servlet-mapping>

(3) Servlet映射路徑匹配方式（精確匹配和模糊匹配）：

精確匹配：要配置的url與用戶訪問的url要如出一轍才能夠訪問到對應的servlet。
模糊匹配：模糊匹配使用一個通配符「*」號，只有這一個通配符。

前綴匹配，必須以「/」開頭，以「*」結尾（*前面必須有/）

例：/abc/*,只要用戶訪問時/abc/開頭均可以匹配到；

後綴匹配，必須以「*」開頭，以「.」擴展名方式結束使用

例：*.do，只要用戶訪問時以.do結尾均可以匹配到；

注意：/abc/*/abc,既不屬於前綴也不屬於後綴，屬於精確匹配；匹配模式同樣的時候，匹配類似度越高優先級越高；精確匹配優先於模糊匹配；模糊匹配中，前綴匹配優先於後綴匹配。

(4) 缺省路徑：

「/」和「/*」就是缺省路徑，缺省路徑能夠匹配一切資源，該映射路徑已經被全局tomcat/conf/web.xml使用了,其中DefaultServlet配置了缺省路徑。DefaultServlet是用於處理靜態資源響應的。建議開發者不要使用這個配置url-pattern，若是開發人員使用了這個配置，就覆蓋了缺省路徑，就會致使全部的靜態資源沒法訪問了。（訪問路徑時會先訪問這個項目內部的web.xml中的局部路徑，再訪問服務器中的公有路徑）

7. Web開發中的路徑問題：

(1) 相對路徑：url=直接寫資源路徑名字

如： <form class="form-horizontal" action="LoginServlet" method="post">

這個路徑直接寫LoginServlet的意思是:訪問當前資源目錄loginSys下的LoginServlet

(2) 絕對路徑：url=/工程名字/資源路徑名字

如： <form class="form-horizontal" action="/loginSys/LoginServlet " method="post">

這裏路徑中」/」表明的是tomcat/webapps,因此訪問資源要使用資源目錄loginSys

9. Request

1. Request中的方法介紹：

(1) 獲取Request中請求行的方法：

String getMethod()：獲得請求的方法：GET或POST

String getRequestURI()：獲得請求的URI(統一資源標識符)

StringBuffer getRequestURL()：獲得請求的URL(統一資源定位符，能夠直接訪問)，比較長

String getProtocol()：獲得協議和版本

String getQueryString()：獲得查詢字符串，GET的參數使用查詢字符串，？號後面的數據

String getContextPath()：獲得項目的訪問地址

String getRemoteAddr()：獲得客戶端的ip地址（0:0:0:0:0:0:0:1爲ipv6，127.0.0.1爲ipv4）

String getServerName()：獲得服務器的名字

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

String getSchema()：獲得訪問協議

(2) 獲取Request中請求頭的方法：

getHeader(String headName) ：根據指定的請求頭名字獲得對應value

Enumeration<String> getHeaderNames() ：獲得全部的請求頭名字，返回枚舉類型

常見請求頭	描述
referer	獲得上一個請求的訪問地址，若是沒有上一個頁面，返回null
If-Modified-Since	瀏覽器緩存的時間
Cookie	用來保存服務器上的一些文本信息
User-Agent	獲得瀏覽器的類型

(3) 獲取Request中請求體的方法（請求體做用，用於客戶端提交post提交的數據）：

request.getParameter(name); //獲取客戶端指定的表單元素名稱的一個值，返回string

request.getParameterValues(name); //獲取客戶端指定的表單元素名稱的一組值，返回string[]

request.getParameterMap(); //獲取全部表單元素的key-value的Map集合

2. 處理中文請求的亂碼問題：

(1) 處理post提交中文亂碼問題：

Tomcat服務器的解碼方式默認爲「ISO8859-1」，而瀏覽器的提交方式爲「UTF-8」，因此能夠設置服務器的解碼爲「UTF-8」，設置方式爲： request.setCharacterEncoding("utf-8");

(2) 處理get提交中文亂碼問題：

get方式提交時能夠直接在Tomcat的配置文件server.xml中添加：<Connector port="8080" protocol="HTTP/1.1"

connectionTimeout="20000" redirectPort="8443" URIEncoding="utf-8" />

3. 四大域對象之一：Request域對象

(1) 什麼是域對象：用於在不一樣的Servlet之間共享數據的存儲空間；

(2) Request域對象中的方法：

Object getAttribute("鍵")：從請求域中取出一個值

void setAttribute("鍵",Object值)：向請求域中添加1個鍵和Object的值

removeAttribute("名字")：從請求域中刪除一個鍵和值

(3) ServeltContext對象和Request對象的區別：

a.生命週期不同，servletContext是服務器啓動就建立了對象，服務器關閉的時候銷燬，做用域是整個應用程序

b.request對象是一次請求開始的時候建立，一次響應結束的時候就銷燬。做用域是一次請求內。

(4) Request對象獲取當前工程的名字：

代碼：request.getContextPath()==》獲取當前工程名字；

做用：應用於重定向頁面跳轉路徑爲絕對路徑時替代路徑中寫死項目名稱；

優勢：若是工程名字寫死代碼，不利於之後修改工程名字；

10. Response

1. 響應消息行(HTTP/1.1 200 OK)：

響應消息行由協議版本+http狀態碼+狀態碼含義組成;

在http中狀態碼與對應的含義以下所示：

100~199 ：表示成功接收請求，要求客戶端繼續提交下一次請求才能完成整個處理過程；

200~299 ：表示成功接收請求並已完成整個處理過程，經常使用200表示；

300~399 ：爲完成請求，客戶需進一步細化請求。例如，請求的資源已移動一個新地址，經常使用302,307和304；

400~499 ：客戶端的請求有錯誤，經常使用404；

500~599 ：服務端出現錯誤，經常使用500,503；

需重點掌握的狀態碼以下所示：

狀態碼	含義
200	通訊正常
304	通知瀏覽器使用緩存(瀏覽器本地有緩存文件，不請求服務器了)
404	服務器上沒有找到對應的資源。用戶的錯誤，用戶輸錯了url致使的。
405	提交的請求方式服務器上沒有相應的方法處理,好比,用戶提交了post請求,servlet裏面沒有doPost()方法就會報錯.
500	服務器發生錯誤了，錯誤是由開發人員代碼邏輯不徹底致使的。99%是開發人員的錯誤。
302	通知瀏覽器進行頁面跳轉的動做執行

2. 響應消息頭：

(1) 響應消息頭的介紹：

響應頭的數據是響應給瀏覽器，通常咱們不用讀取，可是咱們能夠設置響應頭的數據，讓瀏覽器按照咱們指定的設置進行執行響應的功能。設置響應消息頭的方法以下所示：

response.setHeader(name,value)：響應消息頭是以key-value格式組成，因此設置時也是設置這2個；

(2) 響應消息頭一（Location）：

響應頭location的做用是通知瀏覽器要進行頁面跳轉的目標地址。http狀態碼302的做用是通知瀏覽器進行頁面跳轉的動做執行，因此響應頭location和http狀態碼302配合起來才能夠完成頁面跳轉。代碼以下所示：

response.setHeader("location", "/day37/count"); //設置響應消息頭，跳轉到該頁面

response.setStatus(302); //設置http狀態碼爲302

其實這2句代碼和起來就是執行Response對象的重定向功能，因此咱們若是要跳轉頁面，通常使用重定向，以下：

response.sendRedirect(getServletContext().getContextPath()+"/count");//通常使用域對象獲取工程名

(3) 響應消息頭二（Content-Encoding）：

通常向客戶端瀏覽器輸出大量數據時，爲了提供網絡傳輸數據須要對數據進行壓縮以後在響應給瀏覽器，可是瀏覽器接收的是一個壓縮文件，因此須要服務器設置響應頭content-encoding通知瀏覽器解壓文件後再顯示數據。目前瀏覽器只支持解壓gzip格式的壓縮文件。實現代碼以下所示：

//設置響應頭content-Encoding,通知瀏覽器解壓數據後再顯示

response.setHeader("content-encoding", "gzip");

//GZIPOutputStream 數據壓縮類，這個類只有壓縮功能，沒有輸出功能，因此要藉助response輸出流將數據輸出給瀏覽器

GZIPOutputStream gzipOutputStream = new GZIPOutputStream(response.getOutputStream());

//進行壓縮（須要將傳出的字符數據轉成字節數組）

gzipOutputStream.write(stringBuilder.toString().getBytes());

//gzipOutputStream壓縮好的在內存中，若是想將壓縮好的數據輸出給瀏覽器，必須將內存中數據給到輸出流，以下方法

gzipOutputStream.finish();

//總結，若是服務器端客戶端輸出大量的數據要進行數據壓縮

(4) 響應消息頭三（Content-Type）：

格式：Content-Type: text/html; charset=GB2312 設置響應正文類型，並通知瀏覽器以什麼碼錶解碼數據；

因爲服務器響應數據默認採用iso8859-1碼錶，然而中國大陸瀏覽器默認採用GBK碼錶，因此經過設置響應頭content-type來統一碼錶，解決響應中文數據亂碼問題。

當須要輸出中文時建議執行以下操做：

//修改服務器默認編碼碼錶爲utf-8

response.setCharacterEncoding("utf-8");

//通知瀏覽器以utf-8解碼數據顯示

response.setHeader("content-type", "text/html;charset=utf-8");

//對字符串進行輸出

response.getWriter().write("hello world 傳智");

//思考，字符流輸出中文默認亂碼，字節流輸出默認不亂碼，爲何呢？

//.getBytes()若是無參，默認是GBK編碼，瀏覽器有默認以gbk解碼，因此不亂碼了，使用字節流不安全，由於只有中國瀏覽器默認以GBK解碼。因此，輸出中文，建議字符流，明確設置服務器碼錶與瀏覽器碼錶同樣就安全了。

(5) 響應消息頭四（refresh）：

格式：Refresh: 1;url=http://www.it315.org 描述：1秒之後頁面跳轉到http://www.it315.org

在項目中的實際運用以下：

需求：第一次跳轉到倒計時頁面wait.html，第二次跳轉3秒之後跳轉到index.html

response.setHeader("refresh", "3;url="+getServletContext().getContextPath()+"/index.html");

request.getRequestDispatcher("/wait.html").forward(request, response);

第一句代碼做用爲給響應對象設置一個延遲功能，3秒後會跳轉到index.html界面，第二行代碼做用爲轉發到wait.html

總結：上述爲在後端設置延遲功能（幾秒後跳轉到指定頁面），此功能也能夠在前端使用JS代碼實現；

(6) 響應消息頭五（Content-Disposition）：

通知瀏覽器不要直接顯示數據，以附件形式下載數據。默認瀏覽器查看數據是直接顯示數據，有的資源下載網站須要下載資源數據而不是直接顯示，因此須要設置響應頭content-disposition來通知瀏覽器以附件下載數據。

格式：Content-Disposition: attachment; filename=aaa.zip --下載

attachment,通知瀏覽器不要顯示數據要以附件形式下載 filename=aaa.zip,下載的文件名字

實現代碼以下所示：

//網頁中a標籤設置以下： <a href="down?filename=file.zip">壓縮文件</a><br/>

//後端代碼以下：

// 1) 經過request對象中的方法從連接上獲得文件名

String file = request.getParameter("filename");

// 2) 經過servletcontext對象的方法獲得文件的MIME類型

String type = getServletContext().getMimeType("/download/" + file);

System.out.println(type);

// 3) 設置content-type頭爲MIME類型

response.setHeader("content-type", type);

// 4) 設置content-disposition,以附件方式下載文件filename後是文件名,防止中文亂碼，文件名使用url編碼格式

response.setHeader("content-disposition", "attachment; filename=" + URLEncoder.encode(file, "utf-8"));

// 5) 獲得文件的輸入流

InputStream in = getServletContext().getResourceAsStream("/download/" + file);

// 6) 獲得response的輸出流

OutputStream out = response.getOutputStream();

// 7) 寫出到瀏覽器端

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

while((len=in.read(buf))!=-1) { out.write(buf,0,len); }

in.close(); out.close();

3. 響應正文：

就是服務器輸出數據給用戶看，瀏覽器直接要顯示給用戶，就是服務器輸出數據；

能夠輸出字符數據、字節數據；能夠輸出資源文件數據（資源圖片）；能夠輸出緩存（內存中）圖片（資源沒有對應的物理資源）--驗證碼。

11. Request和Response之間的區別

1. 頁面跳轉的區別：

(1) Request中的頁面跳轉（轉發）：

轉發的方法爲：request.getRequestDispatcher("/轉發的地址").forward(request, response);
因爲用戶只發送了一次請求，因此在轉發過程當中，url保持不變；
由於轉發動做發生在服務器內部，因此只能跳轉到當前項目內的資源，沒法訪問外部資源；
頁面跳轉前Servlet和頁面跳轉後的資源共用一個Request和Response(一次請求一個Request和Response);
Request是服務器處理請求時建立，服務器響應結束後銷燬(無論中間轉發了多少次)；

(2) Response中的頁面跳轉（重定向）：

a. 重定向的方法爲：response.sendRedirect(request.getContextPath() + "/two");

b. 用戶發出2次請求，因此url改變了，一個url對應一次請求；

c. 在重定向中，頁面跳轉這個動做是瀏覽器發起的，因此能夠跳轉到任何地方的資源；

d. 頁面跳轉後2個資源不共享Request和Response，一次請求對應一個Request和Response；

e. 因爲重定向瀏覽器發出了2次請求，因此跳轉速度沒有請求轉發快；

(3) 轉發和重定向的區別：

區別	轉發forward	重定向sendRedirect
根目錄	當前工程目錄內	webapps這一級
地址欄	不會發生變化	會，顯示第2個
跳轉者	由服務器跳轉	瀏覽器跳轉
請求域	Request對象數據不會丟失	會丟失，不是同一次請求
代碼執行	轉發或重定向後續的代碼的後續代碼都會執行

2. 解決中文亂碼的區別：

通常狀況下，服務器的默認編碼和解碼方式均爲」ISO8859-1」，而瀏覽器的提交或者解碼方式爲」UTF-8」，此時若是瀏覽器和服務器之間傳輸中文的話就會產生亂碼問題，因此咱們在編寫代碼的過程當中需解決該問題，解決方案以下：

第一步：進入服務器的配置文件server.xml文件中，修改服務器的編碼方式爲UTF-8： URIEncoding=」utf-8」;

第二步：設置request請求對象和response響應對象的碼錶爲utf-8：

request.setCharacterEncoding(「utf-8」); response.setCharacterEncoding(「utf-8」);

第三步：通知瀏覽器以utf-8的格式解碼：

response.setHeader(「content-type」, 「text/html;charset=utf-8」);

12. ServletContext

1. ServletContext概述：

ServletContext官方叫servlet上下文。服務器會爲每個工程建立一個對象，這個對象就是ServletContext對象。這個對象全局惟一，並且工程內部的全部servlet都共享這個對象。因此叫全局應用程序共享對象。

在Servlet對象中，之間執行getServletContext方法就能夠得到ServletContext對象，以下代碼所示：

ServletContext servletContext = getServletContext();

2. ServletContext做用一（ServletContext是一個域對象）：

域對象是服務器在內存上建立的存儲空間，用於在不一樣動態資源（servlet）之間傳遞與共享數據。

凡是域對象，都有以下三個方法：

setAttribute(name,value); name是String類型，value是Object類型；往域對象裏面添加數據 getAttribute(name); 根據指定的key讀取域對象裏面的數據

removeAttribute(name); 根據指定的key從域對象裏面刪除數據

servletContext存儲數據特色，

全局共享，裏面的數據全部動態資源均可以寫入和獲取；

服務器啓動的時候建立，服務器關閉的時候銷燬，由於這是全局應用程序對象，全局共享對象。

3. ServletContext做用二（能夠讀取全局配置參數）：

在web.xml中配置全局參數以下代碼所示：

<context-param>

<param-name>param1</param-name>

<param-value>value1</param-value>

</context-param>

servletContext讀取全局參數核心方法以下所示：

getServletContext().getInitParameter(name); //根據指定的參數名獲取參數值

getServletContext().getInitParameterNames(); //獲取全部參數名稱列表

4. ServletContext做用三（能夠搜索當前工程目錄下面的資源文件）：

ServletContext搜索當前工程目錄下的資源的主要方法以下：

getServletContext().getRealPath(path)：根據相對路徑獲取服務器上資源的絕對路徑

getServletContext().getResourceAsStream(path)：根據相對路徑獲取服務器上資源的輸入字節流

示例代碼以下：

String realPath = getServletContext().getRealPath("img/2.jpg"); 根據相對路徑獲取絕對路徑

InputStream fileInputStream = getServletContext().getResourceAsStream("img/2.jpg"); 獲取資源文件輸入流

5. ServletContext做用四（能夠獲取當前工程名字）：

核心方法以下：

getServletContext().getContextPath()；

13. JavaEE項目中的架構

1. 三層架構：

在項目開發中，爲了進行明確分工，將整個項目分紅了三層，分別是表示層，業務邏輯層和數據訪問層，具體以下：

表示層：是一個用戶交互的層面，主要是執行Servlet的功能，用來獲取用戶的請求(request)和處理用戶的響應(response)

業務邏輯層：service層，主要用來處理各類業務（將表示層的數據接收，進行業務處理，若是須要服務數據庫，就將須要處理的數據傳入下一層）

數據訪問層：dao層，用於操做數據庫的層面，主要進行編寫sql語句，和執行sql語句並返回結果；

dao（d：data數據 a：ask 訪問 o：object 對象）：數據訪問對象。

2. MVC+三層架構：

M：model，模型，負責封裝數據與業務處理，數據庫操做（業務邏輯層和數據訪問層）

V：view，視圖，顯示數據（JSP和前端的html顯示數據）

C：controller，控制器，調度數據（servlet表示層，將用戶輸入的指令和數據傳遞給業務模型）

14. Cookie(客戶端會話)

1. Cookie的概述：

Cookie 就是瀏覽器寫在你本地計算機上的一個文本文件，大小不超過 4K；能夠執行保存密碼，下次自動登陸功能。

2. Cookie的常見操做：

(1) Cookie中的經常使用方法：

public Cookie(String name,String value)：構造方法，用來建立一個名字和值的 Cookie 對象；

setValue()/getValue()：修改 Cookie 的值，獲得 Cookie 中指定的值

getName()：獲得 Cookie 的名字

setMaxAge()/getMaxAge()：設置 Cookie 過時的時間，單位是秒

setPath()/getPath()：用來設置 Cookie 的路徑，cookie的默認有效路徑是當前工程名字，因此瀏覽器只要訪問當前服務器和當前的工程名字都會攜帶cookie到服務器

Response.addCookie(): 把 Cookie 對象寫到瀏覽器。添加了一個叫"Set-Cookie"的響應頭信息

Request.getCookies(): 獲得瀏覽器發送回來的 Cookie 數組,返回值爲一個Cookie數組

(2) Cookie中的注意事項：

A. 必須設置cookie有效期,不然不會產生文本文件,cookie只會在瀏覽器內存中，當瀏覽器關閉時會清空；

B. 當向瀏覽器中設置Cookie以後，之後每次訪問瀏覽器都會自動攜帶cookie數據給到服務器端；

C. Cookie在瀏覽器和服務器之間的傳遞是經過響應消息頭和請求消息頭來傳遞的；

D. 瀏覽器每次請求都會攜帶cookie,會帶來流量資源的銷燬，這時能夠經過setPath()方法來設置Cookie的路徑，如將路徑設置爲/工程名字/abc資源路徑時，這時只有訪問abc這個資源時纔會攜帶Cookie；

(3) Cookie的中文亂碼問題：

由於Cookie傳遞數據是使用消息頭就行傳送的，因此若是使用Cookie傳遞中文時需進行url編碼和解碼。

Url編碼方法：String str2 = URLEncoder.encode(str1,"utf-8"); 會將字符串str1編寫成utf-8格式的url碼str2。

Url解碼方法：String str2 = URLDecoder.decode(cookie.getValue(),"utf-8"); 會將utf-8格式的url進行解碼。

請注意：之後編程中，無論編碼仍是解碼，通常使用utf-8；能支持全部語言；

3. Cookie總結：

默認生命週期:服務器建立輸出給瀏覽器,瀏覽器關閉後cookie失效；設置的生命週期:經過setMaxAge設置有效期。

服務器端生成cookie數據，經過響應頭傳遞給瀏覽器，在瀏覽器端存儲的文本文件。

瀏覽器每次請求都會攜帶與cookie有效路徑同樣的cookie數據經過請求頭帶到服務器端。

cookie存儲在客戶端，數據是不安全的，對於敏感數據要進行加密後在存儲，cookie文件大小有限制4KB。

cookie中存儲是鍵值對，而且一個cookie中只能存儲一個鍵值對。

4. Cookie和Session的總結：

會話對象一共有2個，cookie是客戶端會話，session是服務器端會話

cookie只能存儲字符串數據，session能夠存儲object類型數據

cookie默認有效期是瀏覽器關閉，session默認有效期30分鐘而且是一次會話內

session存儲數據是在服務器端，安全性比cookie高。

15. Session(服務器會話)

1. Session的概述：

從用戶打開瀏覽器開始訪問網站到關閉瀏覽器窗口，咱們認爲瀏覽器與服務器進行了一次會話。會話提供了一種方法，它讓服務器能夠識別屢次請求或訪問服務器的同一個用戶，並服務器存儲有關該用戶的信息。會話在指定的時間段內有效。

2. Session的特色：

1) 運行在服務器端，由服務器爲每一個瀏覽器建立單獨的存儲空間對象，稱爲會話對象。

2) 每一個用戶都有本身的會話對象，不一樣的瀏覽器表明不一樣的用戶。

3) 會話對象也是一個域對象，主要用於存儲每一個用戶本身的數據，不一樣的用戶之間數據不能共享。

3. Session的使用：

session 也是一個域對象，用來保存不一樣用戶的數據。

域範圍大小：request(一次請求) < session(一次會話內) < servletContext(整個應用程序範圍內)。

使用過程：由服務器建立，在第一次用戶訪問的時候會建立一個會話。不一樣的瀏覽器獲得的會話對象是不一樣的。注：同一個瀏覽器不一樣的標籤頁，是同一個會話。能夠經過request.getSession();方法得到這個會話。

HttpSession類（做用域）中的方法：

void setAttribute(String name, Object value) ：向會話中保存數據

void removeAttribute(String name)：從會話中刪除指定的數據

Object getAttribute(String name) ：從會話中獲得指定的數據

String getId() ：獲得會話的 ID，一個 32 位的十六進制數，在服務上惟一。

4. Session的運行原理：

總結：session技術是依賴或基於cookie技術的；用戶第一次訪問沒有cookie，因此服務器就建立session同時將sessionid寫入cookie,用戶第二次訪問攜帶cookie,服務器就能夠獲取cookie-jsessionid,就返回對應已有session對象。

5. session有效期：

session的有效期是一次會話內，關閉了瀏覽器session就沒用了，可是session對象依然存儲在服務器內存中，session對象並無銷燬。默認的會話時間是 30 分鐘(服務器建立一個session對象，30分鐘後會銷燬這個對象。超過30分鐘瀏覽器沒有關閉，瀏覽器訪問服務器，服務器會產生一個新的session對象。)

6. 改變session的銷燬時間：

方式一：經過web.xml文件設置（<session-config> <session-timeout>1</session-timeout> </session-config>）

值設置爲1證實1分鐘後該session會銷燬，若是設置爲0或者負值，那這個session就不會自動銷燬。

方式二：session.invalidate();

當執行這個方法時，該session會馬上失效，能夠應用於註銷登陸等場景。

16. JSP (基本概述)

1. JSP概述（Java Server Pages）：

運行在服務器上的頁面。結合了HTML和Servlet的優勢，既能夠方便的編寫html、CSS和JS代碼，又能夠在網頁上編寫Java代碼處理動態的內容。jsp在訪問的時候，會被服務器翻譯成.java文件，再被編譯成.class文件，因此jsp能夠寫java代碼。Jsp文件被編譯後，其中的html代碼是經過out.write直接輸出，而java代碼是原樣輸出。JSP其實本質上就是一個Servlet，只是服務器把其中的html代碼經過out.write直接進行輸出了。

2. JSP的運行原理：

用戶訪問jsp的時候，服務器每次都會檢查jsp頁面是否修改過，若是修改過服務器會將jsp翻譯成.java文件，並編譯成.class文件；若是服務器檢查jsp沒有修改過，會直接運行.class文件。運行.class的servlet,最後走servlet的生命週期。

3. JSP頁面的七個組成部分：

組成部分	功能	語法
HTML	製做靜態內容
JSP腳本(重點)	Java代碼	符合Java語法 <% Java代碼; %> 有分號
JSP表達式(重點)	能夠直接輸出的表達式	<%=表達式%> 沒有分號
JSP聲明	只能聲明全局變量和方法	<%! 聲明 %>
JSP指令	頁面上的輔助功能	<%@指令名屬性名=屬性值%>
JSP動做	代替部分Java代碼的功能	<jsp:動做名屬性名=屬性值/>
JSP註釋(重點)	用來註釋JSP代碼	<%-- 註釋內容 --%>

(1) JSP註釋：在JSP中一共存在三種註釋

第一種： 該只能註釋靜態內容，如html，css等，若是註釋中有java代碼時，仍是會執行。

第二種：<%-- JSP註釋--%>，被這個註釋註釋的內容，是徹底不會運行的，不過前端仍是後端。

第三種：/ , // , /**/，由於JSP中包含Java代碼，因此Java中的註釋在JSP中能正常使用。

(2) JSP腳本：

語法：<% Java代碼; %>

做用：在JSP上直接編寫Java代碼

(3) JSP表達式：

語法：<%=表達式%>；前面有等於號，後面沒有分號。

做用：用於輸出表達式的值，相似於out.print(表達式)，翻譯成Servlet之後其實就是一句：out.print()

(4) JSP聲明：

語法：<%! 聲明方法或全局變量 %>

例：<%! private String string = "name"; %>

(5) JSP指令：請見以下詳細講解

(6) JSP動做（JSP的內置標籤）：

做用：jsp內置標籤是sun公司開發的，用於封裝了具備必定功能的腳本代碼。（使用時不須要導包）

格式：<jsp:標籤名字></jsp:標籤名字>

標籤一：include標籤 <jsp:include page="設置包含頁面地址的"></jsp:include> 會動態包含另外一個JSP頁面

動態包含：服務器會將包含的2個頁面分別翻譯成2個java文件,是在運行當前頁面時動態將2個頁面合在一塊兒；2個頁面不共享成員變量或局部變量。（因此咱們通常使用include指令進行靜態包含）

標籤二：forward標籤 <jsp:forward page="轉發地址"></jsp:forward> 用於請求轉發

標籤三：param標籤 <jsp:param name="username" value="admin"></jsp:param> 用於轉發中傳遞參數數據

<jsp:forward page="index.jsp">

<jsp:param name="username" value="admin"></jsp:param>

</jsp:forward>

4. JSP九個內置對象：

什麼是內置對象：由JSP翻譯成Servlet以後自動生成的對象，咱們能夠直接在JSP上使用這些內置對象。

對象名	對應的類型	功能描述
request	HttpServletRequest	表明請求對象
response	HttpServletResponse	表明響應對象
out	JspWriter	有緩存的打印流
session	HttpSession	會話對象
application	ServletContext	上下文對象
config	ServletConfig	配置對象
exception	Throwable	異常對象
page	This===》Servlet	JSP翻譯之後的Servlet對象
pageContext	PageContext	頁面上下文

pageContext內置對象詳解（頁面上下文對象）：

(1) 能夠獲取全部內置對象： pageContext.getSession(); 能夠經過 . 的方式獲取其餘的全部內置對象

(2) 是一個域對象：此域對象範圍（一個servlet內,一個jsp頁面內,至關於當前類內部的全局成員變量）

(3) 能夠獲取或設置其餘域數據：

pageContext.setAttribute(String,Object,int); String：數據名字；Object：數據；int：枚舉類型，表明具體域

pageContext.getAttribute(String,int); 從指定域對象裏面獲取數據

(4) 能夠依次搜索全部域對象裏面的數據：

pageContext.findAttribute(name) 會依次從pageContext/request/session/application中查找數據,找到爲止.

5. JSP頁面四大域對象：

做用域對象名	對應的接口名	對象名	做用範圍
頁面域	PageContext	pageContext	當前頁面
請求域	HttpServletRequest	request	一次請求內，同一個請求到達的多個頁面
會話域	HttpSession	session	一次會話內，同一個用戶到達的多個頁面
上下文域	ServletContext	application	整個應用程序，全部用戶到達的全部頁面

頁面域pageContext < 請求域request < 會話域session < 上下文域servletContext

6. JSP和Servlet在之後開發中的使用選擇：

jsp：編寫html佈局代碼方便，因此主要負責顯示佈局動態資源數據

servlet:寫的代碼所有是java代碼，所主要主要負責產生動態資源數據

jsp與servlet配合使用，用戶請求servlet負責從數據庫獲取數據，存儲到域對象裏面，以後跳轉到jsp頁面顯示布局動態資源數據。

7. 解決JSP界面混亂問題：

(1) JSP界面只用了顯示佈局的動態資源數據，不用了進行業務邏輯等的處理；（請參考下方MVC+三層架構）

(2) <%= %> 在JSP界面不寫這個標籤，使用el表達式代替這個進行內容的輸出；（請參考下方EL表達式）

(3) <% %> java代碼不寫在這個標籤中了，使用jstl代替這個技術；（請參考下方JSTL標籤庫）

17. JSP (三大指令)

1. JSP中指令的概述：

指令的做用：用於在JSP頁面上實現一些輔助的功能，並不會在JSP上生成Java代碼。

指令的格式和分類：<%@指令名屬性名=屬性值 %>； JSP中分爲page、include、taglib三大指令。

2. page指令：

(1) 做用：用於告訴tomcat如何將一個JSP頁面翻譯成Servlet，指定翻譯時的一些參數。

(2) 位置：page指令能夠放在網頁的任意的地方，根據開發習慣，建議放在網頁的最前面。

(3) 格式：格式:<%@ page contentType="text/html;charset=UTF-8" language="java" %>。

(4) 屬性一：contentType="text/html;charset=UTF-8",設置輸出類型與碼錶的,至關於response.setContentType方法。

(5) 屬性二：pageEncoding="utf-8" 指定頁面編碼，有三個做用：

做用一：與contentType="text/html; charset=utf-8"屬性的功能相同

做用二：用於設置當前JSP頁面文本保存的字符集

做用三：用於指定JSP翻譯成Servlet的編碼

因此：之後只須要設置pageEncoding屬性就能夠解決JSP編碼的問題

(6) 屬性三：language="java",告訴tomcat將jsp翻譯java文件。

(7) 屬性四：import,導入java類所須要的類

格式一:一個page指令導入一個類<%@ page import="java.util.List" %>

格式二:一個page指令導入多個類<%@ page import="java.util.ArrayList,java.text.SimpleDateFormat" %>

(8) 屬性五：buffer="8kb",用於設置out字符流輸出對象的緩存大小，該屬性默認爲8kb

緩存:沒有緩存當即輸出,有緩存輸出的數據知足指定的大小以後才能輸出；

buffer="8kb",out字符流輸出對象緩存數據輸出的前提條件

條件一：頁面out字符流對象輸出數據大小夠8kb纔會向瀏覽器輸出數據

條件二：若是頁面全部輸出數據不夠8kb,等待頁面沒有緩存的數據所有輸出完後再輸出緩存數據

PrinterWriter response.getWriter() ,這個打印字符流就沒有緩存功能

out對象的類型JspWriter,這是PrinterWriter升級版,具備緩存功能

(9) 屬性六：isErrorPage="false"

用於設置錯誤友好頁面接收傳遞過來的exception對象,默認不接收,設置爲true才接收

咱們能夠在錯誤友好界面將接收過來的exception對象進行控制檯打印或者日誌輸出，能夠看到異常輸出

這個屬性需配合errorPage="500.jsp"這個屬性使用，噹噹前頁面發生異常時跳轉到500.jsp界面，但在工做開發中咱們通常不用這個屬性，咱們會在web.xml文件中配置<error-page> <error-code>500</error-code>

<location>/500.jsp</location> </error-page>這個配置文件，這樣當頁面出現500異常時所有會跳轉500.jsp頁面。

3. taglib指令：

(1) 做用：導入JSP的標籤庫；(標籤庫：是具備特定功能的java代碼，使用標籤方式展示)

(2) 格式：<%@taglib uri="設置導入標籤的地址" prefix="設置標籤的前綴"%>

4. include指令：

(1) 做用：用來包含另外一個JSP或者HTML頁面；

(2) 格式：<%@include file="設置要包含的頁面" %>；

(3) 特色：include指令的包含稱做爲靜態包含，服務器會將當前頁面和包含的頁面2個jsp頁面翻譯成一個.java文件,這樣就叫作靜態包含；靜態包含時2個頁面共享成員或局部變量。

18. JSP(EL表達式)

1. EL表達式之概述：

咱們在寫JSP代碼時，應該儘量少的在jsp頁面上使用Java代碼，由於JSP是一個頁面，頁面上應該使用標籤。因此咱們這個時候就能夠使用EL（Expression Language 表達式語言）表達式了，EL表達式是sun公司本身開發,在jsp頁面上能夠直接使用用。格式：${域對象裏面的key },用於輸出域對象裏面的數據。請注意：JSP中使用的變量是腳本變量，而EL中的變量都是使用域變量，要操做的變量都在使用域中。

2. EL表達式之獲取四大域裏面的數據：

(1) 從指定域裏面讀取數據, ${指定域.key}：

${pageScope.name} ${requestScope.name}

${sessionScope.name} ${applicationScope.name}

(2) 依次從四大域對象裏面獲取數據,找到爲止（從小到大） ${key}：

請注意：從域中經過EL表達式獲取到數據後能夠直接輸出。

3. EL表達式之獲取域裏面不一樣數據類型的數據：

(1) 獲取對象類型的數據：

語法：${域裏面的key.對象屬性} el會自動調用該屬性的get封裝方法獲取值

例： <p>user對象裏面的age屬性值:${user.age}</p>

(2) 獲取Map集合的數據：

語法：${域裏面的key.map裏面的key}

例： <p>獲取map裏面key爲one的user對象裏面的age屬性值:${map.one.age}</p>

(3) 獲取List集合的數據：

語法：${域裏面的key[index]},index從0開始

例： <p>獲取list裏面第一個元素的user對象裏面的age屬性值:${userList[0].age}</p>

(4) 獲取數組類型的數據：

語法：${域裏面的key[index]},index從0開始

例： <p>獲取數組裏面第一個元素的user對象裏面的age屬性值:${users[0].age}</p>

4. EL表達式中的隱式對象：

(1) EL表達式中有11中經常使用的隱式對象，其中標紅的6個需重點掌握：

pageContext：表明頁面上下文對象，能夠在頁面上調用get方法

pageScope：表明頁面域pageContext中的Map對象

requestScope：表明請求域中request的Map對象

sessionScope：表明會話域session中的Map對象

applicationScope：表明上下文域servletContext中的Map對象

Param：獲得表單提交參數，功能與：request.getParameter()相同

paramValues：獲得表單提交參數，功能與：String[] request.getParameterValues()相同

Header：獲得請求頭的數據 request.getHeader(「名字」)

headerValues：獲得請求頭的數據 request.getHeaders(「名字」)

Cookie：獲得請求的Cookie信息

initParam：至關於config.getInitParamter()獲得web.xml中配置的參數

(2) pageContext和pageScope的區別：

這2個EL中的對象是由JSP中的一個對象pageContext變化而來，其做用分別以下所示：

pageScope,能夠獲取jsp域對象pageContext裏面域數據

pageContext,能夠獲取jsp域對象pageContext對象的相關get方法的數據

跟JSP中的使用區別以下（以獲取訪問者IP爲例）：

腳本代碼: <%= request.getRemoteAddr() %>

使用el代替： ${pageContext.request.remoteAddr}

(3) Cookie對象Cookie cookie = new Cookie("name","value"); ：

${cookie.cookie存儲的key.name}//獲取cookie裏面指定key的name 其中key值即爲name值

${cookie.cookie存儲的key.value}//獲取cookie裏面指定key的value

5. EL表達式中的運算符：

算術表達式：

運算符	說明	範例	結果
+	加	${1+1}	2
-	減	${2-1}	1
*	乘	${1*1}	1
/或div	除	${5 div 2}	2.5
%或mod	取餘	${5 mod 2}	1

比較表達式：

運算符	說明	範例	結果
==或eq	等於(equal)	${1 eq 1}	true
!=或 ne	不等於(not equal)	${1 != 1}	false
< 或lt	小於(Less than)	${1 lt 2}	true
<=或le	小於等於(Less than or equal)	${1 <= 1}	true
>或gt	大於(Greater than)	${1 > 2}	false
>=或ge	大於等於(Greater than or equal)	${1 >=1}	true

判空表達式：

判斷變量名是否爲空或空串，若是是，則返回true，不是返回false：

1) 判斷一個變量是否爲null

2) 判斷一個字符串是不是空串

3) 判斷一個集合是否沒有元素

<p>空字符串:${empty ""}</p>

<p>能夠取反:${not empty list}</p>

邏輯表達式：

邏輯運算符	說明	範例	結果
&& 或 and	交集(與)	${A and B}	true / false
\|\| 或 or	並集(或)	${A \|\| B }	true / false
! 或 not	非	${not A}	true / false

6. EL表達式的啓用和禁用：

(1) page指令設置頁面禁用EL(isELIgnored="true")：當在page中設置此指令時，會忽略EL表達式，全部EL表達式都不起做用。

(2) EL的轉義：\ ${5 div 3 }，當在EL表達式前面加上\後，這個EL就不會起做用，\表示這個表達式不起做用。

7. EL表達式中[]和.的區別：

在EL中，一共有2中寫法：${ header["host"] } 和 ${header.host }

若是一個變量名中有特殊的字符，則應用使用[「名字」]；

如：${header["user-agent"]}，該屬性名中含有特殊字符-，因此此時只能使用[ ]的寫法。

19. JSP(JSTL標籤庫)

1. JSTL標籤庫概述：

Jsp Standard Tag Library ，Jsp標準標籤庫，一組由apache公司已經制做好的擴展標籤庫，能夠在JSP頁面直接使用。每一個標籤都有它本身的功能。能夠替換JSP頁面上的Java腳本代碼。

咱們使用JSTL標籤庫主要是使用其中的核心標籤庫，其前綴爲c，url爲http://java.sun.com/jsp/jstl/core，主要做用是一組經常使用的核心標籤庫，就是操做java邏輯控制語句的標籤庫，代替頁面jsp腳本代碼。

2. JSTL標籤庫使用步驟：

(1) 導包jstl.jar庫到web下的lib目錄；

(2) 2.在JSP頁面上使用taglib指令：<%@taglib prefix=」c」 uri=」 http://java.sun.com/jsp/jstl/core」 %>；

(3) 使用標籤庫；

3. JSTL標籤庫之set標籤：

做用：往域裏面設置數據

格式:<c:set var="域裏面key" value="域裏的值" scope="指定域"></c:set>

指定域的值page/request/session/application

例：<c:set var="username" value="admin" scope="session"></c:set>

4. JSTL標籤庫之out標籤：

做用:用於輸出el表達式數據,能夠對特殊數據進行轉義

格式：<c:out value="${requestScope.name }"></c:out>

注意：若是是大量數據不要直接給瀏覽器顯示，須要使用out標籤轉義後再輸出

例：<c:out value="${sessionScope.username}"></c:out>

5. JSTL標籤庫之if標籤：

做用：至關於if條件句,用於分支判斷

格式: <c:if test="el條件表達式"> //條件爲true運行的代碼 </c:if>

例：<c:set var="username" value="" scope="session"></c:set>

<c:if test="${not empty username}">

<p>你好,${username}</p>

</c:if>

6. JSTL標籤庫之choose標籤：

做用:至關於if-else條件句,用於多分支判斷

格式：

<c:choose>

<c:when test="${not empty username}"> when至關於if

<p>你好,${username}</p>

</c:when>

<c:when test="${not empty username}"> when至關於else if

<p>你好,${username}</p>

</c:when>

<c:otherwise> otherwise至關於else

</c:otherwise>

</c:choose>

例：

<c:set var="username" value="" scope="session"></c:set>

<c:choose>

<c:when test="${not empty username}">

<p>你好,${username}</p>

</c:when>

<c:otherwise>

</c:otherwise>

</c:choose>

7. JSTL標籤庫之forEach標籤：

做用：用於循環,至關於for循環

經常使用屬性：

begin:開始循環變量值

end:結束循環變量值

step:循環遞增值,默認1

items:須要遍歷的集合,使用el獲取域裏面的集合數據

var="user":循環變量,也是遍歷集合中的每一個元素,標籤內部會將其放入域中

在循環過程當中會執行這樣操做pageContext.setAttribute("user",object);

varStatus="i"：循環過程信息對象

forEach在循環過程當中會產生不少循環的信息(循環的索引index,序號count),將這些封裝給VarStatus對象

VarStatus varStatus = new VarStatus(index,count);

封裝後會將對象存儲到域中

pageContext.setAttribute("i",varStatus);

因此獲取以下信息： ${i.index}獲取循環索引 ${i.count}獲取循環序號

格式：

普通根據次數循環格式：

<c:forEach begin="1" end="5" step="1">

<p>hello world</p>

</c:forEach>

遍歷集合的循環格式：

<c:forEach items="${userList}" var="user">

</c:forEach>

遍歷數組：

<c:forEach items="${arr}" var="num"> arr爲一個數組對象

${num} <br/>

</c:forEach>

遍歷Map集合:

<c:forEach items="${map}" var="entry"> map爲一個Map集合

${entry.key } -> ${entry.value} <br/>

</c:forEach>

相似於Java中for循環的用法（遍歷從1到100）：

<c:forEach begin="1" end="100" var="i" step="2">

${i} <br/>

</c:forEach>

20. ServletContextListener監聽器

1. ServletContextListener監聽器的概念：

監聽器是JavaWeb三大組件(servlet,監聽器,過濾器)之一，可以在web程序運行的過程當中監聽一些事件，對這些事件作出響應，經過編寫代碼對這些事件進行操做。

2. ServletContextListener的做用：

監聽Servlet中ServletContext域對象，監聽此做用域的建立和銷燬。服務器利用「監聽者（監聽器）」監聽「事件源對象」的變化，可讓開發人員在「事件源對象」變化發生時進行對應的控制實現。

3. ServletContextListener監聽機制的組成

1)事件源：事件的發出者，ServletContext

2)事件：觸發的一種行爲。域對象的建立和銷燬

3)監聽者（服務器）：接口，咱們的程序實現這個接口，而且實現其中的方法。

4. ServletContextListener監聽器中的方法：

接口中的方法	功能
void contextDestroyed(ServletContextEvent sce)	web程序銷燬的時候執行
void contextInitialized(ServletContextEvent sce)	web程序建立的時候執行

5. ServletContextListener監聽器的應用場景：

在服務器啓動時加載配置文件，之後會學習spring框架，到時講解加載spring的配置文件就是使用ServletContextListener監聽器加載的，到時會具體講解。

21. Filter(過濾器)

1. Filter的概述：

過濾器用來過濾用戶的請求和響應，修改用戶的請求和響應的數據，對請求進行攔截。若是某個功能是不少Web資源都須要執行，咱們就能夠在過濾器中集中進行處理。例如能夠對漢字亂碼進行集中的解決。

2. Filter的編寫步驟：

步驟一：編寫一個類，實現javax.serlvet.Filter接口

步驟二：重寫接口中doFilter的方法，全部的過濾都是經過doFilter方法來過濾的；chain.doFilter(request, response);

步驟三：在web.xml中配置過濾器,配置須要過濾哪些用戶訪問的資源(詳細配置請看下方配置映射路徑和過濾類型)

3. Filter的執行流程和生命週期：

(1) 單一過濾器的執行流程：

當前端瀏覽器發送請求時，該請求會先來到過濾器中的doFilter方法，對請求進行過濾，而後經過該方法中的chain.doFilter(request, response);步驟進行放行，執行相應的servlet資源，當執行完畢後又會返回到此過濾器中，對響應進行過濾，最後纔會將響應的數據發送給前端。

(2) 過濾器鏈的執行流程：

過濾器鏈就是多個過濾器同時過濾一個資源，這些過濾器就造成過濾器鏈。

當用戶發送請求後，第一個過濾器會對用戶的請求進行過濾，再將該請求傳送給第二個過濾器，當第二個過濾器過濾完後纔會執行對應的servlet，servlet返回的響應會先返回第二個過濾器，過濾完後再該響應會傳送到第一個過濾器裏，再次進行過濾後纔會在瀏覽器上顯示出來。

(3) 過濾器的生命週期：

由於過濾器是對瀏覽器的請求進行過濾的，因此建立的時間是很早的，當服務器進行加載時就已經建立好這個過濾器了，而後每次瀏覽器發送請求時，都會執行一次過濾器的doFilter方法，對數據進行過濾，當服務器關閉或者重啓時，過濾器也會相應的進行銷燬操做。

4. Filter配置映射路徑：

(1) web.xml中的配置信息以下(以解決全局亂碼爲例) ：

<filter-name>CharacterFilter</filter-name>

<filter-class>com.itheima.filter.CharacterFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>CharacterFilter</filter-name>

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

<servlet-name> </servlet-name>

<dispatcher>REQUEST</dispatcher> <dispatcher>FORWARD</dispatcher>

<dispatcher>INCLUDE</dispatcher> <dispatcher>ERROR</dispatcher>

</filter-mapping>

(2) Filter與Servlet中<url-pattern>的區別：

Servlet中的url-pattern是它的訪問地址， Filter中url-pattern是過濾地址。

瀏覽器訪問目標資源的路徑，若是不存在，過濾器也會執行，只要匹配訪問的url-pattern就會執行過濾器。

(3) 在Filter中URL的過濾方式：

Filter中的URL過濾方式和Servlet中的過濾方式基本相同。

但Servlet不容許使用缺省路徑（/或/*）,會致使靜態資源沒法訪問，Filter能夠使用缺省路徑，表示全局過濾。

(4) 過濾器中匹配的要點：

a. 一個filter-mapping中寫多個url-pattern，這會過濾全部的url-pattern對應的web資源。

b. 一個filter對應多個filter-mapping，這也會過濾全部filter-mapping中url-pattern對應的web資源。

c. 過濾Servlet的寫法：在filter-mapping中，還能夠寫入<servlet-name> </servlet-name>，表示要過濾指定servlet

5. Filter的過濾類型：

沒有配置過濾器類型採用默認的request，若是配置了過濾器就按照配置的類型執行過濾。

之後request和forward經常使用，因此通常這兩都配置上。

REQUEST ：來自於用戶的請求才通過過濾器(包括重定向)，默認值

FORWARD：來自於頁面的轉發才通過過濾器

INCLUDE：來自於頁面的動態包含才通過過濾器

ERROR：來自於錯誤頁面的跳轉才通過過濾器

6. 裝飾者模式：

(1) 概念：原本有一個類，對這個類中的某個方法的功能進行加強，不能修改這個方法的源代碼。使用裝飾者設計模式能夠達到對以實現功能進行持續加強。

(2) 步驟：a.編寫一個類，繼承於具體對象。b.在裝飾類中有一個抽象對象的成員變量，經過構造方法傳遞進來。

c.重寫具體對象的方法，對這個方法進行功能的加強。

7. 解決全局亂碼問題：

(1) 將傳入的請求和響應對象分別轉成子類的對象(HttpServletRequest和HttpServletResponse)

(2) 對請求添加的方法進行判斷，若是是Post提交進行Post解決，若是是Get提交進行Get解決

① 解決請求中post方法的亂碼問題(request.setCharacterEncoding("utf-8");)

② 解決請求中get方法的亂碼問題(使用裝飾模式對請求中的方法getParameter()進行重寫)

(3) 解決響應中的亂碼問題(response.setContentType("text/html; charset = utf-8 ");)

(4) 調用方法，進行放行(chain.doFilter(req, resp);)

8. 自動登陸功能實現：

22. AJAX

1. AJAX介紹：

AJAX即「Asynchronous Javascript And XML」（異步JavaScript和XML）能夠使網頁實現異步更新，就是不從新加載整個網頁的狀況下，對網頁的某部分進行更新（局部刷新）。傳統的網頁（不使用 AJAX）若是須要更新內容，必須重載整個網頁頁面。

AJAX = 異步 JavaScript和XML，是一種新的思想，整合以前的多種技術，用於建立快速交互式網頁應用的網頁開發技術。

2. 同步與異步的區別：

同步概念：客戶端發送請求到服務端，當服務端返回響應以前，客戶端都處於等待卡死狀態。

異步概念：客戶端發送請求到服務端，不管服務端是否返回響應，客戶端均可以在該頁面中隨意作其餘事情，不會被卡死，提升了用戶的體驗。

3. AJAX原理分析：

4. Jquery的AJAX使用：

jQuery.post(url, [data], [callback], [type]); 以post請求方式發送ajax

jQuery.get(url, [data], [callback], [type]); 以get請求方式發送ajax

參數1：url，請求路徑

參數2：data，請求參數,能夠分爲普通格式和json對象格式

普通格式:key1=value1&key2=value2...; json對象格式(就是js對象格式),{key1:value1,key2:value2....}

參數3：callback，回調函數,function(result){…}，這裏的參數result是服務器響應的數據

參數4：type，返回內容格式，xml, html, script, json, text, _default，通常使用json格式

5. JSON數據：

(1) 什麼是JSON數據：JSON(JavaScript Object Notation) 是一種輕量級的數據交換格式。JSON採用徹底獨立於語言的文本格式，就是說不一樣的編程語言JSON數據是一致的。

(2) JSON格式：

JSON對象格式

{"key":"value","key":"value",....}

鍵和值使用冒號分隔。

標準規範要求key必須使用雙引號，value若是沒有使用雙引號表示變量。

JSON數組

[ obj , obj , obj , ....]

表示一組值，多個值使用逗號分隔

(3) JSON-LIB工具( 就是一個json的jar包，如今通常使用gson的jar包 )

使用JSONObject對象將user對象轉換爲json對象格式：JSONObject.fromObject(user).toString();

使用JSONArray對象將userList轉換爲json數組格式：JSONArray.fromObject(userList).toString();

23. Redis(NOSQL數據庫)

1. NOSQL概述：

(1) 什麼是NOSQL：Not Only SQL，意即「不只僅是SQL」，是一項全新的數據庫理念，泛指非關係型的數據庫。

(2) 爲何須要NOSQL數據庫( NOSQL能夠對以下三高問題解決 )：

High performance - 對數據庫高併發讀寫的需求

Huge Storage - 對海量數據的高效率存儲和訪問的需求

High Scalability && High Availability- 對數據庫的高可擴展性和高可用性的需求

(3) NOSQL的特色：易擴展；大數據量，高性能；靈活的數據模型；高可用。

2. Redis概述：

Redis是用C語言開發的一個開源的高性能鍵值對（key-value）數據庫，目前爲止Redis支持的鍵值數據類型以下：

字符串類型 string， 散列類型 hash，列表類型 list， 集合類型 set，有序集合類型 sortedset

咱們通常使用字符串類型。

3. Redis的下載、安裝和使用：

(1) 下載Redis：

官方提供了Linux版的Redis，但Windows版的只能從GitHub中下載，具體連接地址以下：

官網下載地址：http://redis.io/download

github下載地址：https://github.com/MSOpenTech/redis/tags

(2) window版Redis的安裝和使用( 本地安裝 )：

window版的安裝及其簡單，解壓Redis壓縮包完成即安裝完畢，其具體目錄結構以下：

redis-benchmark：性能測試工具

redis-check-aof AOF：文件修復工具

redis-check-dump： RDB文件檢查工具（快照持久化文件）

redis-cli：命令行客戶端

redis-server： redis服務器啓動命令

redis.windows.conf： redis核心配置文件

雙擊Redis目錄中redis-server.exe能夠啓動redis服務，Redis服務佔用的端口是6379，關閉Redis的控制檯窗口就能夠關閉Redis服務；雙擊Redis目錄中redis-cli.exe能夠啓動redis客戶端。

(3) Linux版Redis的安裝( 本地安裝 )：

步驟一：redis是C語言開發，安裝redis須要對源碼進行編譯，編譯依賴gcc環境。 yum install gcc-c++

步驟二：上傳"redis-3.0.0.tar.gz"到linux系統/soft目錄下

步驟三：進入soft目錄,將"redis-3.0.0.tar.gz"解壓到/usr/local目錄下 tar -zxvf redis-3.0.0.tar.gz -C /usr/local

步驟四：進入redis-3.0.0目錄使用make命令編譯redis，以下信息表明編譯成功 ‘make test’ ; )

步驟五：在redis-3.0.0目錄中使用 make PREFIX=/usr/local/redis install 命令安裝redis到/usr/local/redis中

(4) Linux版Redis的服務端啓動( 通常不使用前端模式啓動，這裏介紹後端模式啓動 )：

步驟一：將 /usr/local/redis-3.0.0/redis.conf 複製到 /usr/local/redis/bin/。 cp redis.conf /usr/local/redis/bin/

步驟二：修改redis.conf配置文件， daemonize yes 之後端模式啓動。vim /usr/local/redis/bin/redis.conf

步驟三：啓動時，指定配置文件 cd /usr/local/redis/bin ./redis-server redis.conf

(5) Linux版Redis的其餘操做：

Redis默認端口6379，能夠經過當前服務進行查看：ps -ef | grep -i redis

啓動客戶端命令：進入redis/bin目錄,啓動"redis-cli" ./redis-cli

redis中止：強制中止， kill -9 31475 #pid須要經過「ps -ef|grep redis」進行查詢

正常關閉，向Redis發送SHUTDOWN命令 cd /usr/local/redis ./bin/redis-cli shutdown

遠程鏈接：如需遠程鏈接redis，需配置redis端口6379在linux防火牆中開發

#開放6379端口 /sbin/iptables -I INPUT -p tcp --dport 6379 -j ACCEPT

#開放的端口永久保存到防火牆 firewall-cmd --zone=public --add-port=6379/tcp --permanent

4. Redis的數據類型( 比較經常使用字符串類型 )：

(1) 字符串類型是Redis中最爲基礎的數據存儲類型，它在Redis中是二進制安全的，這便意味着該類型存入和獲取的數據相同。在Redis中字符串類型的Value最多能夠容納的數據長度是512M。

(2) 字符串類型string經常使用命令：

set key value：設定key持有指定的字符串value，若是該key存在則進行覆蓋操做。老是返回」OK」

例：set company "itcast"

get key：獲取key的value。若是與該key關聯的value不是String類型，redis將返回錯誤信息，由於get命令只能用於獲取String value；若是該key不存在，返回(nil)。例：set name "itcast"

del key：刪除指定key 例：del name

5. Redis中keys的通用操做( 所謂通用操做是指，無論value是五種類型中的哪種類型，均可以用的操做 )：

(1) keys pattern : 獲取全部與pattern匹配的key，*表示任意0個或多個字符，？表示任意一個字符

例：keys * 查找出全部的key值

(2) del key key key : 刪除指定的key

例：del username password gender 刪除key爲username，password，gender的鍵值對

(3) exists key：判斷該key是否存在，1表示存在，0表示不存在

例：exists username 若是username存在返回1，不存在返回0

(4) rename key newkey : 將當前key重命名爲newkey

例：rename username newusername 將username重命名爲newusername

(5) type key ：獲取指定key的類型，以字符串形式返回，返回值爲：string/hash等，若是key不存在，返回none

例：type username 返回username的類型

(6) select：一個Redis服務器能夠包括多個數據庫，客戶端能夠指鏈接Redis中的哪一個數據庫，例：select 1

(7) move : 移key到其餘數據庫例：move key 1 : 將當前數據庫中的key移到1號數據庫中

6. Redis的持久化：

(1) 持久化概述：Redis的高性能是因爲其將全部數據都存儲在了內存中，爲了使Redis在重啓以後仍能保證數據不丟失，須要將數據從內存中同步到硬盤中，這一過程就是持久化。Redis支持兩種方式的持久化，一種是RDB方式，一種是AOF方式。能夠單獨使用其中一種或將兩者結合使用。

(2) RDB持久化( 默認支持，無需配置，在指定的時間間隔內將內存中的數據集快照寫入磁盤 )：

優勢：採用該方式，那麼你的整個Redis數據庫將只包含一個文件，能夠很是容易的進行恢復；此方式是由子線程進行IO寫入，作到了性能最大化。

缺點：因爲是在一段時間後纔會執行持久化，因此若是在這段時間內發生宕機現象，數據不會保存；由於是經過子線程進行持久化操做的，因此若是數據過大時執行持久化有幾百毫秒的卡頓現象。

(3) AOF持久化( 該持久化需手動開啓 )：

優勢：該機制能夠帶來更高的數據安全性，即數據持久性；該機制寫入數據時執行的是append模式，因此就算髮生宕機現象，也比較安全；若是日誌過大，Redis能夠自動啓用rewrite機制，更能保證數據安全。

缺點：對於相同數量的數據集而言，AOF文件一般要大於RDB文件；根據同步策略的不一樣，AOF在運行效率上每每會慢於RDB。

7. Jedis的基本使用：

(1) Jedis的基本基本操做和經常使用方法：

a. Jedis介紹：

Redis不只是使用命令來操做，如今基本上主流的語言都有客戶端支持，好比java、C、等。在官方網站裏列一些Java的客戶端，有Jedis、Redisson、Jredis、JDBC-Redis、等其中官方推薦使用Jedis和Redisson。在企業中用的最多的就是Jedis，Jedis一樣也是託管在github上，地址：https://github.com/xetorthio/jedis。

b. 經常使用方法以下：

new Jedis(host, port)：建立jedis對象，參數host是redis服務器地址，參數port是redis服務端口

set(key,value)：設置字符串類型的數據

get(key)：得到字符串類型的數據

hset(key,field,value)：設置哈希類型的數據

hget(key,field) ：得到哈希類型的數據

lpush(key,values)：設置列表類型的數據

del(key)：刪除指定的key

c. jedis的基本操做:

//1 設置ip地址和端口

Jedis jedis = new Jedis("localhost", 6379);

//2 設置數據

jedis.set("name", "itheima");

//3 得到數據

String name = jedis.get("name");

System.out.println(name);

//4 釋放資源

jedis.close();

(2) Jdeis鏈接池的使用：

鏈接池的基本概念：

jedis鏈接資源的建立與銷燬是很消耗程序性能，因此jedis爲咱們提供了jedis的池化技術，jedisPool在建立時初始化一些鏈接資源存儲到鏈接池中，使用jedis鏈接資源時不須要建立，而是從鏈接池中獲取一個資源進行redis的操做，使用完畢後，不須要銷燬該jedis鏈接資源，而是將該資源歸還給鏈接池，供其餘請求使用。

jedisPool的基本使用

public void testJedisPool(){

//1 得到鏈接池配置對象，設置配置項

JedisPoolConfig config = new JedisPoolConfig();

// 1.1 最大鏈接數

config.setMaxTotal(30);

// 1.2 最大空閒鏈接數

config.setMaxIdle(10);

//2 得到鏈接池

JedisPool jedisPool = new JedisPool(config, "localhost", 6379);

//3 得到核心對象

Jedis jedis = null;

try {

jedis = jedisPool.getResource();

//4 設置數據

jedis.set("name", "itcast");

//5 得到數據

String name = jedis.get("name");

System.out.println(name);

} catch (Exception e) {

e.printStackTrace();

} finally{

if(jedis != null){

jedis.close();

}

// 虛擬機關閉時，釋放pool資源

if(jedisPool != null){

jedisPool.close();

}

24. Maven基礎

1. Maven的概念：

Maven是項目進行模型抽象，充分運用的面向對象的思想，Maven能夠經過一小段描述信息來管理項目的構建，報告和文檔的軟件項目管理工具。Maven 除了以程序構建能力爲特點以外，還提供高級項目管理工具。因爲 Maven 的缺省構建規則有較高的可重用性，因此經常用兩三行 Maven 構建腳本就能夠構建簡單的項目。

2. Maven的做用：

maven對項目的第三方構件（jar包）進行統一管理。向工程中加入jar包不要手工從其它地方拷貝，經過maven定義jar包的座標，自動從maven倉庫中去下載到工程中。maven提供一套對項目生命週期管理的標準，開發人員、和測試人員統一使用maven進行項目構建。項目生命週期管理：編譯、測試、打包、部署、運行。

3. Maven的概念模型：

項目對象模型 (Project Object Model)。POM對象模型，每一個maven工程中都有一個pom.xml文件，定義工程所依賴的jar包、本工程的座標、打包運行方式。

4. Maven的倉庫：

本地倉庫：至關於緩存，工程第一次會從遠程倉庫（互聯網）去下載jar 包，將jar包存在本地倉庫。

中央倉庫：就是遠程倉庫，倉庫中jar由專業團隊（maven團隊）統一維護。

遠程倉庫：在公司內部架設一臺私服，其它公司架設一臺倉庫，對外公開。

5. Maven的座標：

Maven的一個核心的做用就是管理項目的依賴，引入咱們所需的各類jar包等。爲了能自動化的解析全部Java構件，Maven將這些Jar包或者其餘資源進行惟一標識，這是管理項目的依賴的基礎，也就是咱們要說的座標。

座標中的屬性：

groupId：定義當前Maven項目名稱

artifactId：定義項目模塊

version：定義當前項目的當前版本

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

6. Maven的安裝和配置：

(1) 下載Maven：能夠取Maven官方網站上下載Maven

(2) 安裝Maven：將下載的壓縮包解壓便可，跟Tomcat服務器相似

(3) 配置環境變量：給Maven配置一個環境變量，配置方式跟JDK的環境變量配置方式相似

(4) 配置本地倉庫：將Maven裏的配置文件Settring.xml中的localRepository屬性配置成本地倉庫的地址便可

(5) 測試Maven安裝成功：打開cmd本地控制檯，輸入mvn -version，顯示Maven版本即配置成功

7. IDEA綁定Maven配置：

(1) 將Maven加載到IDEA中：

File -> Setting -> Build,Execution,Deployment -> Build Tools -> Maven ：進行下圖所示配置

(2) 設置使用本地倉庫：

File -> Setting -> Build,Execution,Deployment -> Build Tools -> Maven -> Runner:

VMoptions：-DarchetypeCatalog=internal ( 設置這個參數會先從本地獲取jar包，若是沒有才去網上獲取 )

(3) idea使用maven項目生命週期管理命令時，會輸出中文亂碼,解決方案：

File -> Setting -> Build,Execution,Deployment -> Build Tools -> Maven -> Runner:

VMoptions: -Dfile.encoding=GB2312

8. 使用Maven骨架建立JavaWeb工程：

(1) 點擊File，新建Module，選擇Maven骨架中的webapp建立項目；

(2) 將關聯的module和父項目選爲none，填寫詳細座標信息( 能夠填寫當前的工程名和模塊名[跟install有關] )；

(3) 選擇本機的Maven信息；

(4) 指定模塊名稱，工程名稱和存儲位置，點擊Finish完成建立；

(5) 在main目錄下建立java源代碼目錄和resources目錄，在src下建立test目錄，在test下建立java測試目錄；

9. Java工程和Web工程的Maven目錄結構：

(1) Java工程的Maven目錄結構：

(2) Web工程的Maven目錄結構：

10. Maven的經常使用命令：

(1) clean：清除編譯產生的target文件夾內容，能夠配合相應命令一塊兒使用，如mvn clean package， mvn clean test

(2) complie：該命令能夠對src/main/java目錄的下的代碼進行編譯

(3) package：mvn package，打包項目，打包後的項目會在target目錄下找到

(4) install：mvn install，打包後將其安裝在本地倉庫，安裝完畢後，在本地倉庫中能夠找到該項目的信息

11. Maven的插件導入：

Maven是一個核心引擎，提供了基本的項目處理能力和建設過程的管理，以及一系列的插件是用來執行實際建設任務。maven插件能夠完成一些特定的功能。例如，集成jdk插件能夠方便的修改項目的編譯環境；集成tomcat插件後，無需安裝tomcat服務器就能夠運行tomcat進行項目的發佈與測試。在pom.xml中經過plugin標籤引入maven的功能插件。

<artifactId>maven-resources-plugin</artifactId>

</plugin>

12. Maven的依賴管理：

(1) 導入依賴：

導入依賴座標，無需手動導入jar包就能夠引入jar。在pom.xml中使用<dependency>標籤引入依賴。

導入servlet的依賴：

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

</dependency>

若是本地倉庫沒有，能夠去網絡地址查：https://mvnrepository.com/

(2) 依賴範圍：

根據<scope>test</scope>標籤來設置依賴範圍

依賴範圍	對於編譯classpath有效	對於測試classpath有效	對於運行時classpath有效	例子
compile	Y	Y	Y	spring-core
test	-	Y	-	Junit
provided	Y	Y	-	servlet-api
runtime	-	Y	Y	JDBC驅動
system	Y	Y	-	本地的，Maven倉庫以外的類庫
按照依賴強度，由強到弱來排序：compile> provided> runtime> test

25. Maven高級

1. 在Maven項目中需注意的事項：

(1) 常見的命令：

Compile：編譯； Test：測試； Package：打包；

Install：安裝(安裝到本地倉庫)； Deploy：部署(部署到私服等)； Clean：清空，將打包好的包刪除；

(2) 座標的書寫規範：

groupId：公司或組織域名的倒序

artifactId：項目名或模塊名

Version：版本號

(3) 依賴範圍：

compile：編譯依賴範圍，在編譯，測試，運行時都須要。

test：測試依賴範圍，測試時須要。編譯和運行不須要。如 Junit

runtime：運行時依賴範圍，測試和運行時須要。編譯不須要。如 JDBC 驅動包

provided：已提供依賴範圍，編譯和測試時須要。運行時不須要。如 servlet-api

2. Maven構建 SSM工程中的知識點：

(1) 依賴傳遞：

什麼是依賴傳遞：A依賴B，B依賴C 至關於 A傳遞依賴C；
依賴衝突解決( 當B和C都依賴了同一jar包，但版本不一樣時，會發生依賴衝突 )：

方法一：聲明優先，在同路徑（從依賴到具體的包的路徑）下；會使用在前面聲明的座標；

方法二：路徑近者優先，若是依賴座標對應的路徑比較短則優先使用該座標對應的依賴；

方法三：排除傳遞依賴；在座標裏面設置配置的座標信息；配置以後則不會再傳遞相關的依賴；

例： <exclusions> <exclusion>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

</exclusion> </exclusions>

(2) 鎖定版本：

面對衆多的依賴，有一種方法不用考慮依賴路徑、聲明優化等因素能夠採用直接鎖定版本的方法肯定依賴構件的版本，版本鎖定後能夠統一在一個地方設置依賴的版本號則全部使用了該座標的工程中的依賴都使用該版本。此方法在企業開發中經常使用。

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

<version>${mybatis.version}</version>

</dependency> </dependencies> </dependencyManagement>

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

</dependency> </dependencies>

注意：在工程中鎖定依賴的版本並不表明在工程中添加了依賴，若是工程須要添加鎖定版本的依賴則須要單獨添加<dependencies></dependencies>標籤，當在<dependencyManagement>中鎖定了版本，因此在<dependency>下不須要再指定版本。

3. 使用Maven分模塊構建工程：

(1) 繼承和聚合：

繼承：父工程有的子工程也要有，能夠將子工程中重複的配置提取出來在父工程的 pom.xml 中定義。

聚合：將一個工程拆分紅多個子工程，某個聚合子工程能夠獨立給予其它工程做爲依賴。

(2) 依賴範圍對傳遞依賴的影響：

依賴會有依賴範圍，依賴範圍對傳遞依賴也有影響，例若有 A、B、C，A依賴 B、B 依賴 C，C 多是 A 的傳遞依賴，以下圖：最左邊一列爲直接依賴，理解爲 A 依賴 B 的範圍，最頂層一行爲傳遞依賴，理解爲 B 依賴 C 的範圍，行與列的交叉即爲 A 傳遞依賴 C 的範圍。

傳遞依賴直接依賴	compile	provided	runtime	test
compile	compile	-	runtime	-
provided	provided	provided	provided	-
runtime	runtime	-	runtime	-
test	test	-	test	-

舉例一：好比A對B有compile 依賴，B對C有 runtime 依賴，那麼根據表格所示 A對 C 有 runtime 依賴。

舉例二：若是修改 ssm_dao 工程依賴 junit 的 scop 爲 compile，ssm_dao 工程所依賴的 junit 的 jar 包會加入到 ssm_service 工程中，符合上邊表格所示。

4. Maven私服：

關於Maven私服的安裝、配置和第三方jar包的上傳和下載請查看nexus安裝的詳細文檔。

26. Git工具的使用

1. Git概述：

Git是分佈式版本控制系統，SVN是集中式版本控制系統。

2. Git工做流程( 重點，必須掌握 )：

(1) 從遠程版本庫中克隆（倉庫，工做目錄）

(2) 在工做目錄中修改具體的文件，

(3) 將修改提交到暫存區

(4) 將修改從暫存區提交到本地版本庫（新版本號）

(5) 能夠加個本地版本庫中的版本推送到遠程版本庫

(6) 能夠從遠程版本庫中拉取最新的修改版本

3. Git安裝和使用：

關於Git安裝和使用以及更詳細的配置請查看Git的安裝文檔

27. 框架概述

1. 什麼是框架：

框架(Framework)是整個或者部分系統的可重用設計，是J2EE底層技術的封裝。框架是能夠被應用開發者（程序員）定製的應用骨架。簡而言之，框架其實就是別人搭好了舞臺，你來作表演。

2. 框架解決的問題：

(1) 框架解決了技術整合問題。在J2EE體系中，有着各類各樣的技術。不一樣的軟件企業，根據自身的業務需求選擇不一樣的技術，容易形成應用依賴技術，增長了項目開發實現的複雜性和技術風險性。企業項目中應該將應用的設計與實現技術解耦。

(2) 框架解決了提高開發效率的問題。企業項目中使用框架，程序員再也不須要重複造輪子，只須要專一實現業務需求。使用框架的方便性，提高了開發效率。

(3) 框架解決了穩定性的問題。一個成熟的框架，通過了在衆多企業項目中的驗證使用。穩定性有保障

3. 軟件開發中的分層思想：

4. 分層開發下常見框架：

(1) MyBatis：解決數據持久化問題的框架；

(2) Spring MVC：解決web表現層的mvc框架；

(3) Spring：解決技術整合問題的框架；

28. MyBatis

28.1. mybatis介紹：

(1) mybaits框架的早期版本叫作Ibatis，目前託管在github。

(2) mybatis框架是一個持久層的框架，是對jdbc的封裝。

(3) mybatis框架經過xml或者註解進行配置，實現java對象與sql語句的映射（對應關係）。

28.2. mybatis入門程序( 可以使用mybatis框架對數據庫進行操做 ) ：

(1) 配置pom.xml文件，加入依賴，即導入jar包( 加入後需刷新右側的Maven，看jar包是否已經導入 )；

(2) 編寫配置文件( 使用框架的兩大特色：一個是框架的jar包；另一個則是框架的配置文件 ):

編寫mybatis框架的主配置文件，該文件名稱能夠修改，默認使用sqlMapConfig.xml：

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE configuration

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

</configuration>

編寫日誌的配置文件( 此配置文件能夠在運行過程當中進行日誌的打印 )：

# Global logging configuration

log4j.rootLogger=DEBUG, stdout

# Console output...

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

日誌文件的依賴：

<version>${slf4j.version}</version>

</dependency>

(3) 編寫用戶實體類對象；

(4) 編寫mapper.xml映射文件( 此配置文件的主要用於配置java對象與sql語句的對應關係 )：

通常來講，一個mapper.xml文件對應一個實體類對象，因此在一個項目中存在不少的該映射文件，能夠建立一個文件夾來放置；另外，使用框架，程序的入口是主配置文件，須要將其它配置文件在主配置文件中進行加載。因此要在主配置文件中添加<mappers>標籤，用來加載mapper.xml文件，請看步驟(2)。

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- select：用於放置查詢的sql語句 id：惟一標識一條sql語句, parameterType：輸入參數的類型

resultType：返回值類型（暫時注意是類的全限定名稱） #{id}：佔位符，至關於jdbc中的？-->

(5) 編寫測試代碼：

//1.加載主配置文件sqlMapConfig.xml (通常封裝到工具類中)

//2.讀取主配置文件內容 (通常封裝到工具類中)

/**SessionFactory對象：

* a.它是mybatis框架的核心對象

* b.它是線程安全的，一個應用中一般只須要一個便可

* c.它能夠給咱們打開SqlSession對象

//3.打開SqlSession對象 (通常使用工具類獲取的SqlSessionFactory對象進行打開)

/**SqlSession對象：

* a.它給咱們提供了操做數據庫的CRUD方法

* b.它是線程不安全的，每個執行的方法都須要建立一個

// 4.調用API方法執行

/**

* selectOne方法：查詢單條記錄

* 參數一：執行的sql語句（名稱空間+"."+sql語句的id）參數二：傳入的參數值

Object user = sqlSession.selectOne("test.queryUserById", 24);

//5.釋放資源

sqlSession.close();

27.3. mybaits中的小知識點：

(1) 佔位符#{}和${}的區別 ( 在項目中通常使用#{}，當進行模糊查詢時才考慮使用${} )：

佔位符#{}，至關於jdbc中的問號?。當參數傳遞的是java簡單類型（八種基本類型+字符串String）的時候，花括號中的內容能夠是任意字符串。
字符串拼接符${}，當參數傳遞的是java簡單類型的時候，花括號中的內容只能是：value
佔位符#{}與字符串拼接符${}，當參數傳遞的是pojo類型的時候，花括號中的內容都是pojo的屬性

(2) mybaits中的提交事務：

手動提交事務( sqlSession.commit(); )：

當須要執行的sql語句所有執行完後，經過代碼手動提交數據，能夠保證全部的sql語句所有執行成功後纔會改變數據庫中的數據，若是其中的某條sql語句異常，不會執行提交的代碼，能保證數據安全性。

自動提交事務( 打開sqlSession對象的時候，指定自動提交事務，代碼：sessionFactory.openSession(true); )：

在打開sqlSession對象時，若是設置爲true就爲自動提交事務，不設置就不會自動提交；若是設置爲自動提交事務那隻要操做一完成就提交事務，若是有多個操做，且要考慮事務回滾的狀況下，須要使用手動提交事務的方式。

(3) 獲取數據庫維護的主鍵值：

在企業項目中，若是數據庫表的主鍵字段值由數據庫自行維護，則不須要咱們在java程序中進行傳遞。可是咱們有這樣的需求，好比新增一個用戶後，須要給該用戶分配權限，須要該用戶id值。即須要把數據庫維護的主鍵值查詢出來。

方式一：

selectKey：查詢數據庫維護的主鍵值，說明：

keyColumn：主鍵字段 keyProperty：主鍵屬性 resultType：主鍵類型

order：指定在insert語句執行以前，仍是以後獲取主鍵值。

AFTER：在insert執行後；BEFORE：在insert執行前

select last_insert_id()

</selectKey>

方式二：

在要執行的sql語句的標籤中添加以下屬性：

useGeneratedKeys="true" keyColumn="id" keyProperty="id"

便可以獲取主鍵值

27.4. mybaits的框架原理：

a. Configuration：配置對象，它的內容是主配置文件（sqlMapConfig.xml），具體mapper映射文件（User.xml.......）

b. MappedStatment：輸入輸出映射對象，paramterType參數輸入，resultType返回值輸出

c. Executor：執行器對象，執行數據庫的CRUD操做

27.5. mapper代理開發原則：

(1) 要求mapper映射文件中namespace屬性值，必須是mapper代理接口的全限定名稱；

(2) 要求mapper映射文件中sql標籤的聲明，與mapper代理接口中方法的聲明一致；

sql標籤中resultType屬性指定的類型（若是返回的結果是集合，那麼resultType指定的是集合中存放的類型），與mapper接口方法返回值類型一致
sql標籤中id屬性值，與mapper接口方法名稱一致
sql標籤中parameterType屬性指定的類型，與mapper接口方法的形參類型一致

(3) 代碼實現：

編寫mapper代理接口，即編寫一個dao層的數據庫訪問的接口；
編寫UserMapper.xml映射文件，命名需根據mapper代理開發原則來命名；
在sqlMapConfig.xml文件中，加載UserMapper.xml文件；
具體代碼調用：

// 1.建立sqlSession對象（使用工具類）

SqlSession sqlSession = MybatisUtil.getSqlSessionFactory().openSession();

//2.使用sqlSession對象，調用API方法獲取mapper代理對象

// getMapper方法：獲取mapper代理對象參數：被代理接口的字節碼

UserMapper mapper = sqlSession.getMapper(UserMapper.class);

//3.使用mapper對象，調用具體的方法，實現對數據庫的操做

User user = mapper.queryUserById(2);

//4.釋放資源

sqlSession.close();

27.6. mybatis主配置文件：

(1) 主配置文件sqlMapConfig.xml文件能夠配置內容以下：

順序	配置標籤名稱	說明
1	properties	屬性	1.紅色字體內容要求掌握 2.在sqlMapConfig.xml中必須是從上往下的配置順序
2	settings	配置全局參數
3	typeAliases	類型別名
4	typeHandlers	類型處理器
5	objectFactory	對象工廠
6	plugins	插件
7	environments	環境集合屬性對象
8	databaseIdProvider	多數據庫支持
9	mappers	映射器

(2) properties（屬性）：

做用：加載屬性文件（好比db.properties）和定義屬性
編寫db.properties文件：

db.driver=com.mysql.jdbc.Driver db.url=jdbc:mysql://127.0.0.1:3308/mybatis

db.username=root db.password=admin

加載db.properties文件:

使用db.properties文件中的屬性:

//在進行數據庫配置時能夠以下方法使用 <property name="driver" value="${db.driver}" />

使用property標籤的其餘聲明：

能夠使用resource加載本地的屬性文件，能夠使用url屬性加載網絡上的屬性文件。先加載內部property標籤訂義的屬性，再加載屬性文件中的屬性。若是相同，屬性文件中的屬性覆蓋property標籤訂義的屬性。

(3) typeAliases（類型別名）：

內置別名：

內置別名能夠直接使用，別名不區分大小寫；

自定義別名：

方式一( 瞭解 )：

<!--配置單個別名，說明：

1.type：別名的類型

2.默認使用類的名稱做爲別名的名稱

3.alias：別名的名稱

-->

</typeAliases>

方式二( 很重要 )：

<!--包掃描方式配置別名，說明：

1.name：要掃描的包

2.有多個包，在同一個父包下，配置父包便可

3.不在同一個父包，配置多個package標籤

4.在企業項目中，推薦使用包掃描方式

-->

</typeAliases>

(4) mappers( 映射器 )：

a. 能夠進行包掃描方式加載mapper映射文件：

<!--加載UserMapper.xml

<!--包掃描方式加載別名，說明：

1.前提是mapper代理開發方法

2.要求mapper映射文件，與mapper接口在同一目錄

3.要求mapper映射文件的名稱，與mapper接口名稱一致

4.企業項目中推薦使用這種方式

-->

</mappers>

b. 注意事項：使用idea開發工具，全部配置文件都須要放在resources資源目錄下。此時須要在resources下建立對應的目錄。好比cn.itheima.mapper，而且把UserMapper.xml文件移動到該目錄下。

27.7.mybatis輸入輸出映射

1. ParameterType輸入映射:

(1) 能夠是簡單類型，當爲簡單類型時，直接在ParameterType中寫入具體的簡單類型便可；

(2) 能夠是pojo參數類型：'%${user.username}%'

2. ResultType輸出映射：

(1) java簡單類型：在ResultType中直接寫入具體的簡單類型便可；

(2) pojo類型：在ResultType中寫入具體映射的對象；

3. ResultMap輸出映射：

<!--配置訂單的主鍵對應關係，說明：

column：主鍵字段 property：主鍵屬性 -->

</resultMap>

select o.id,o.user_id,o.number,o.createtime,o.note from orders o

</select>

27.8.mybatis動態sql

1. if標籤：判斷傳入的參數狀況，拼裝sql語句。

username like #{username} </if>

2. where標籤：

where標籤，至關於sql語句中的where關鍵字；根據傳入的參數狀況，智能的去掉多餘的and、or條件關鍵字；根據傳入的參數狀況，智能的去掉多餘的where關鍵字。

3. set標籤：

至關於sql語句中的set關鍵字，根據傳入的參數狀況，智能的去掉多餘的逗號。

4. sql（include）標籤：

說明：sql標籤：提取公共的sql語句片斷；include標籤：用於引用sql片斷。

o.id,o.user_id,o.number,o.createtime,o.note

</sql>

select <include refid="select_orders_list"/> from orders o

</select>

5. foreach標籤：

做用：循環處理參數集合（list、數組）。

insert into `user`(username,birthday,sex,address) values

<!--('用戶1','2018-04-30','1','地址1'),('用戶2','2018-04-30','1','地址12')

foreach標籤：循環處理參數集合

collection：參數集合，這裏是list

item：當前遍歷的對象

separator：元素間的分割符

-->

(#{u.username},#{u.birthday},#{u.sex},#{u.address})

</foreach>

</insert>

27.9.mybatis關聯查詢

1. 關聯關係分類：

(1) 一對一關聯關係，人和身份證的關係。一我的只能有一張身份證，一張身份證只能屬於一我的。雙向的【一對一】關聯關係。

(2) 一對多關聯關係，人和訂單的關係。一我的能夠有多個訂單，從人到訂單是【一對多】關聯關係。一個訂單隻能屬於一我的，從訂單到人是【一對一】的關聯關係。

(3) 多對多關聯關係，學生和課程的關係。一個學生能夠選擇多門課程，一門課程也能夠被多個學生選擇。多對多關聯關係，在實際項目中，一般當作兩個一對多的關聯關係。所以咱們這裏講的實際上是一對一關聯關係，和一對多關聯關係。

2. 一對一關聯查詢：

<!--配置訂單到用戶的一對一關聯關係，說明：

id：惟一標識名稱，經過id引用該ResultMap type：要映射的類型 -->

<!--配置訂單到用戶的一對一關聯關係： association：配置一對一關聯關係

屬性： property：映射的屬性名稱 javaType：映射的屬性類型（必需要指定）-->

</association>

</resultMap>

SELECT o.id, o.user_id, o.number, o.createtime, o.note, u.username, u.address FROM

orders o LEFT JOIN `user` u ON o.user_id = u.id

</select>

3. 一對多關聯查詢：

<!--配置用戶到訂單一對多關聯關係，說明：

id：惟一標識名稱，經過id引用該resultMap; type：要映射的類型 -->

<!--配置用戶到訂單一對多關聯關係，說明： collection：配置一對多關聯關係

屬性：

property：要映射的屬性名稱

javaType：要映射的屬性類型（能夠指定，能夠不指定，建議都指定）

ofType：集合中存放的類型（必需要指定）

-->

</collection>

</resultMap>

SELECT u.id, u.username, u.birthday, u.sex, u.address, o.id oid, o.number, o.createtime

FROM user LEFT JOIN orders o ON u.id = o.user_id

</select>

29. 組件開發和依賴問題

1. 組件式開發概念：

組件式開發，也叫模塊化開發。各模塊之間、各子系統之間，須要保持相對的獨立性。

2. 依賴問題( 經過JDBC鏈接數據庫操做演示依賴問題 )：

(1) 存在的問題：

使用DriverManager.registerDriver(new com.mysql.jdbc.Driver());語句加載驅動，咱們發現應用程序對mysql數據庫的驅動有很強的編譯期依賴關係，緊密耦合。

(2) 面向對象編程的原則：高內聚，低耦合。在編譯的時候不依賴，在運行時才依賴。

(3) 解決方法：經過反射技術，加載驅動的的字符串名稱，實現運行時加載( Class.forName("com.mysql.jdbc.Driver"); )

(4) 依然存在的問題：

應用程序依然存在對數據庫驅動的具體依賴；
假如須要從mysql數據庫，換成oracle數據庫，仍是要需改java代碼；
有沒有更好的方法，實如今數據庫之間進行切換，也不須要修改java代碼

3. 依賴問題解決（工廠模式解耦）：

(1) 對解決依賴問題的說明：

在上述依賴問題中，咱們發現應用程序的類和類之間，不可避免都會產生依賴關係，咱們把這種依賴關係，稱爲耦合。在實際的項目開發中，有些依賴關係是必須的，有些依賴關係能夠經過優化實現方式清除。接下來咱們使用工廠模式，實現依賴關係的解耦。

(2) 工廠模式概述：

工廠模式是咱們最多見的實例化對象模式了，是用工廠方法代替new操做的一種模式。工廠模式在Java程序系統能夠說是隨處可見，由於工廠模式就至關於建立實例對象的new，咱們常常要根據類Class生成實例對象，如 A a = new A()工廠模式也是用來建立實例對象的，使用之後new時就要多個心眼，是否能夠考慮使用工廠模式，雖然這樣作，可能多作一些工做，但會給你係統帶來更大的可擴展性和儘可能少的修改量。

(3) 使用工廠模式解耦最終版( 只需掌握最終版 )；思路：使用配置文件，配置須要實現的類，在工廠類中，經過加載配置文件，根據配置文件內容，使用反射技術運行時建立對象。：

準備配置文件( bean.properties )：

例：CUSTOMERDAO=cn.itheima.dao.impl.CustomerDaoImpl

編寫工廠類：

步驟一：聲明私有的工廠類對象( 把工廠類構造方法私有化，使用靜態代碼塊初始化工廠類對象； );

步驟二：提供公有的靜態的方法，獲取工廠類對象；

步驟三：經過傳入的beanName去配置文件中獲取類的全限定名稱，在經過反射技術建立目標對象；

例：String classPathName = prop.getProperty(beanName); //beanName至關於配置文件左側名字

Object obj = Class.forName(classPathName).newInstance();

4. 工廠模式解耦瞭解：

(1) 說明：在實際項目開發中，咱們能夠經過配置文件把controller、service、dao對象配置起來，當啓動服務器加載應用的時候，讀取配置文件，建立配置文件中的對象而且保存起來。因爲在一個應用中，會須要大量的對象，因此在應用加載時候，建立一個Map，用於存放controller、service、dao對象，這個Map咱們把它稱爲容器。

(2) 什麼是工廠？工廠就是負責建立對象，而且把對象放到容器中。而且在使用的時候，幫助咱們從容器獲取指定的對象。此時咱們獲取對象的方式發生了改變。

(3) 總結：用來咱們獲取對象時，都是採用new的方式。是主動獲取。如今咱們獲取對象時，找工廠要，由工廠建立或者提供給咱們。是被動接收。這種將對象建立的權利，由在程序代碼中主動new對象，轉變爲由工廠建立提供，咱們使用的地方被動接收的方式。稱爲控制反轉。控制反轉也叫IOC（Inversion Of Control），即咱們接下來要學習的spring框架中的一個重點知識點。在這裏咱們首先明確一個事情：spring的IOC解決的問題，便是工廠模式解耦解決的問題。

30. Spring

30.1. spring概述：

A. spring介紹：

spring是分層的Java SE/EE應用的full-stack輕量級開源框架。它是以IOC（Inversion Of Control）控制反轉和AOP（Aspect Oriented Programming）面向切面編程爲核心，提供了表現層springmvc和持久層spring JDBC以及業務層的事務管理等企業級應用解決方案。還能實現將開源世界中衆多優秀的第三方框架和類庫整合，成爲愈來愈受歡迎的Java EE企業級應用框架。

B. spring優勢：
1. IOC解耦，簡化開發：經過spring提供的IOC容器，能夠將對象間的依賴關係交由spring管理，避免硬編碼形成的程序間過渡耦合。用戶也沒必要再爲了編寫工廠類，屬性文件解析等底層實現編寫代碼，能夠更加專一於業務系統需求的實現；
2. AOP面向切面編程支持：經過spring的AOP功能，方便實現面向切面編程，不少使用傳統OOP編程不容易實現的業務功能，能夠經過AOP輕鬆實現。好比事務管理，日誌功能。
3. 聲明式事務支持：經過聲明式方式靈活實現事務管理，提升開發效率和質量，將咱們（程序員）從單調煩悶的事務管理代碼中解脫出來。
4. 方便程序測試：能夠使用非容器依賴的方式進行程序測試工做，讓測試工做更加輕鬆，更加方便。
5. 集成第三方優秀框架：spring框架下降了第三方框架的集成使用難度，提供了對各類框架的直接支持。
6. 學習java源碼的經典案例：spring的源碼設計精妙、結構清晰、匠心獨具，到處體現了大師對java設計模式的靈活應用以及java技術的高深造詣。它的源代碼無疑是java技術的最佳實踐案例。
7. C. spring體系結構：

30.2. spring的IOC( 基於xml方式配置IOC )：

A. IOC的基本概述：

IOC（Inversion Of Control）控制反轉。是面向對象編程的一個重要法則，用於削減計算機程序間的耦合問題。控制反轉中分爲兩種類型，一種是DI（Dependency Injection）依賴注入；另一種是DL（Dependency Lookup）依賴查找。實際應用中依賴注入使用更多。

B. IOC的基本配置：

a) 準備spring的jar包：

spring官方網址：http://spring.io/

下載地址一( 官方 )：https://projects.spring.io/spring-framework/

下載地址二：http://repo.springsource.org/libs-release-local/org/springframework/spring/

b) 建立表現層，業務邏輯層，數據訪問層的三層架構所需的類；

c) 配置pom.xml文件，加入spring依賴包：beans包，core包，context包，expression包，等

d) 編寫bean.xml配置文件：

這裏bean.xml文件，就至關於咱們工廠模式解耦中的bean.properties屬性文件。用於配置javaBean對象。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--使用bean標籤配置javaBean對象，說明：

屬性： id：bean對象的惟一標識名稱 class：類的全限定名稱

細節：默認調用無參數構造方法建立bean對象

-->

</beans>

e) 在Java代碼中調用框架，獲取具體的對象：

// 加載spring配置文件bean.xml，建立spring框架提供的工廠對象

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

// 從工廠容器對象中，獲取java對象

CustomerService service = (CustomerService) context.getBean("customerService");

C. 基於xml的IOC配置細節：

a) ApplicationContext：

它是spring框架提供的一個大工廠，提供了根據bean的id獲取對象的方法，主要有兩個經常使用的實用類：

ClassPathXmlApplicationContext：從類根路徑下加載配置文件（企業項目開發中使用較多）【須要掌握】

FileSystemXmlApplicationContext：從文件系統（磁盤上）加載配置文件【瞭解便可】

b) BeanFactory與ApplicationContext區別：

不一樣點一：BeanFactory是工廠頂層接口，ApplicationContext是BeanFactory子接口

不一樣點二：默認建立對象的時間點不同：

BeanFactory建立對象：何時使用，何時建立。採用延遲建立的思想；

ApplicationContext建立對象：加載配置文件，當即建立對象。採用當即建立的思想。

D. bean標籤細節：

a) 做用：配置javaBean對象，讓spring容器建立管理。默認是使用無參的構造方法建立對象。

b) 屬性：

id：給bean取一個惟一標識名稱

class：指定類的全限定名稱

scope：指定bean的做用範圍( singleton：單例。默認值；prototype：多例 )

init-method：指定初始化執行方法名稱，在構造方法執行後當即執行。通常用於執行初始化【瞭解】

destroy-method：指定銷燬執行方法名稱，在spring容器銷燬前執行。通常用於執行釋放資源【瞭解】

c) 做用範圍和聲明週期：

單例對象：scope="singleton"；做用範圍：一個應用只有一個對象實例，範圍是整個應用；

生命週期：加載配置文件，容器建立，對象出生；容器存在，對象就存在；容器銷燬，對象死亡

多例對象：scope="prototype"；做用範圍：在一次使用的過程當中；

生命週期：和普通對象相似，建立是對象出生，使用過程當中存活，沒有使用和沒有被引用時，消亡

E. bean建立對象的三種方式：

a) 使用無參數構造方法建立對象【掌握】：

b) 使用靜態工廠方法建立對象【瞭解】：

<bean id="staticDao" class="cn.itheima.factory.StaticFactory"

factory-method="getCustomerDao"></bean>

c) 使用實例工廠方法建立對象【瞭解】：

//第一步：配置實例工廠對象

//第二步：使用實例工廠對象，實例工廠方法，建立客戶dao對象

<bean id="instanceDao" factory-bean="instanceFactory"

factory-method="getCustomerDao"></bean>

F. 依賴注入：

a) 依賴注入是什麼：

在前面的spring的IOC中，已經讓spring框架爲咱們建立了客戶業務層、以及客戶持久層對象。還差層與層之間的關係沒有維護起來。接下來咱們來看spring框架的依賴注入。首先給依賴注入下一個定義。依賴注入即在spring建立容器時，爲咱們維護好層與層之間對象的關係。咱們在使用中，只須要提供構造方法或者set方法便可。簡單說就是在層與層之間缺乏什麼，就傳入什麼。

b) 構造方法注入【瞭解】：

<!--配置構造方法注入，說明： constructor-arg標籤：調用構造方法給成員變量賦值

index：指定參數在構造方法參數列表中的索引 name：指定參數在構造方法參數列表中的名稱

type：指定參數類型（一般不須要指定） value：給簡單參數類型賦值（八種基本類型+字符串String）

ref：給其它bean類型賦值

-->

<constructor-arg index="0" type="int" value="1"></constructor-arg>

<constructor-arg name="name" value="小明"></constructor-arg>

<constructor-arg name="age" value="18"></constructor-arg>

<constructor-arg name="birthday" ref="now"></constructor-arg>

</bean>

c) set方法注入【掌握】：

<!--配置set方法注入，說明： property標籤：調用set方法給成員變量賦值

name：成員變量的名稱； value：給簡單類型賦值（八種基本類型+字符串String）；

ref：給其它bean類型賦值

-->

</bean>

d) p名稱空間注入【瞭解】：

<!--配置p名稱空間注入方式，說明：

第一步：導入p名稱空間（xmlns:p="http://www.springframework.org/schema/p"）

第二步：配置

p:屬性：給簡單類型賦值

p:屬性-ref：給其它bean類型賦值

-->

<bean id="pDependency" class="cn.itheima.dao.impl.SetDaoImpl"

p:id="1" p:name="小王" p:age="18" p:birthday-ref="now">

</bean>

e) 集合屬性注入【瞭解】

<array>

<value>array1</value> <value>array2</value>

</array>

</property>

30.3. spring的IOC( 基於註解和xml配置IOC )

A. 使用註解的步驟：

a) 建立項目，架設必要的三層架構；

b) 搭建spring IOC開發環境( 基於註解的開發環境 )：

l 配置pom.xml文件，加入依賴jar包( 除spring中的4個必要包和日誌包外還需導入spring aop包 )

l 編寫bean.xml文件：

導入context名稱空間( 以下所示 )：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

配置context:component-scan標籤，掃描包：

<!--配置掃描包，說明：配置context:component-scan，指定spring建立容器時掃描的包。

它會掃描配置的當前包和它的子包

-->

<context:component-scan base-package="cn.itheima"></context:component-scan>

c) 改造實現類：

在實現類上加上必要註解，註解詳情請看下面經常使用註解模塊

B. 經常使用註解：

a) 建立對象相關注解( @Component )：[ 例：@Component("customerService") ]

做用：此註解添加於類名上方，至關於bean.xml中，bean標籤配置

屬性：value，給bean取一個名稱，至關於bean標籤中的id屬性。

但value屬性能夠省略，當省略時默認使用類的名稱（首字母小寫），做爲bean的名稱

細節：由@Component衍生的三個註解，衍生三個註解的目的是語義更加明確：

分別是：@Controller：通常用於表現層

@Service：通常用於業務層

@Repository：通常用於持久層

b) 設置bean做用域相關注解( @Scope )：[ 例：@Scope("singleton") ]

做用：此註解也添加於類名上方，用於設置bean的做用範圍，至關bean標籤中的scope屬性

屬性：value，屬性名即value通常省略，只寫屬性值便可，屬性能夠取以下值：

singleton：單例。默認值，當沒有添加@Scope註解時默認爲此值

prototype：多例

request：web項目中，request域【瞭解】

session：web項目中，session域【瞭解】

globalsession：web項目中，全局session域【瞭解】

c) 注入數據相關注解：

l @Autowired註解( 此註解無屬性 )：[ 例：@Autowired ]

做用：寫於類型爲bean的成員變量上方，默認按照bean的類型注入數據，即若是spring容器中存在跟bean類型相同的對象，就會將該對象賦值給該成員變量。

細節：在spring容器中，同一個類型存在多個bean。先根據bean的類型進行注入，再根據bean

的名稱進行匹配。匹配上注入成功；匹配不上注入失敗。即若是該成員變量的類型爲Student，名稱爲student，在進行注入時會先將spring容器中全部的Student對象都查找出來，若是存在多個，就會查找名稱爲student的對象，若是能查到注入成功，不能就注入失敗。

l @Qualifier註解：[ 例：@Qualifier("customerDao2") ]

做用：配合@Autowired註解使用。在按照類型注入的基礎上，再按照此註解的value的值注入

屬性：value：指定注入的bean名稱

細節：在成員變量上使用，不能單獨使用，須要配合@Autowired註解一塊兒使用

在方法形參上，能夠獨立使用

l @Resource註解：[ 例：@Resource(type= CustomerDaoImpl.class) ]

做用：寫於類型爲bean的成員變量上方，默認按照bean的名稱注入數據

屬性：name：指定注入bean的名稱

type：指定注入bean的類型

細節：默認按照bean的名稱注入數據，若是名稱匹配不上，會自動再按照bean的類型進行注入

l @Value註解：[ 例：@Value("1") ]

做用：寫於類型爲簡單類型的成員變量上方，給基本數據類型注入數據

屬性：value：數據值

d) 與bean生命週期相關注解：

l @PostConstruct：[ 例：@PostConstruct ]

做用：寫於方法上方，指定執行初始化操做的方法。至關於bean標籤中的init-method屬性。

l @PreDestroy：[ 例：@PreDestroy ]

做用：寫於方法上方，指定執行銷燬操做的方法。至關於bean標籤中的destroy-method屬性。

C. spring整合junit單元測試：

a) 加入junit單元測試框架包；

b) 除spring基礎包外加入spring註解開發（aop）包和測試（test）包；

c) 使用@Runwith註解，把junit框架的測試類，替換成spring提供的測試類：SpringJUnit4ClassRunner：

例：@RunWith(SpringJUnit4ClassRunner.class) //此註解寫於測試類上方

d) 使用@ContextConfiguration註解，加載spring的配置文件（bean.xml）：

@ContextConfiguration(value={"classpath:bean.xml"}) //此註解寫於測試類上方

e) 此時已加載好spring容器，裏面的對象都可以直接使用；

30.4. 動態代理

A. 代理模式定義：

爲目標對象提供一種機制，用於控制對這個對象的訪問。在某些狀況下，一個對象不適合或者不能

直接引用另外一個對象，而代理對象能夠在客戶端和目標對象之間起到中介的做用。

B. 代理模式優勢：

安全性好：代理對象，在客戶端和目標對象之間起到中介的做用。實現了對目標對象的保護。

擴展性好：在運行時實現對目標對象的加強，屬於字節碼加強，不須要修改目標java源代碼。

職責清晰：真實的角色就是實現實際的業務邏輯，不用關心其餘非本職責的事務。經過後期的代理完成一件

完整事務，附帶的結果就是編程簡潔清晰。

C. 動態代理的經常使用方式一( 基於接口的動態代理 )：

a) 原理：

提供者：jdk( Proxy類 ) 要求：被代理類至少要實現一個接口

b) 實現( 以劇組-經紀人-演員舉例來實現 )：

前提條件：

有演員的接口：其中有baseAct，difficultyAct等抽象方法

有一個演員的類，實現了演員的接口，將抽象方法一一實現了

建立經紀人的具體步驟：

//建立演員對象，沒有演員就沒有經紀人，並使用final修飾

final Actor actor = new ActionActor();

/*建立經紀人代理對象：

涉及到的類：Proxy

涉及到的方法：newProxyInstance()

涉及到的參數：

Classloader：類加載器。與被代理類使用相同的類加載器。固定寫法

Interfaces：實現的接口列表。與被代理類實現相同的接口列表。固定寫法

InvocationHandler：如何代理。這裏是實現加強功能的地方

Actor actorProxy = (Actor) Proxy.newProxyInstance(

actor.getClass().getClassLoader(),

actor.getClass().getInterfaces(),

new InvocationHandler(){

/**

*方法：invoke()

* 參數：

* proxy：代理對象引用。通常用不到

* method：當前執行的方法對象

* args：當前執行方法的參數

public Object invoke(Object proxy, Method method, Object[] args) throws

Throwable {

//執行對演員的代理，即判斷該添加是否能夠執行演員內的方法

//若是能夠經過，就使用方法執行演員對象的方法

String methodName = method.getName(); //獲取操做的方法名稱

Float money = (Float) args[0]; //對每一個參數進行解析

//經過反射使用傳進來的方法對象執行actor演員對象中的該方法(並將參數傳入)，並將結果返回

return method.invoke(actor, money * 4 / 5);

}

);

//此時能夠直接使用經濟人的對象執行接口actor中的方法

actorProxy.baseAct(5000f);

D. 動態代理的經常使用方式二( 基於子類的動態代理 )：

a) 原理：

提供者：第三方cglib 要求：被代理類不能是最終類（即便用final修飾的類）

c) 實現( 以劇組-經紀人-演員舉例來實現 )：

前提條件：

配置pom.xml，進入cglib依賴包

跟經常使用方式一相似，建立相應的接口和類

建立經紀人的具體步驟：

//建立演員類的對象，並使用final修飾

final ArtActor actor = new ArtActor();

/**

* 建立代理對象：

* 涉及到的類：Enhancer

* 涉及到的方法：create()

* 涉及到的參數：

* Class：被代理類字節碼。固定寫法

* Callback：如何代理。這裏是實現加強功能的地方。至關於InvocationHandler

ArtActor actorProxy = (ArtActor) Enhancer.create(

actor.getClass(),

new MethodInterceptor() {

/**

*方法：intercept()

* 參數：

* proxy：代理對應引用。通常用不到

* method：當前執行的方法對象

* args：當前執行方法的參數列表

* methodProxy：當前執行方法的對象代理引用。通常用不到

public Object intercept(Object proxy, Method method, Object[] args,

MethodProxy methodProxy) throws Throwable {

跟經常使用方式一相似，對演員對象進行代理，並將使用反射執行演員對象的方法的結果返回

}

});

30.5. spring的AOP( 基於xml方式配置AOP )

A. AOP的概述：

a) AOP是什麼：

AOP（Aspect Oriented Programming），即面向切面編程。經過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟件系統開發中的一個熱點，也是spring框架的一個重點。利用AOP能夠實現業務邏輯各個部分的隔離，從而使得業務邏輯各個部分的耦合性下降，提升程序的可重用性，同時提升開發效率。

一句話歸納：aop是面向切面編程，是使用動態代理技術，實如今不修改java源代碼的狀況下，運行時實現方法功能的加強。

aop的具體應用：

b) AOP的做用及優點：

做用：在程序運行期間，不修改源代碼對已有方法功能進行加強

優點：減小重複代碼提升開發效率統一管理統一調用方便維護

c) AOP經常使用術語( 術語詳解請看下面內容 )：

Joinpoint（鏈接點）：在spring中，鏈接點指的都是方法（指的是那些要被加強功能的候選方法），spring

只支持方法類型的鏈接點。

Pointcut（切入點）：在運行時已經被spring 的AOP實現了加強的方法。

Advice（通知）：通知指的是攔截到Joinpoint以後要作的事情。即加強的功能。通知類型：前置通知/後置通知/異常通知/最終通知/環繞通知。

Target（目標對象）：被代理的對象。好比動態代理案例中的演員。

Weaving（織入）：織入指的是把加強用於目標對象，建立代理對象的過程。spring採用動態代理織入，

AspectJ採用編譯期織入和類裝載期織入

Proxy（代理）：一個類被AOP織入加強後，即產生一個結果代理類。好比動態代理案例中的經紀人。

Aspect（切面）：切面指的是切入點和通知的結合。

d) 學習spring AOP須要明確的事情：

l 開發階段：

編寫核心業務代碼，須要熟悉業務需求；

把公用代碼抽取出來，製做成通知；

在配置文件中，配置切入點與通知的關係

l 運行階段：

spring框架監控切入點方法執行。一旦監控到切入點方法被執行，使用動態代理機制，建立目標對象的代理對象，根據通知類型，在代理對象當前執行方法的對應位置，織入通知功能，完成完整的代碼邏輯執行。

B. 基於xml的AOP配置( 基本配置 )：

a) 配置pom.xml文件，進入依賴包：

spring基礎開發包：beans，context，core，expression，logging，log4j等

springaop開發jar包：aopalliance，aop，aspects，aspectjweaver等

b) 編寫核心業務代碼；

c) 編寫公用代碼，將其製做成通知類和通知方法；

d) 編寫spring配置文件bean.xml：

第一步：導入aop名稱空間：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

第二步：使用aop:config聲明aop配置

第三步：使用aop:aspect配置切面

第四步：使用aop:before配置前置通知

第五步：使用aop:pointcut配置切入點表達式

<aop:config>

<!--第三步：使用aop:aspect配置切面，說明：

id：給切面取一個惟一標識名稱 ref：引用通知類對象bean的名稱 -->

<aop:aspect id="logAspect" ref="logger">

<!--第四步：使用aop:before配置前置通知，說明：

method：指定通知中的方法名稱 pointcut-ref：引用切入點表達式id -->

<aop:before method="printLog" pointcut-ref="pt1"></aop:before>

<!--第五步：使用aop:pointcut配置切入點表達式，說明：

id：給切入點表達式取一個惟一標識名稱 expression：配置切入點表達式 -->

<aop:pointcut id="pt1" expression="execution(public void

cn.itheima.service.impl.CustomerServiceImpl.saveCustomer())"/>

</aop:aspect>

</aop:config>

C. 切入點表達式演化 ( 格式：訪問修飾符 返回值 包名稱 類名稱 方法名稱 (參數列表) )：

l 全匹配方式：public void cn.itheima.service.impl.CustomerServiceImpl.saveCustomer()

l 訪問修飾符能夠省略：void cn.itheima.service.impl.CustomerServiceImpl.saveCustomer()

l 返回值能夠使用通配符*：* cn.itheima.service.impl.CustomerServiceImpl.saveCustomer()

l 包名稱能夠使用通配符，有多少級包就寫多少個：* *.*.*.*.CustomerServiceImpl.saveCustomer()

l 包名稱能夠使用..表示當前包和子包：* *..CustomerServiceImpl.saveCustomer()

l 類名稱能夠使用通配符*：* *..*.saveCustomer()

l 方法名稱能夠使用通配符*：* *..*.*()

l 參數列表能夠使用通配符*，此時必需要有參數：* *..*.*(*)

l 參數列表能夠使用..，有無參數都可：* *..*.*(..)

l 實際項目中的配置案例：* cn.itheima.service..*.*(..)

D. AOP經常使用標籤說明：

l aop:config：做用：用於聲明aop配置

l aop:aspect：做用：用於配置切面

屬性：id：配置切面的惟一標識名稱 ref：引用通知類bean的id

l aop:pointcut：做用：用於配置切入點表達式

屬性：id：配置切入點表達式惟一標識名稱 expression：定義切入點表達式

l aop:before：做用：用於配置前置通知

屬性：method：指定通知方法的名稱 pointcut：定義切入點表達式 pointcut-ref：引用切入點表達式

l aop:after-returning ：做用：用於配置後置通知屬性同上

l aop:after-throwing：做用：用於配置異常通知屬性同上

l aop:after：做用：用於配置最終通知屬性同上

l aop:around：做用：用於配置環繞通知屬性同上

E. 通知類型：

a) 通知類型模板以下：

<aop:after-throwing method="afterThrowingLog" pointcut-ref="pt1"></aop:after-throwing>

b) 不一樣通知類型執行機制說明：

前置通知：在切入點方法執行前執行。

後置通知：在切入點方法正常執行以後執行。它和異常通知只能執行一個。

異常通知：在切入點方法發生異常後執行。它和後置通知只能執行一個。

最終通知：不管切入點方法執行是否發生異常。它老是能夠執行。

c) 環繞通知：

說明：它是spring框架，爲咱們提供的一種手動控制通知執行時間點的機制。使用起來更加靈活。

原理分析：spring框架，爲環繞通知提供了ProceedingJoinPoint接口，做爲環繞通知方法的形參。在執行環繞通知的時候，提供實例化對象，咱們直接使用便可。該對象有一個proceed()方法，至關於 method.invoke()方法。

例：

public void aroundLog(ProceedingJoinPoint pjp){

try {

System.out.println("【環繞通知中-前置通知】記錄日誌。");

pjp.proceed(); //調用目標方法

System.out.println("【環繞通知中-後置通知】記錄日誌。");

} catch (Throwable throwable) {

throwable.printStackTrace();

System.out.println("【環繞通知中-異常通知】記錄日誌。");

}

System.out.println("【環繞通知中-最終通知】記錄日誌。");

}

30.6. spring的AOP( 基於註解的AOP配置 )

A. 改造bean.xml文件，配置註解掃描包;

B. 啓用spring對註解aop的支持:

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

C. 改造各個類，使用註解配置：

l @Aspect：做用：聲明當前類爲切面類。至關於bean.xml文件中aop:aspect標籤配置。

l @Before：做用：配置前置通知例：@Before("pt1()")

l @AfterReturning：做用：配置後置通知

l @AfterThrowing：做用：配置異常通知

l @After：做用：配置最終通知

l @Around：做用：配置環繞通知

l @Pointcut：做用：配置切入點表達式

@Pointcut("execution(* cn.itheima.service..*.*(..))")

public void pt1(){}

30.7. spring中的JdbcTemplate

A. JdbcTemplate概述：

它是spring框架中提供的一個持久層操做對象，是對jdbc API的封裝。以下爲持久層總圖：

JdbcTemplate在spring-jdbc-xxx.RELEASE.jar包中（xxx是具體的版本號）。在使用JdbcTemplate時，除了導入spring-jdbc-xxx.RELEASE.jar包之外，還須要導入一個spring-tx-xxx.RELASE.jar包。它們是配套使用的。

B. JdbcTemplate入門案例：

a) 建立帳號表：在數據庫中建立須要使用的表；

b) 建立項目，配置pom.xml文件，進入所需的依賴：

spring中的包：beans包，core包，context包，expression包，spring-jdbc包，

其餘包：mysql包，log4j包，org.slf4j包等

c) 編寫bean.xml文件：

把JdbcTemplate和DriverManagerDataSource對象配置到bean.xml文件中，讓spring容器管理起來。

配置spring內置的數據源對象，需進入數據庫鏈接必需的四個條件。

d) 編寫測試代碼：

// 1.加載bean.xml文件，建立spring容器

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean.xml");

// 2.獲取jdbcTemplate對象

JdbcTemplate jt = (JdbcTemplate) context.getBean("jt");

// 3.向帳戶表中新增記錄

jt.update("insert into account(name,money) values('大楊',3000)");

C. JdbcTemplate實現CRUD操做：

a) 不管使用哪種持久化技術，要對數據庫表進行操做，咱們首先都須要創建表的實體類對象。

b) 在進行查詢時，JdbcTemplate與RunnerQuery的查詢不一樣，以下代碼所示：

List<Account> list = jt.query("select * from account", new RowMapper<Account>() {

/** 結果集映射方法，對應查詢結果集中每一條記錄，都會調用執行一次

* 參數： rs：結果集 rowNum：結果集記錄索引 */

public Account mapRow(ResultSet rs, int rowNum) throws SQLException {

// 建立Account對象，並將結果集中查到數據賦值到Account中，會返回該Account對象

Account account = new Account();

account.setId(rs.getInt("id")); account.setName(rs.getString("name"));

return account;

}

});

30.8. spring中的事務控制

A. 事務的定義和特性：

a) 事務的定義：

事務（transaction），通常是指要作的或者所作的事情。在程序中，尤爲是在操做數據庫的程序中，指的是訪問而且可能更新數據庫中數據項的一個執行單元（unit），這個執行單元由事務開始（begin transaction）和事務結束（end transaction）之間執行的所有操做組成。

b) 事務的特性( ACID原則 )：

l 原子性（atomicity）：一個事務是一個不可再分割的工做單位（最小單位），事務中的所有操做要麼都作，要麼都不作。

l 一致性（consistency）：事務必須是使得數據庫狀態從一個一致性狀態，轉變到另一個一致性狀態。也就是說在事務前，和事務後，被操做的目標資源狀態一致。好比銀行轉帳案例中，轉帳前和轉帳後，總帳不變。

l 隔離性（isolation）：一個事務的執行不能被其餘事務的影響。即一個事務內部的操做及使用的數據對併發的其餘事務是隔離的，多個併發事務之間不能相互干擾。

l 持久性（durability）：一個事務一旦提交，它對數據庫中數據的改變會永久存儲起來。其餘操做不會對它產生影響。

B. spring事務控制中須要明確的事項：

第一：j2EE體系中項目按照分層進行設計開發，有表現層、業務層、持久層。事務處理位於業務層。Spring 提供了分層設計業務層的事務處理解決方案。

第二：spring框架爲咱們提供了一組事務控制接口，該組接口位於spring-tx-xxx.RELEASE.jar包中。具體咱們

在後面的內容中詳細介紹。

第三：spring的事務都是基於AOP的實現，它既能夠使用編程的方式實現，也能夠使用配置的方式實現。我們這裏重點是使用配置的方式來實現。

C. spring中事務控制API介紹：

a) PlatformTransactionManager：

l 說明：它是一個接口，是spring的事務管理器核心接口，spring並不實現具體的事務，而是負責包裝底層事務，提供規範。應用底層支持什麼樣的事務策略，spring就支持什麼樣的事務策略。該接口提供了咱們操做事務的經常使用方法。

l 此接口中的經常使用方法以下：

提交事務：void commit( TransactionStatus status )

回滾事務：void rollback( TransactionStatus status )

獲取事務狀態信息：TransactionStatus getransaction( TransactionDefinition definition )

l 咱們在開發中都是直接使用它的實現類( 有不一樣的實現類，咱們通常使用以下類 )：

DataSourceTransactionManager：使用jdbc或者mybatis框架進行數據持久化時使用。

b) TransactionDefinition：

l 說明：它是一個接口，是定義事務的信息對象；

l 此接口經過了以下方法：

獲取事務對象名稱：String getName()

獲取事務隔離級別：int getIsolationLevel()

獲取事務傳播行爲：int getPropagationBehavior()

獲取事務超時時間：int getTimeout()

以秒爲單位進行設置。若是設置爲-1（默認值），表示沒有超時限制。在企業項目中使用默認值便可。

獲取事務是否只讀：boolean isReadOnly()

只讀事務比讀寫事務性能要高，實際項目中，查詢通常建議設置爲只讀。

l 事務隔離級別( 事務隔離級別反應了事務在併發訪問時的處理態度 )：

ISOLATION_DEFAULT：默認級別，歸屬於下列某一種隔離級別。在項目中使用默認值便可。

ISOLATION_READ_UNCOMMITTED：能夠讀取其餘事務未提交的數據（髒讀）

ISOLATION_READ_COMMITTED：只能讀取其餘事務已提交的數據，解決髒讀的問題(oracle默認級別)

ISOLATION_REPEATABLE_READ：是否讀取其餘事務提交修改後的數據，解決不可重複讀的問題mysql

ISOLATION_SERIALIZABLE：是否讀取其餘事務添加後的數據，解決幻影讀的問題

注意：事務級別從低到高：髒讀->不可重複讀->可重複讀->解決幻讀

事務級別越高，消耗的資源越多，數據庫操做性能越低

在企業項目中，使用哪種級別的事務，須要根據業務需求來肯定

l 事務傳播行爲：

REQUIRED:若是已經有事務，就加入該事務中執行；若是沒有事務，則新建一個事務。對應增/刪/改操做通常的選擇（默認值）。

SUPPORTS：若是已經有事務，支持當前事務的執行；若是沒有事務，就以非事務的方式執行。對應查詢操做通常的選擇。

c) TransactionStatus：

l 說明：它是一個接口，提供了事務具體的執行狀態，描述了某一個時間點上事務對象的狀態信息。

l 提供了以下經常使用方法：

刷新事務： void flush();

獲取是否有存儲點： boolean hasSavepoint();

事務是否完成： boolean isCompleted();

是不是一個新的事務：boolean isNewTransaction();

事務是否回滾： boolean isRollbackOnly();

設置事務回滾： void setRollbackOnly()

D. 基於xml的聲明式事務配置：

a) 配置pom.xml，加入依賴包( 須要導入aop開發相關的jar包 )

b) 在bean.xml文件中導入aop和tx名稱空間

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd">

c) 完整配置：

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

<aop:config>

<aop:pointcut id="pt1"

expression="execution(* cn.itheima.service..*.*(..))"></aop:pointcut>

<aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>

</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<!--tx:method標籤：配置業務方法的名稱規則，說明：

name：方法名稱規則，能夠使用通配符*

isolation：事務隔離級別，使用默認值便可

propagation：事務傳播行爲，增/刪/改方法使用REQUIRED。查詢方法使用SUPPORTS。

read-only：是否只讀事務。增/刪/改方法使用false。查詢方法使用true。

timeout：配置事務超時。使用默認值-1便可。永不超時。

rollback-for：發生某種異常時，回滾；發生其它異常不回滾。沒有默認值，任何異常都回滾

no-rollback-for：發生某種異常時不回滾；發生其它異常時回滾。沒有默認值，任何異常都回滾。

-->

<tx:method name="transfer*" propagation="REQUIRED" read-only="false"/>

</tx:attributes>

</tx:advice>

E. 基於註解和xml的事務配置：

a) 配置pom.xml，加入依賴包( 須要導入aop開發相關的jar包 );

b) 導入必要的名稱空間，如上述所示；

c) 改造dao和service中的類，使用註解配置該類；

d) 繼續改造service中的類，使用@Transactional註解配置事務

在完成事務的方法上加入以下注釋：

@Transactional(propagation=Propagation.REQUIRED,readOnly=false)

e) 配置bean.xml文件

配置掃描包，將全部的類的對象加入spring容器中；

刪除aop的配置，只保留事務管理器便可

開啓spring對註解事務的支持

f) @Transaction註解特別說明：

@Transactional註解和xml中屬性含義一致。該註解能夠出如今接口上、類上、方法上

出如今接口上，表面該接口的全部實現類都有事務支持

出如今類上，表示類中全部方法都有事務支持

出如今方法上，代表該方法有事務支持

三者同時出現，優先級爲：方法>類>接口

31. springMVC

31.1. springMVC入門程序

1. 準備環境：

Jdk 1.8版本以上，idea開發軟件201732版本以上，web容器tomcat7以上

2. 建立項目：建立好maven web項目便可

3. 配置pom.xml文件：

(1) 加入以下依賴包：

spring基礎包：spring-core，spring-beans，spring-context，spring-expression

spring-aop包：spring-aop，spring-aspects

spring數據庫事務包：spring-tx，spring-jdbc

springMVC包：spring-webmvc(核心包)，spring-web

spring其餘包：spring-context-support

jsp的包：jstl

(2) 配置Tomcat插件

<groupId>org.apache.tomcat.maven</groupId>

<artifactId>tomcat7-maven-plugin</artifactId>

<path>/springmvc-first</path>

<server>tomcat7</server>

</configuration>

</plugin>

4. 準備配置文件springmvc.xml：這是springmvc的主配置文件，名字能夠修改，內容跟spring的配置文件相似

5. 配置web.xml:

(1) 請注意：使用maven項目生成的web.xml是2.3，爲了更方便使用，需改爲2.5版本：

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

(2) 配置一個核心控制器（前端控制器）：DispatcherServlet

這是springmvc框架提供的一個servlet。用於接收從瀏覽器發送的請求。會直接將該請求轉入後端控制器。

<servlet-name>springmvc-first</servlet-name> //取名，通常爲項目名，每一個項目中一個

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:springmvc.xml</param-value>

</init-param>

<load-on-startup>1</load-on-startup> //配置何時加載此控制器，通常服務器啓動時就加載

</servlet>

<servlet-mapping></servlet-mapping> //配置此控制器的映射文件，通常爲/，全部的請求都要

6. 編寫controller控制器( 後端控制器 )：

此控制器跟web項目中的servlet同樣，只需在類名上方加上@controller註釋便可，在配置文件中配置包掃描

@RequestMapping("/hello.do") //請求的url

public ModelAndView hello(){

建立ModelAndView，在該對象中進入須要的值，設置須要響應的視圖名稱

return mav;

}

31.2. springMVC三大組件和spring框架原理：

1. 三大組件：

處理器映射器（HandlerMapping）：根據請求的url，查找處理器（處理器方法）。

處理器適配器（HandlerAdapter）：執行處理器方法。

視圖解析器（ViewResolver）：把邏輯視圖（在處理器controller中設置的視圖名稱）解析成物理視圖（在瀏覽器實際看到的頁面）。

2. 三大組件的配置：

<mvc:annotation-driven/>：等於同時配置了RequestMappingHandlerMapping/RequestMappingHandlerAdapter；

</bean>

3. spring框架原理：

31.3. springmvc中的小知識點

1. 默認支持的參數類型

(1) HttpServletRequest：經過request對象，獲取請求域的參數數據。

(2) HttpServletResponse：經過response對象，響應。

(3) HttpSession：經過session對象，操做會話域中的數據。

(4) Model/ModelMap：

Model是一個接口，是模型，用於設置響應的模型數據。ModelMap是一個實現類，使用Model和使用ModelMap是同樣的。若是使用Model，springmvc會實例化成ModelMap。使用Model響應模型數據，就能夠不使用ModelAndView，視圖能夠使用字符串String響應。

2. 簡單參數類型：

(1) Integer：能夠在方法形參上使用Integer接收商品id等Integer類型的數據

注意：使用簡單類型接收請求的參數數據，推薦使用簡單類型的包裝類型（Integer），不建議使用簡單類型

的基礎類型（int）。緣由是基礎類型不能爲null，若是不傳遞會報異常。

(2) 經常使用的簡單類型：

類型	包裝類型	基礎類型
長整形	Long	long
整形	Integer	int
單精度浮點型	Float	float
雙精度浮點型	Double	double
字符串	String	String

(3) @RequestParam註解：

做用：設置請求的參數名稱，與方法的形參名稱匹配。

示例：public String queryItemById(Model model,@RequestParam(value="itemId",required = true,

defaultValue = "2")Integer id){方法體}

屬性：value屬性：設置請求的參數名稱；

required屬性：設置參數是否必需要傳遞。true要傳遞；false：能夠傳也能夠不傳。默認true

defaultValue屬性：設置參數的默認值。若是傳遞參數，使用實際的參數值；若是不傳遞，使用默認值

(4) pojo參數和pojo包裝參數類型：

當前端頁面需進行修改商品等需傳入較多數據到後臺的操做時，能夠是使用此參數類型；

例：public String updateItem(Item item){} Item爲pojo類型；

若有須要是能夠將Item做爲另外一個類的成員變量，此時使用了pojo包裝參數類型；

(5) 自定義參數類型：

a. 說明：自定義參數類型解決的問題，好比日期類型的數據，格式多，須要根據業務需求來肯定。

b. 步驟：

第一步：自定義轉換器；實現org.springframework.core.convert.converter.Converter接口

此接口中有2個參數Converter<S, T>：

S,Source，源，轉換以前的數據，這裏是字符串String類型的商品生產日期；

T,Target，目標，轉換以後的數據，這裏是Date類型的商品生產日期；

第二步：在springmvc.xml中，配置自定義轉換器：

<mvc:annotation-driven conversion-service="conversionService"/>

<bean id="conversionService"class="org.springframework.format.

support.FormattingConversionServiceFactoryBean">

</property>

</bean>

3. 高級參數類型：

(1) 數組參數類型：

在controller的方法中，能夠放置一個數組類型的參數，用來接收從前端頁面傳來的數組

例：public ModelAndView queryItem(QueryVo queryVo,Integer[] ids)

ids：接收請求的多個商品Id，演示數組參數綁定

(2) list參數類型：

使用list集合參數類型綁定，list須要做爲pojo的屬性。不能直接在方法形參中使用list，不然不能完成綁定。

4. @RequestMapping註解：

(1) 做用一：配置請求的url：@RequestMapping(value={"queryItem"})

value：是一個數組，能夠配置多個請求的url，這些url請求都可以訪問此資源；

(2) 做用二：限制http請求方法：

@RequestMapping(value={"queryItem"},method={RequestMethod.POST,RequestMethod.GET})

method：是一個數組，配置容許的http方法：

method={RequestMethod.POST}：只容許post請求

method={RequestMethod.POST,RequestMethod.GET}：只容許post/get請求

(3) 做用三：在類上面使用，對請求的url進行分類管理：

例：@RequestMapping(「item」)

5. Controller方法返回值：

(1) 返回ModelAndView：返回響應的模型數據，返回響應的視圖。

須要在方法中建立ModelAndView視圖對象，並使用setViewName方法設置響應的視圖的地址。

(2) 返回void：使用Request和Response響應。

須要在形參上設置HttpServletRequest request,HttpServletResponse response屬性，並經過轉發和重定向才能實現頁面的跳轉。

(3) 返回String：返回響應的視圖( 經過返回目標視圖的字符串地址，從而跳轉到該位置 )

forward轉發：forward+":"+目標url；例：return "forward:queryItem.do";

redirect重定向：redirect+":"+目標url；return "redirect:queryItem.do";

6. 異常處理：

(1) 異常介紹：異常，就是不正常。異常能夠分類爲預期的異常和運行時異常。預期的異常能夠經過捕獲（try...catch...）進行處理。運行時的異常只能經過規範代碼的編寫，增長測試來減小。

(2) 處理思路：

請求處理流程：客戶端（瀏覽器）->前端控制器（DispatcherServlet）->表現層（controller）->業務

層（service）->持久層（dao）。

異常處理思路：從dao開始，每一層發生異常都向上一層拋出，一直拋到前端控制器，前端控制器不能再拋出，前端控制器須要請求異常處理器來包裝異常。返回一個友好的異常提示頁面。

(3) 自定義異常處理：

第一步：自定義異常類，需繼承Exception類。

第二步：自定義異常處理器：須要實現接口（HandlerExceptionResolver）。

第三步：編寫異常界面，即錯誤友好界面，若是出現異常就跳轉到此頁面。

第四步：在springmvc.xml文件中配置異常處理器( bean class=」自定義的異常類的全路徑名稱」/> )

7. 文件上傳：

(1) 配置pom.xml文件，加入文件上傳的依賴包：

commons-fileupload.jar commons-io.jar commons-codec.jar

(2) 在springmvc.xml文件中配置文件上傳解析器：

<!-- 配置文件上傳解析器 ,框架提供了文件上傳解析器接口：MultipartResolver

細節：文件上傳解析器的id屬性值，必須是文件上傳解析器接口的名稱的首字母小寫（multipartResolver）-->

<bean id="multipartResolver"

class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

</bean>

(3) 編輯jsp頁面，支持文件上傳：

實現文件上傳提交表單，表單中必需要設置屬性（enctype="multipart/form-data"）

(4) 圖片上傳的controller代碼實現：

public String updateItem(Item item,MultipartFile pictureFile){

if(pictureFile != null && pictureFile.getOriginalFilename() !=null){

// 1.獲取上傳文件的名稱

String oriName = pictureFile.getOriginalFilename();

String extName = oriName.substring(oriName.lastIndexOf("."));

// 2.從新命名文件名稱

String newName = System.currentTimeMillis()+"";

newName = newName+extName;

// 3.上傳文件

File dest =

new File("圖片存放地址"+newName);

try {

pictureFile.transferTo(dest);

} catch (Exception e) {

e.printStackTrace();

}

// 4.保存上傳文件的名稱

item.setPic(newName);

}

return "具體視圖地址";

}

請注意：若是實現上傳商品等操做時，能夠先實現圖片上傳，再實現將商品信息存入數據庫的操做，若是出現異常就中止執行。如此能夠將商品圖片順利上傳到服務器。

8. json數據交互：

(1) 配置pom.xml文件，加入jackson依賴包：

jackson-databind jackson-core jackson-annotations

(2) 配置springmvc.xml配置文件：

<mvc:annotation-driven />默認就支持jackson的數據轉換。不須要再作額外的配置。

(3) 在controller中使用@RequestBody註解和@ResponseBody註解：

說明：在處理器方法的形參上使用，把請求的json格式的數據，轉換成java對象。

說明：在處理器方法返回值上，或者方法上使用。把響應的java對象，轉換成json格式的數據。

例：/**請求商品格式的json數據->使用商品pojo接收參數->響應商品對象->轉換回json格式的數據*/

@RequestMapping("/testJson.do")

@ResponseBody

public Item testJson(@RequestBody Item item){

return item;

}

9. restful支持：

10. 攔截器：

(1) 攔截器介紹：在springmvc框架中提供了攔截器，它至關於servlet中的過濾器（filter），過濾器能夠用於實現前置加強和後置加強。這裏攔截器也是用於實現前置加強和後置加強。能夠對處理器方法執行預處理（在處理器方法執行前執行）；也能夠對處理器方法執行後處理（在處理器方法執行後執行）。

(2) 自定義攔截器( 至關於JavaWeb中的filter過濾器 )：

第一步：自定義攔截器(類)需實現HandlerInterceptor接口；並實現接口中的3個方法。

第二步：在springmvc.xml中，配置攔截器。

<mvc:interceptors>

<mvc:interceptor>

<!-- 配置攔截器的url規則，說明：

1.攔截單個url：/interceptor.do，表示攔截請求：/interceptor.do

2.攔截多個url：/inter/**，表示攔截以/inter開始的全部請求 -->

<mvc:mapping path="/interceptor.do"/>

</mvc:interceptor>

</mvc:interceptors>

(3) 攔截器執行結果說明：

當preHandle方法返回true時：

執行攔截器的preHandle方法

執行處理器的testInterceptor方法

執行攔截器的postHandle方法

響應jsp頁面

執行攔截器的afterCompletion方法

當preHandle方法返回false時：

只執行了攔截器preHandle方法。終止執行。

(4) 攔截器方法做用說明：

preHandle：

l preHandle方法，在處理器方法執行前執行，在響應jsp頁面前執行。是對處理器方法執行預處理。

l 該方法返回布爾類型的值。返回true繼續執行；返回false終止執行。

l 在實際項目中，適合於在該方法實現檢查用戶是否登陸、是否有資源操做的權限等業務邏輯處理。

postHandle：

l postHandle方法，在處理器方法執行後執行，在響應jsp頁面前執行。是對處理器方法執行後處理。

l 該方法中提供了ModelAndView參數對象，能夠設置響應的模型數據。

l 在實際項目中，適合於在該方法實現公共模型數據的設置。好比頁面頭部的歡迎信息、頁面尾部的友情連接、備案、免責聲明等信息。

afterCompletion：

l afterCompletion方法，在處理器方法執行後執行，在響應jsp頁面後執行。是對處理器方法執行後處理。

l 該方法的特色是隻要當前攔截器preHandle方法返回true，就能夠獲得執行。

l 在實際項目中，適合於在該方法實現用戶訪問操做日誌的記錄。

(5) 配置多個攔截器時各個方法的執行順序：

所有符合true時：

攔截器preHandle方法按照配置的順序執行

攔截器postHandle方法按照配置的逆序執行

攔截器afterCompletion方法按照配置的逆序執行

攔截器一返回true、攔截器二返回false測試：

攔截器afterCompletion方法，只要當前攔截器返回true，就能夠獲得執行。

32. springmvc+spring+mybatis整合

1. 整合思路：

springmvc是表現層框架，mybatis是持久層框架、spring是整合層的框架。在咱們前邊學習的spring框架

中，它的IOC容器用於建立對象和管理對象。所以整合的思路即：把springmvc、mybatis框架的對象，交給spring

管理。

2. 項目分層：

(1) 表現層，springmvc( controller )：把表現層的對象交給spring管理，在表現層中能夠調用業務成的對象；

(2) 業務層，service：把業務層的對象交給spring管理起來，事務也管理起來。在業務層中調用持久層對象；

(3) 持久層，mybatis( mapper )：把持久層的對象，交給spring管理起來，完成數據庫的CRUD操做；

3. 建立項目，配置pom.xml文件，加入依賴：

mybatis框架包，spring框架包(包括springmvc)，mybatis-spring整合包，數據庫驅動包，

數據庫鏈接池包(dbcp)，jstl標籤庫包，log4j日誌包

4. 準備配置文件(配置文件是框架的核心)：

(1) sqlMapConfig.xml配置文件：

這是myBatis的核心配置文件，由於spring框架接管了myBatis的不少內容，故在此配置文件中只需配置別名

</typeAliases>

(2) springmvc.xml

l 配置包掃描controller：

<context:component-scan base-package="cn.itheima.ssm.controller"/>

l 配置處理器映射器和處理器適配器：

<mvc:annotation-driven/>

l 配置視圖解析器：

</bean>

(3) applicationContext-dao.xml

l 配置數據源對象（DataSource）：

<context:property-placeholder location="classpath:db.properties"/>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

</bean>

l 配置mybatis框架核心對象（SqlSessionFactory）：

</bean>

l 配置mapper掃描器（MapperScannerConfigurer）：

<!-- 配置要掃描的包，說明：

1.若是有多個包，在同一個父包下，配置父包便可

2.若是不在同一個父包下，以半角逗號進行分割 -->

</bean>

(4) applicationContext-service.xml

配置包掃描service：

<context:component-scan base-package="cn.itheima.ssm.service"/>

(5) applicationContext-trans.xml

l 配置事務管理器（transactionManager）：

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

l 配置通知（txAdvice）：

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="add*" propagation="REQUIRED"/>

<tx:method name="insert*" propagation="REQUIRED"/>

<tx:method name="save*" propagation="REQUIRED"/>

<tx:method name="update*" propagation="REQUIRED"/>

<tx:method name="delete*" propagation="REQUIRED"/>

<tx:method name="find*" propagation="SUPPORTS" read-only="true"/>

<tx:method name="select*" propagation="SUPPORTS" read-only="true"/>

<tx:method name="get*" propagation="SUPPORTS" read-only="true"/>

<tx:method name="query*" propagation="SUPPORTS" read-only="true"/>

</tx:attributes>

</tx:advice>

l 配置切面（aop:config）：

<aop:config>

<aop:advisor advice-ref="txAdvice"

pointcut="execution(* cn.itheima.ssm.service..*.*(..))"/>

</aop:config>

(6) db.properties和log4j.properties

5. 配置好web.xml：

(1) 配置spring提供的監聽器：

配置監聽器的目的是當web容器啓動，建立ServletContext對象的時候，自動建立spring的容器，而且

把spring容器放入ServletContext域中。

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:spring/applicationContext-*.xml</param-value>

</context-param>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

(2) 配置前端控制器：DispatcherServlet

<servlet-name>ssm01</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:spring/springmvc.xml</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>ssm01</servlet-name>

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

</servlet-mapping>

6. 進行項目整合：

(1) controller：

後端控制器，進行url的具體處理

(2) service：

業務邏輯層，進行具體的業務邏輯處理

(3) dao：

只須要建立對應接口便可，在resources的同一目錄下建立對應的同名映射文件

7. 總結：

第一步：準備基礎環境（編寫實體類對象、持久層對象、業務層對象）

第二步：確保spring框架獨立運行（導入jar包，準備配置文件：bean.xml）

第三步：確保springmvc框架獨立運行（導入spring-web和spring-webmvc包，準備主配置文件：springmvc.xml，配置一個前端控制器：DispatcherServlet）

第四步：整合spring和springmvc框架（ServletContextListener監聽ServletContext對象建立、配置ContextLoaderListener 繼承了ServletContextListener，幫助咱們建立spring容器，而且放入ServletContext中）

第五步：確保mybatis框架獨立運行（導入mybatis框架包、編寫主配置文件：sqlMapConfig.xml、編寫數據庫屬性文件db.properties、編寫log4j.properties文件、編寫mapper映射文件）

第六步：整合spring和mybatis框架（就是把mybatis框架的對象，交給spring管理起來：數據源對象、SqlSessionFactory、 mapper代理對象、事務也讓spring管理起來）

33. 框架的補充知識點

1. 解決不能加載靜態資源的問題：

當咱們進行框架整合後發現不能加載靜態資源文件( css/js )。緣由是咱們在web.xml文件中前端控制器的配置/，表示攔截全部請求，包括靜態資源加載的請求。springmvc的前端控制器它不能加載靜態資源的請求。靜態資源的加載須要交給默認的servlet處理器來處理，至關於給tomcat來處理。

此時需在springmvc.xml文件配置默認的servlet處理器，用來加載靜態資源。

<mvc:default-servlet-handler/>

2. 攔截url中 / 和 /* 區別:

/，攔截全部請求，包括動態請求（*.do），靜態資源（css/js/img）

/*，攔截全部請求，包括動態請求（.do），jsp頁面，靜態資源（css/js/img）

3. 在applicationContext-dao.xml中整合別名:

說明：此時從技術角度，能夠刪除sqlMapConfig.xml文件，可是在實際項目中建議保留它，這樣項目結構會更加

清晰方便維護。

4. 項目聲明週期：

需求提出-》可行性分析-》立項-》功能需求分析-》設計（數據庫設計、概要設計、詳細設計）-》編碼-》測試（單元測試、集成測試）-》上線運行。

5. log4j的介紹和使用：

(1) 導入log4j的jar包：log4j， slf4j-api， slf4j-log4j12；

(2) 配置log4j的配置文件：

# Set root logger

#DEBUG INFO WARN ERROR FATAL

log4j.rootLogger=DEBUG,stdout,A2

###################

# stdout Appender

###################

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Threshold=DEBUG

log4j.appender.stdout.Target=System.out

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d %-5p ~ %m%n

log4j.appender.A2=org.apache.log4j.RollingFileAppender

log4j.appender.A2.Threshold=INFO

log4j.appender.A2.File=E:/teach/0346/log/rollinglogfile.log

log4j.appender.A2.MaxFileSize=5KB

log4j.appender.A2.MaxBackupIndex=3

log4j.appender.A2.layout=org.apache.log4j.PatternLayout

log4j.appender.A2.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n

6. StringUtils工具類的使用：

(1) 導入jar包：commons-lang；

(2) StringUtils中一共有以下四個方法：

StringUtils.isNotBlank(str1) (自動去除空格) StringUtils.isNotEmpty(str1) (不會去除空格)

StringUtils.isBlank(str1) StringUtils.isEmpty(str1)

34. crawler(爬蟲)

1. 爬蟲基礎：

(1) 什麼是爬蟲：爬蟲，又叫網絡爬蟲，或者網絡蜘蛛。是一種運行在互聯網上用來獲取數據的自動化程序。

(2) 有哪些數據須要爬取：

能夠分爲內部數據和外部數據，主要注意內部數據中的用戶數據(不管是網站、仍是用戶註冊都會填寫郵箱、電話、身份證號碼等數據，這些數據其實很是有價值，此外還要加上用戶使用公司產品留下的行爲數據)。

(3) 爬蟲分類：

l 通用爬蟲：爬取全網的數據，百度、360、搜狗

l 垂直爬蟲：爬取單一網站的數據，爬取某個細分領域的數據。

l 學習的是垂直爬蟲。如今公司中基本上都是垂直爬蟲。

2. 如何開發爬蟲：

(1) 開發爬蟲的步驟：

第一步：指定一個新聞詳情頁面的地址(url)

第二步：模擬瀏覽器發起http請求(能夠使用serverSocket，HttpUrlConnection和第三方提供的HttpClient[推薦])

第三步：獲得網頁的二進制數據

第四步：把二進制數據轉換成字符串的數據

第五步：解析數據（字符串新聞數據）（使用jsoup框架操做Document對象）

第六步：持久化新聞數據（將數據保存到數據庫）

(2) DNS解析步驟：

l 第一次抓取：將一個種子URL存放到隊裏中

l 從隊列中讀取一個URL

l 發起網絡請求(上圖4-5-6步)

域名解析，獲得IP地址

發起HTTP請求

下載頁面

l 解析HTML文檔(上圖7-8-9步)

把當前URL放入（已抓取URL隊列中）

把當前網頁內容，保存到數據庫中

解析HMTL文檔獲取網頁中全部URL

判斷新解析出的URL是否已經抓取過

是，直接丟棄

否，把新的URL放入（待抓取URL隊列中）

(3) 爬蟲開發的兩個核心技術:

HttpClient：用於發送http請求 jsoup：用於解析html文檔

3. 使用第三方HttpClient發送GET&POST請求：

(1) 配置pom.xml文件，加入HttpClient依賴，httpclient；

(2) 建立HttpClient對象：CloseableHttpClient httpClient = HttpClients.createDefault();

(3) 建立HttpGet或Post對象：HttpGet get = new HttpGet("http://www.itheima.com");

(4) 設置請求頭信息：get.addHeader("User-Agent","Mozilla/5.0");

(5) 執行請求：CloseableHttpResponse response = httpClient.execute(get);

(6) 獲取網頁內容：HttpEntity entity = response.getEntity();

(7) 打印網頁內容：String html = EntityUtils.toString(entity,"utf-8"); System.out.println(html);

(8) 釋放：response.close();

增長內容：HttpClient中的流暢API使用，在pom.xml配置文件中，進入流暢api依賴，fluent-hc

String html = Request.Get("http://www.itheima.com").execute().returnContent().asString(Charset.forName("utf-8"));

4. 解析html文檔：

(1) html基礎知識回顧：

(2) 使用jsoup操做document對象：

jsoup是什麼：

jsoup 是一款Java 的html解析器，可直接解析某個URL地址、html文本內容。它提供了一套很是省力的API，可經過DOM，CSS以及相似於jQuery的操做方法來取出和操做數據。

jsoup核心功能：

輸入信息源：字符串，URL地址，文件；

提取數據：使用Document語法進行解析數據，使用選擇方式進行解析；

jsoup選擇器：

a) jsoup支持相似於CSS(或jquery)的選擇器語法，來實現很是強大和靈活的查找功能。這個select方法在Document,Element,或Elements對象中均可以使用。且是上下文相關的，所以可實現指定元素的過濾，或者鏈式選擇訪問。Select方法將返回一個Elements集合，並提供一組方法來抽取和處理結果。

b) Selector選擇器概述：

tagname：經過標籤查找元素，例如 a

ns|tag: 經過標籤在命名空間查找元素，好比：能夠用 fb|name 語法來查找元素

id：經過ID查找元素，例如 #logo

.class：按類名查找元素，例如 .masthead

[attribute] : 利用屬性查找元素，好比：[href]

[^attr]：帶有屬性名稱前綴的[^data-]元素

[attr=value]：具備屬性值的元素，例如[width=500]

[attr^=value]，[attr$=value]，[attr=value]：用與啓動，結束，或包含所述的值，例如元素[href=/path/]

[attr~=regex]：具備與正則表達式匹配的屬性值的元素; 例如img[src~=(?i).(png|jpe?g)]

*：全部元素

c) Selector選擇器組合使用：

el#id：帶ID的元素，例如 div#logo

el.class：有類的元素，例如 div.masthead

el[attr]：具備屬性的元素，例如 a[href]任何組合，例如 a[href].highlight

ancestor child：從祖先開始降低的子元素，例如，在具備類「body」的塊下.body p找到p元素

parent > child：直接從父項降低的子元素，例如div.content > p查找p元素; 並body > *找到身體標籤的直接子女

5. 1

35. Lucene(搜索)

36. solr(搜索)

1. solr介紹：

(1) solr是什麼：Solr是Apache下的一個頂級開源項目，基於Lucene的全文搜索服務，能夠獨立運行於Jetty，Tomcat等web容器中。

(2) 使用solr建立索引：客戶端能夠經過http的post方法向solr服務器發送一個描述Field及其內容的xml文檔，solr服務器根據xml文檔添加、更新、刪除索引。

(3) 使用solr搜索索引：客戶端能夠經過http的get方法向solr服務器發送請求，對solr服務器返回的xml、json格式結果進行解析。solr不提供構建頁面UI的功能。solr提供了一個管理界面，經過管理界面能夠查詢solr的配置和運行狀況。

2. lucene與solr區別：

Lucene是一個全文檢索工具包，提供了索引引擎和查詢引擎功能，不是一個完整的服務，不能獨立運行。Solr是基於Lucene構建的全文檢索服務，是一個完整的服務，能夠獨立運行於web容器中。基於Solr能夠快速構建企業級的搜索引擎。

3. solr安裝部署：

4. solrj使用：

(1) solrj介紹：solrj就是訪問服務的java客戶端程序，提供了索引和搜索請求的方法。solrj與solr的關係，就比如小海豚與mysql的關係。

(2) 使用solrj須要導入的jar包：

(3) 添加(更新)索引：

solr是根據id域（惟一約束）執行索引的添加。先根據id域搜索，搜索到執行更新；搜索不到執行添加。

//1.創建HttpSolrServer服務對象，鏈接solr服務

HttpSolrServer httpSolrServer = new HttpSolrServer("http://127.0.0.1:8081/solr/");

//2.創建文檔對象（SolrInputDocument）

SolrInputDocument sif = new SolrInputDocument();

sif.addField("id", "9527");

sif.addField("name", "solr is a good thing");

//3.使用HttpSolrServer對象，執行添加（更新）

httpSolrServer.add(sif);

//4.提交

httpSolrServer.commit();

(4) 根據Id刪除索引：

//1.創建HttpSolrServer服務對象，鏈接solr服務

HttpSolrServer httpSolrServer = new HttpSolrServer("http://127.0.0.1:8081/solr/");

//2.使用HttpSolrServer對象，執行刪除

httpSolrServer.deleteById("9527");

//3.提交

httpSolrServer.commit();

(5) 根據條件刪除索引：

//1.創建HttpSolrServer服務對象，鏈接solr服務

HttpSolrServer httpSolrServer = new HttpSolrServer("http://127.0.0.1:8081/solr/");

//2.使用HttpSolrServer對象，執行刪除

httpSolrServer.deleteByQuery("name:solr");

//3.提交

httpSolrServer.commit();

(6) 查詢索引：

//1.創建HttpSolrServer服務對象，鏈接solr服務

HttpSolrServer httpSolrServer = new HttpSolrServer("http://127.0.0.1:8081/solr/");

//2.創建查詢對象（SolrQuery）;查詢全部

SolrQuery sq = new SolrQuery("*:*");

//3.使用HttpSolrServer對象，執行搜索，返回搜索結果（QueryResponse）

QueryResponse query = httpSolrServer.query(sq);

//4.從QueryResponse中，獲取搜索的結果集（SolrDocumentList）

SolrDocumentList results = query.getResults();

//5.處理結果集

//5.1.獲取實際搜索到的數量

System.out.println("實際搜索到的數量:"+results.getNumFound());

//5.2.獲取具體的文檔數據

for (SolrDocument result : results) {

System.out.println("id域: "+result.get("id"));

System.out.println("name域: "+result.get("name"));

System.out.println("title域: "+result.get("title"));

}

(7)

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。