笔记整理自动力节点，B站尚硅谷JavaWeb视频，其中可能有记录内容不正确，望诸位指出

作者：Vison

1、HTML

1.1、标签

  标题标签
           
            h1 - h6 都是标题标签
            h1 最大
            h6 最小
                 align 属性是对齐属性
                   left		左对齐(默认)
                   center         剧中
                   right	  右对齐
           
            <h1 align="left">标题1</h1>
            <h2 align="center">标题2</h2>
            <h3 align="right">标题3</h3>
            <h4>标题4</h4>
            <h5>标题5</h5>
            <h6>标题6</h6>
            <h7>标题7</h7>

段落换行标签
      <p>段落标签</p>
      <br />换行标签
      
文本格式化标签
    <strong>加粗</strong> 
    <b>加粗</b>
    <em>倾斜</em>
    <i>倾斜</i>
    <del>删除线</del>
    <s>删除线</s>
    <ins>下划线</ins>
    <u>下划线</u>
 
<div>和<span>标签
    <div>独自占一行</div>     ---------->大盒子
    <span>跨距</span>	       ---------->小盒子
        
图像标签<img>
    <img src="图像URL" alt="图像显示不出来的时候用文字替换" title="鼠标放到图像上提示的文字" width="宽度（像素） " height="高度（像素）" border="边框厚度（像素）"/>

超链接标签
     a标签是 超链接
	 href属性设置连接的地址
	 target属性设置哪个目标进行跳转
	     _self		表示当前页面(默认值)
             _blank		表示打开新页面来进行跳转 
    <a href="地址" target="_blank">百度_blank</a><br/>

锚点链接
    <a href="#锚点">名字</a>
    <h1 id="锚点">
    
特殊标签
    
	需求1：把 <br> 换行标签 变成文本 转换成字符显示在页面上
	常用的特殊字符:
		===>>>>		&lt;
		===>>>>		&gt;
	  空格   ===>>>>	      &nbsp;

	我是标签<br/>
	Vison好帅啊!
  
表格标签
        table 是用于定义表格的标签
        tr标签用于定义表格中的行，嵌套在table标签中
        td用于定义表格中的单元格，必须嵌套在tr标签中
        字母td表示表格的数据(table data)，即数据单元格的内容
      表格中属性
       align(left,center,right)规定表格相对周围的元素对齐方式
       border(1或"")规定表格单元是否拥有边框，默认为""表示没有边框
       cellpadding(像素值)规定单元边沿与其内容之间的空白，默认1像素
       cellspacing(像素值)规定单元格之间的空白默认为2像素
       width(像素值或者百分比)规定表格的宽度

1.2、表单

表单域

表单域就是一个区域

    <form action="url" method="提交方式" name="表单域名称">
        各种表单元素控件
    </form>

属性	属性名	作用
action	url地址	用于指定接收并处理表单数据的服务器程序的url地址
method	get/post	用于设置表单数据的提交方式
name	名称	用于指定表单的名称，以区分同一个页面中的多个表单域

<!-- text 文本框 用户可以里面输入任何文字 -->
    用户名: <input type="text" name="username" value="请输入用户名" maxlength="6">   <br> 
<!-- password 密码框 用户看不见输入的密码 -->
    密码: <input type="password" name="pwd" >  <br> 
<!-- radio 单选按钮  可以实现多选一 -->
<!-- name 是表单元素名字 这里性别单选按钮必须有相同的名字name 才可以实现多选1 -->
<!-- 单选按钮和复选框可以设置checked 属性, 当页面打开的时候就可以默认选中这个按钮 -->
    性别: 男 <input type="radio" name="sex" value="男"> 女  <input type="radio" name="sex" value="女" checked="checked"> 人妖   <input type="radio" name="sex" value="人妖">   <br> 
<!-- checkbox 复选框  可以实现多选 -->
    爱好: 吃饭 <input type="checkbox" name="hobby" value="吃饭"> 睡觉 <input type="checkbox"name="hobby">  打豆豆 <input type="checkbox" name="hobby" checked="checked"> 
<br> 
<!-- 点击了提交按钮,可以把 表单域 form 里面的表单元素 里面的值 提交给后台服务器 -->
    <input type="submit" value="免费注册">
<!-- 重置按钮可以还原表单元素初始的默认状态 -->
    <input type="reset" value="重新填写">
<!-- 普通按钮 button  后期结合js 搭配使用-->
    <input type="button" value="获取短信验证码"> <br>
<!-- 文件域 使用场景 上传文件使用的 -->
    上传头像:  <input type="file" >

type属性的属性值及其描述如下

属性值	描述
button	定义可点击的按钮(多数情况下，用于通过javaScript启动脚本)
checkbox	定义复选框
file	定义输入字段和浏览字段，供文件上传
hidden	定义隐藏的输入字段
image	定义图像形式的提交按钮
password	定义密码字段，该字段中的字符被掩码
radio	定义单选按钮
reset	定义重置按钮，重置按钮会清楚表单中的所有数据
submit	定义提交按钮，提交按钮会把表单数据发送到服务器
text	定义单行的输入字段，用户可在其中输入文本，默认宽度为20个字符

属性	属性值	描述
name	由用户自定义	定义input元素的名称
value	由用户自定义	规定input元素的值
checked	checked	规定此input元素首次加载时应当被选中
maxlength	正整数	规定输入字段中的字符的最大长度

lable标签
为input元素定义标注
用于绑定一个表单元素，当点击label标签内的文本时，浏览器就会自动将焦点转到或者选择对应的表单元素上，用来增加用户体验

下拉列表

form
    select
        option
        option
        option
    select
 form

文本框 textarea 可以输入多行文本 cols=每行的字符数 rows=显示的行数

2、JavaScript

JavaScript 的变量类型：数值类型： number 字符串类型： string 对象类型： object 布尔类型： boolean 函数类型： function JavaScript 里特殊的值： undefined 未定义，所有 js 变量未赋于初始值的时候，默认值都是 undefined. null 空值 NaN 全称是：Not a Number。非数字。非数值JS 中的定义变量格式： var 变量名;var 变量名 = 值;

2.1、函数

2.2、事件

onload加载事件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
        function onclickFun() {
            alert("静态注册onclick事件");
        }

        // 动态注册onclick事件
        window.onload = function () {
            // 1 获取标签对象
            /*
            * document 是JavaScript语言提供的一个对象（文档）<br/>
            * get           获取
            * Element       元素（就是标签）
            * By            通过。。   由。。经。。。
            * Id            id属性
            *
            * getElementById通过id属性获取标签对象
            **/
            var btnObj = document.getElementById("btn01");
            // alert( btnObj );
            // 2 通过标签对象.事件名 = function(){}
            btnObj.onclick = function () {
                alert("动态注册的onclick事件");
            }
        }

    </script>
</head>
<body>
    <!--静态注册onClick事件-->
    <button onclick="onclickFun();">按钮1</button>
    <button id="btn01">按钮2</button>
</body>
</html>

lick单击事件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
        function onclickFun() {
            alert("静态注册onclick事件");
        }

        // 动态注册onclick事件
        window.onload = function () {
            // 1 获取标签对象
            /*
            * document 是JavaScript语言提供的一个对象（文档）<br/>
            * get           获取
            * Element       元素（就是标签）
            * By            通过。。   由。。经。。。
            * Id            id属性
            *
            * getElementById通过id属性获取标签对象
            **/
            var btnObj = document.getElementById("btn01");
            // alert( btnObj );
            // 2 通过标签对象.事件名 = function(){}
            btnObj.onclick = function () {
                alert("动态注册的onclick事件");
            }
        }

    </script>
</head>
<body>
    <!--静态注册onClick事件-->
    <button onclick="onclickFun();">按钮1</button>
    <button id="btn01">按钮2</button>
</body>
</html>

onblur失焦事件

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
        // 静态注册失去焦点事件
        function onblurFun() {
            // console是控制台对象，是由JavaScript语言提供，专门用来向浏览器的控制器打印输出， 用于测试使用
            // log() 是打印的方法
            console.log("静态注册失去焦点事件");
        }

        // 动态注册 onblur事件
        window.onload = function () {
            //1 获取标签对象
           var passwordObj = document.getElementById("password");
           // alert(passwordObj);
            //2 通过标签对象.事件名 = function(){};
            passwordObj.onblur = function () {
                console.log("动态注册失去焦点事件");
            }
        }

    </script>
</head>
<body>
    用户名:<input type="text" onblur="onblurFun();"><br/>
    密码:<input id="password" type="text" ><br/>
</body>
</html>

onchange内容发生改变

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

    <script type="text/javascript">
        function onchangeFun() {
            alert("女神已经改变了");
        }

        window.onload = function () {
            //1 获取标签对象
            var selObj = document.getElementById("sel01");
            // alert( selObj );
            //2 通过标签对象.事件名 = function(){}
            selObj.onchange = function () {
                alert("男神已经改变了");
            }
        }


    </script>
</head>
<body>
    请选择你心中的女神：
    <!--静态注册onchange事件-->
    <select onchange="onchangeFun();">
        <option>--女神--</option>
        <option>芳芳</option>
        <option>佳佳</option>
        <option>娘娘</option>
    </select>

    请选择你心中的男神：
    <select id="sel01">
        <option>--男神--</option>
        <option>国哥</option>
        <option>华仔</option>
        <option>富城</option>
    </select>


</body>
</html>

onsubmit表单提交事件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript" >
        // 静态注册表单提交事务
        function onsubmitFun(){
            // 要验证所有表单项是否合法，如果，有一个不合法就阻止表单提交
            alert("静态注册表单提交事件----发现不合法");

            return flase;
        }

        window.onload = function () {
            //1 获取标签对象
            var formObj = document.getElementById("form01");
            //2 通过标签对象.事件名 = function(){}
            formObj.onsubmit = function () {
                // 要验证所有表单项是否合法，如果，有一个不合法就阻止表单提交
                alert("动态注册表单提交事件----发现不合法");

                return false;
            }
        }

    </script>
</head>
<body>
    <!--return false 可以阻止 表单提交 -->
    <form action="http://localhost:8080" method="get" onsubmit="return onsubmitFun();">
        <input type="submit" value="静态注册"/>
    </form>
    <form action="http://localhost:8080" id="form01">
        <input type="submit" value="动态注册"/>
    </form>

</body>
</html>

DOM模型

DOM 全称是 Document Object Model 文档对象模型就是把文档中的标签，属性，文本，转换成为对象来管理。 Document 对象的理解：第一点：Document 它管理了所有的 HTML 文档内容。第二点：document 它是一种树结构的文档。有层级关系。第三点：它让我们把所有的标签都对象化第四点：我们可以通过 document 访问所有的标签对象。

document.getElementById(elementId) 通过标签的 id 属性查找标签 dom 对象，elementId 是标签的 id 属性值

document.getElementsByName(elementName) 通过标签的 name 属性查找标签 dom 对象，elementName 标签的 name 属性值

document.getElementsByTagName(tagname) 通过标签名查找标签 dom 对象。tagname 是标签名

document.createElement( tagName)方法，通过给定的标签名，创建一个标签对象。tagName 是要创建的标签名注： document 对象的三个查询方法，如果有 id 属性，优先使用 getElementById 方法来进行查询如果没有 id 属性，则优先使用 getElementsByName 方法来进行查询如果 id 属性和 name 属性都没有最后再按标签名查 getElementsByTagName 以上三个方法，一定要在页面加载完成之后执行，才能查询到标签对象。

节点常用属性和方法

方法：通过具体的元素节点调用 getElementsByTagName() 方法，获取当前节点的指定标签名孩子节点

appendChild( oChildNode ) 方法，可以添加一个子节点，oChildNode 是要添加的孩子节点属性： childNodes属性，获取当前节点的所有子节点 firstChild属性，获取当前节点的第一个子节点 lastChild属性，获取当前节点的最后一个子节点 parentNode属性，获取当前节点的父节点 nextSibling属性，获取当前节点的下一个节点 previousSibling属性，获取当前节点的上一个节点 className 用于获取或设置标签的 class 属性值 innerHTML属性，表示获取/设置起始标签和结束标签中的内容 innerText属性，表示获取/设置起始标签和结束标签中的文本

3、JQuery

3.1、 jQuery

什么是Jquery：对js提供了大量的封装，简化了js的书写是一个优秀的js框架

把js做了进一步的封装，使用简便，功能强大，他是很多前端框架的基础

jQuery是一个JavaScript函数库。 jQuery是一个轻量级的"写的少，做的多"的JavaScript库。 jQuery库包含以下功能：

HTML 元素选取
HTML 元素操作
CSS 操作
HTML 事件函数
JavaScript 特效和动画
HTML DOM 遍历和修改
AJAX
Utilities

3.2、 jQuery的使用

jQuery把js代码进行了封装我们想要谁用jQuery需要引入jQuery的函数库

 <!--引入JQuery库   在当前页面引入jQuery库  当前页面就可以使用jQuery函数了-->
    <script type="text/javascript" src="jquery-1.11.1.js"></script>

基本语法：$()

//$(document)-->$()  jQuery的基本语法  一切都能用$()解决   $()表示对document的封装
        $(function(){
            var $inp = $("#inp1");//jQuery对象  dom的封装产物
            alert(inp);
        })

3.3、jQuery的选择器快速锁定元素

基本选择器：

*通配符选择器

标签选择器

.class属性选择器

‘#’id属性选择器

联合选择的器

/*jQuery的基本选择器*/
        $(function(){
            //获取所有标签
            /*var $all = $("*");
            alert($all.length);*/
            //获取指定标签
            /*var $p = $("p");
            alert($p.size());*/
            //.class属性选择器
            /*var $c = $(".c1");
            alert($c.length);*/
            //#id属性选择器  id选择器只能获取唯一标签  当前页中 id属性必须是唯一值
           /* var $i = $("#i1");
            alert($i.length);*/
           //联合选择器  把多种选择器放在一起  用,隔开
            var $m = $(".c2,#i2,a");
            alert($m.size());
        });

3.4、 jQuery的属性方法

jQuery对象不能直接调用dom的属性，提供了调用的方法

val():给jQuery对象赋值和取值

var $inp = $("#inp1");
var uname = $inp.val();
alert(uname);
//改变value值
$inp.val("王五");

attr(key,[value]):取值jQuery对象的指定属性或给指定属性赋值

var $inp = $("#inp2");
var type = $inp.attr("type");
//alert("type的属性值："+type);
if(type=="password"){
    $inp.attr("type","text");
}else{
    $inp.attr("type","password");
}

prop(key,[value]):取值jQuery对象的指定属性或给指定属性赋值

//点击时   默认选中女
            var $m = $("#m");
            //使用prop
            var value = $m.prop("value");
            alert("性别："+value);
            //使用prop选中女
            $m.prop("checked",true);

addClass(value):给指定元素添加class属性

 var $n = $("#n");
 $n.addClass("csex");

text()====>innerText

html()=====>innerHTML

//jQuery对事件的封装
        $(function(){
            $("#inp1").focus(function(){
                $("#font1").attr("color","blue");
                $("#font1").text("<b>账号是6-8位数字和字母的组合</b>")
                //$("#font1").html("<b>账号是6-8位数字和字母的组合</b>")
            });
        });

3.5、 dom对象和jQuery对象的转换

jQuery对象中的get(index),该方法可以使得jQuery对象根据下标取值，但取出的值是dom对象

jQuery对象.get(index) ====>jQuery[index]

jQuery对象-----》dom对象

jQuery[0]

dom对象----》jQuery对象

$(dom对象)

var pwd = document.getElementById("pwd");
alert("dom对象："+pwd);
//转换为jQuery对象
var $pwd = $(pwd);
alert("jQuery对象："+$pwd);
//转换成dom对象
var  pwdDom = $pwd[0];
alert("转换为dom对象："+pwdDom);

jquery对象经过下标操作或变成dom，所以注意jQuery的循环

3.6、 jQuery的三种循环

//传统的循环
var $boxs = $("input");//这是一个js数组
            for(var i=0;i<$boxs.length;i++){
                var box = $boxs[i];//dom对象
                /*alert(box);*/
                box.checked = true;
            }

返回值:each(callback)

以每一个匹配的元素作为上下文来执行一个函数。

function getNo(){
    var  $boxs = $("input");//这是一个jQuery对象 但是是一个数组
    $boxs.each(function (i) {
        var box = $boxs[i];//变成dom对象
        box.checked = false;
    })

}

返回值:ObjectjQuery.each(object, [callback])

通用例遍方法，可用于例遍对象和数组。

function  getOther(){
    var  $boxs = $("input");//这是一个jQuery对象 但是是一个数组
    //object:需要遍历的数组或集合
    //function:每次遍历调用的方法
    	//i:遍历的次序
    	//node:每次遍历的赋值变量   参考增强for
    $.each($boxs,function(i,node){
       /* alert("node变量："+node);*/
        node.checked = !node.checked;
    })
}

3.7、 jQuery对事件的操作

常见的事件

页面对不同访问者的响应叫做事件。

鼠标事件	键盘事件	表单事件	文档/窗口事件
click	keypress	submit	load
dblclick	keydown	change	resize
mouseover	keyup	focus	scroll
mouseout		blur	unload

js是直接在标签上用on的方式绑定事件

jQuery把事件封装成方法：click() submit() 获取jQuery对象后调用事件方法即可

得焦事件：

$(function(){
    //等待账号的得焦事件
    $("#name").focus(function(){
        $("#font1").attr("color","blue");
        $("#font1").text("账号是6-8位数字和字母的组合 jQuery版");
    });
   
});

3.8、 jQuery的文档处理

jQuery可以操作html

append(content|fn)往匹配的元素内部追加内容。

$(function(){
    $("#but1").click(function(){
        //给指定的元素追加子内容
        $("#div1").append("<p>这是新段落</p>")
    });
});

appendTo(content) 把所有匹配的元素追加到另一个指定的元素元素集合中

$("#but2").click(function(){
    $("<a>这是a连接</a>").appendTo($("#div1"));
});

before(content|fn)在每个匹配的元素之前插入内容。

after(content|fn)在每个匹配的元素之后插入内容。

$("#but1").click(function(){
    $("#font1").before("<p>在font之前插入</p>");
});
$("#but2").click(function () {
    $("#font1").after("<b>在font之后</b>");
});

replaceWith(content|fn)将所有匹配的元素替换成指定的HTML或DOM元素。

$("#but3").click(function () {
   $("#font1").replaceWith("<div>这是替换后的div</div>")
});

replaceAll(selector) 用匹配的元素替换掉所有 selector匹配到的元素。

remove([expr])从DOM中删除所有匹配的元素。

$("#but4").click(function () {
    $("p").remove();
})

empty()删除匹配的元素集合中所有的子节点。

$("#but4").click(function(){
    $("#div1").empty();
});

css(name|pro|[,val|fn])访问匹配元素的样式属性 key：css的通用属性

$("#but1").click(function(){
    $("#font1").css("color","red");
    $("#font1").css("font-family","楷体");
});

3.9、其它选择器

层级选择器

选择器选择器：匹配指定选择器的所有后代元素

选择器 >选择器：匹配指定选择器的所有子元素

选择器 + 选择器：匹配指定选择器的紧邻的下一个兄弟元素

选择器 ~ 选择器：匹配指定选择器的后面所有的兄弟选择器

$("#but2").click(function(){
    var $divs = $("#div1 p");
    $.each($divs,function (i,n) {
        alert(n.innerHTML);
    })
});
$("#but3").click(function(){
    var $divs = $("#div1 > p");
    $.each($divs,function (i,n) {
        alert(n.innerHTML);
    })
});
$("#but4").click(function(){
    var $divs = $("#div1 + b");
    $.each($divs,function (i,n) {
        alert(n.innerHTML);
    })
});
$("#but5").click(function(){
    var $divs = $("#div1 ~ p");
    $.each($divs,function (i,n) {
        alert(n.innerHTML);
    })
});

简单选择器

$("#but1").click(
    function () {
        var t = $("li:first").html();
        alert(t);
    }
);
$("#but2").click(function () {
    $("li:even").css("color","blue");
});
$("#but3").click(function () {
    $("li:eq(3)").css("color","red");
});

4、Servlet

4.1、 http协议

协议：协议的甲乙双方，就是客户端（浏览器）和服务器！　　理解成双方通信的格式！

请求协议；

响应协议；

4.2、请求协议

request header：浏览器发起对服务器的访问时，根据http协议的内容我们会把当前浏览器的信息通过请求头传递到服务器端，遵守请求协议

请求有两种形式： get请求和post请求

get是明文请求：我们会把请求携带的参数明文的方式显示在浏览器地址栏中

明文请求不安全携带的数据量小最大2kb

post是暗纹(报文)请求:不会把参数显示在地址栏中，跟着请求正文被携带到服务器

暗纹：安全携带数据量大

前端向服务器发送请求的方式：

超链接   form表单   重定向

<h1><a href="http://www.baidu.com">超链接请求</a></h1>
    <!--
        form表单在sumbmit提交事件  会触发action
        同时拼接表单中所有 key-value
        input中：  name=value

    -->
<form action="002success.html" method="post">
    账号：<input type="text" name="uname" value="" ><br/>
    密码：<input type="password" name="upwd" value=""><br/>
    <input type="submit" value="提交">
</form>

4.3、响应协议

服务器接收到请求，做对应的处理，处理完毕，向浏览器回复信息,这就是响应

响应头对浏览器来说很重要，它说明了响应的真正含义。例如200表示响应成功了，302表示重定向，这说明浏览器需要再发一个新的请求。

200：请求成功，浏览器会把响应体内容（通常是html）显示在浏览器中；

404：请求的资源没有找到，说明客户端错误的请求了不存在的资源；

500：请求资源找到了，但服务器内部出现了错误；

302：重定向，当响应码为302时，表示服务器要求浏览器重新再发一个请求，服务器会发送一个响应头 Location，它指定了新请求的URL地址；

4.4、Servlet

javaweb有三大组件：

Servlet：处理器

Lisenter：监听器

Filter：过滤器

4.5、什么是Servlet

Servlet是JavaWeb的三大组件之一，它属于动态资源。

Servlet的作用是处理请求，服务器会把接收到的请求交给Servlet来处理，在Servlet中通常需要：

接收请求数据；

处理请求；

完成响应

4.6、 Servlet的体系

4.6.1、Servlet接口

在ServletAPI中最重要的是Servlet接口，所有Servlet都会直接或间接的与该接口发生联系，或是直接实现该接口，或间接继承自实现了该接口的类。
该接口包括以下五个方法：

init(ServletConfig config)
ServletConfig getServletConfig()
service(ServletRequest req,ServletResponse res)
String getServletInfo()
destroy( )

（1）第一次访问Servlet时，服务器会创建Servlet对象，并调用init方法，再调用service方法
（2）第二次再访问时，Servlet对象已经存在，不再创建，执行service方法
（3）当服务器停止，会释放Servlet，调用destroy方法。

4.6.2、GenericServlet抽象类

它对Servlet接口中的部分方法（init和destroy）添加了实现，使得开发时只需要考虑针对service方法的业务实现即可。

4.6.3、HttpServlet类

是继承GenericServlet的基础上进一步的扩展
平时使用Servlet开发基本上就是继承该类，重写doGet和doPost方法

4.7、Servlet创建方式

导入jar包

servlet-api.jar

4.7.1、方式一

实现接口Servlet

public class HelloServlet2 implements Servlet{

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
	}

	@Override
	public ServletConfig getServletConfig() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String getServletInfo() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void init(ServletConfig arg0) throws ServletException {
		// TODO Auto-generated method stub	
	}
	@Override
	public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		System.out.println("OK");
		response.setContentType("text/html;charset=UTF-8");
		response.getWriter().println("我是第一种创建方式");
	}
}

4.7.2、方式二

继承HttpServlet

// 创建一个普通类  继承javax.servlet.http.HttpServlet
//servlet类是一个处理器类
//服务器接受到请求  把对应的q请求分发给指定servlet
//servlet去处理
public class FirstServlet extends HttpServlet {
    //servlet初始化的方法  创建当前servlet对象 会先调用这个方法
    //初始化方法只调用一次
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        System.out.println("这是FirstServlet。我是初始化方法  当前对象创建了");
    }
    //doget和dopost方法是处理对应请求的   他俩来自 service方法
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(req, resp);
        System.out.println("这是处理get的");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
        System.out.println("这是处理post的");
    }
    //销毁的方法
    @Override
    public void destroy() {
        super.destroy();
        System.out.println("FirstServlet要销毁了  我就是销毁的方法");
    }

4.8、 Servlet生命周期

4.8.1、生命周期概念

生命周期也就是生命历程，就像人都是从怀胎-->出生-->婴儿-->儿童-->少年-->成年-->中年-->老年-->死亡

void init(ServletConfig)：出生之后（1次）仅且只调用一次；

void service(ServletRequest request, ServletResponse response)：每次处理请求时都会被调用；

void destroy()：临死之前（1次）；

每个servlet都是被服务器创建的，当有请求访问某个servlet时，服务器会创建这个servlet对象，调用一次init()方法，由service()处理该请求，当服务器关闭时，servlet会被服务器杀死，调用destroy()

servlet是单例多线程对象，懒汉式

4.8.2、Servlet生命周期的四个阶段

实例化（调用构造方法）

	实例化阶段是Servlet生命周期中的第一步，由Servlet容器调用Servlet的构造器创建一个具体的Servlet对象的过程。而这个创建的时机可以是在容器收到针对这个组件的请求之后，即:用了才创建；也可以在容器启动之后立刻创建实例。

初始化（init方法）

	Servlet在被加载实例化之后，必须要初始化它。在初始化阶段，init（）方法会被调用。这个方法在javax.servlet.Servlet接口中定义。其中，方法以一个ServletConfig类型的对象作为参数。ServletConfig对象由Servlet引擎负责创建，从中可以读取到事先在web.xml文件中通过<init-param>节点配置的多个name-value名值对。ServletConfig对象还可以让Servlet接受一个ServletContext对象。
一般情况下，init方法不需要编写，因GenericServlet已经提供了init方法的实现，并且提供了getServletConfig方法来获得ServletConfig对象。

Tips：init方法只被执行一次

就绪/服务

	Servlet被初始化以后就处于能够响应请求的就绪状态。每个对Servlet的请求由一个ServletRequest对象代表，Servlet给客户端的响应由一个ServletResponse对象代表。当客户端有一个请求时，容器就会将请求与响应对象转给Servlet，以参数的形式传给service方法。service方法由javax.servlet.Servlet定义，由具体的Servlet实现

Tips：HttpServlet将service方法拆分了。doGet和doPost

销毁

	Servlet容器在销毁Servlet对象时会调用destroy方法来释放资源。通常情况下Servlet容器停止或者重新启动都会引起销毁Servlet对象的动作，但除此之外，Servlet容器也有自身管理Servlet对象的准则，整个生命周期并不需要人为进行干预。

代码演示:

/**
 * Servlet implementation class LifeServlet
 * 演示Servlet的生命周期：
 * 1、实例化
 * 2、init:初始化
 * 3、service：服务
 * 4、destory：销毁
 */
public class LifeServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public LifeServlet() {
        super();
        System.out.println("1、完成了实例化");
        // TODO Auto-generated constructor stub
    }
    @Override
    public void init() throws ServletException {
    	// TODO Auto-generated method stub
    	super.init();
    	System.out.println("2、完成了初始化");
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		System.out.println("3、就绪中");
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}
	
	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		super.destroy();
		System.out.println("4、销毁了");
	}
}

web.xml配置文件

   <!--  告诉服务器 当有aaa请求访问服务器  请分发给FirstServlet-->
    <!--配置servlet请求-->
    <!-- 告诉服务器  我这有个servlet -->
    <servlet>
        <servlet-name>first</servlet-name>
        <servlet-class>com.bjpn.servlet.FirstServlet</servlet-class>
    </servlet>
    <!--配置servlet的请求映射   -->
    <servlet-mapping>
        <servlet-name>first</servlet-name>
        <!-- url请求必须写/
            /代表根路径   http://ip:port/项目名
        -->
        <url-pattern>/aaa</url-pattern>
    </servlet-mapping>

4.9、web.xml文件的配置

web.xml是服务器的核心配置文件，主要配置javaweb的三大组件

服务器在启动时会读取web.xml文件中的内容，一旦web.xml配置信息有误，服务器就会启动失败

1，不能有重名

2，url-pattern：必须写/

3、配置初始化参数

4、设置组件启动时机 load-on-startup

5、HttpServletRequest对象

5.1、什么是request对象

request是Servlet.service()方法的一个参数，类型为javax.servlet.http.HttpServletRequest。在客户端发出每个请求时，服务器都会创建一个request对象，并把请求数据封装到request中，然后在调用Servlet.service()方法时传递给service()方法，这说明在service()方法中可以通过request对象来获取请求数据。

request的功能可以分为以下几种：

封装了请求头数据；

封装了请求正文数据，如果是GET请求，那么就没有正文；

request是一个域对象，可以把它当成Map来添加获取数据；

request提供了请求转发和请求包含功能。

5.2 、request常用的方法

5.2.1 、request的域方法：

void setAttribute(String name, Object value)：用来存储一个对象，也可以称之为存储一个域属性
例如：servletContext.setAttribute(“xxx”, “XXX”)，在request中保存了一个域属性，域属性名称为xxx，域属性的值为XXX。
请注意，如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值，这一特性与Map相同；

 Object getAttribute(String name)：用来获取request中的数据，当前在获取之前需要先去存储才行
 例如：String value = (String)request.getAttribute(“xxx”);，获取名为xxx的域属性；

void removeAttribute(String name)：用来移除request中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；

Enumeration getAttributeNames()：获取所有域属性的名称；

5.2.2 、request获取请求头数据

request与请求头相关的方法有：

String getHeader(String name)：获取指定名称的请求头；

Enumeration getHeaderNames()：获取所有请求头名称；

int getIntHeader(String name)：获取值为int类型的请求头。

//得到请求头为Accept的信息
        String acceptStr = request.getHeader("Accept");
        System.out.println("Accept的值："+acceptStr);
        //一次性获取所有的header
        Enumeration enumeration = request.getHeaderNames();
        while(enumeration.hasMoreElements()){
            String name = (String)enumeration.nextElement();
            String value = request.getHeader(name);
            System.out.println(name+"---"+value);
        }

5.2.3、 request其它方法

request中还提供了与请求相关的其他方法，有些方法是为了我们更加便捷的方法请求头数据而设计，有些是与请求URL相关的方法。

l int getContentLength()：获取请求体的字节数，GET请求没有请求体，没有请求体返回-1；

l String getContentType()：获取请求类型，如果请求是GET，那么这个方法返回null；如果是POST请求，那么默认为application/x-www-form-urlencoded，表示请求体内容使用了URL编码；

l String getMethod()：返回请求方法，例如：GET

l Locale getLocale()：返回当前客户端浏览器的Locale。java.util.Locale表示国家和言语，这个东西在国际化中很有用；

String getCharacterEncoding()：获取请求编码，如果没有setCharacterEncoding()，那么返回null，表示使用ISO-8859-1编码；

void setCharacterEncoding(String code)：设置请求编码，只对请求体有效！注意，对于GET而言，没有请求体！！！所以此方法只能对POST请求中的参数有效！

 //判断请求是什么类型 get  null   post  application/x-www-form-urlencoded
       String  type= request.getContentType();
        //请求的方法  get/post
       String methodName = request.getMethod();
        System.out.println(type);
        System.out.println(methodName);
        //页面默认的中文编码格式是 ISO-8859-1
        String  code = request.getCharacterEncoding();
        System.out.println("请求的编码格式："+code);
        //设置请求的编码格式
        request.setCharacterEncoding("utf-8");
        String  code1 = request.getCharacterEncoding();
        System.out.println("请求的编码格式："+code1);

l String getContextPath()：返回上下文路径，例如：/hello

l String getQueryString()：返回请求URL中的参数，例如：name=zhangSan

l String getRequestURI()：返回请求URI路径，例如：/hello/oneServlet

l StringBuffer getRequestURL()：返回请求URL路径，例如：http://localhost/hello/oneServlet，即返回除了参数以外的路径信息；

l String getServletPath()：返回Servlet路径，例如：/oneServlet

l String getRemoteAddr()：返回当前客户端的IP地址；

l String getRemoteHost()：返回当前客户端的主机名，但这个方法的实现还是获取IP地址；

l String getScheme()：返回请求协议，例如：http；

l String getServerName()：返回主机名，例如：localhost

l int getServerPort()：返回服务器端口号，例如：8080

请求路径的方法

//接收请求
        StringBuffer path = request.getRequestURL();
        System.out.println("完整的请求："+path);
        //获取请求的协议
        String httpStr = request.getScheme();
        System.out.println("请求的协议："+httpStr);
        //请求服务器的ip地址
        String ip = request.getServerName();
        System.out.println("ip:"+ip);
        //请求携带的端口号
        int port = request.getServerPort();
        System.out.println("端口号："+port);
        //项目名+请求名
        String projectPath = request.getRequestURI();
        System.out.println("项目请求名："+projectPath);
        //项目名
        String  project = request.getContextPath();
        System.out.println("项目名："+project);
        //请求名
        String  reqName = request.getServletPath();
        System.out.println("请求名："+reqName);

获取客户端的方法

//获取客户端的ip和端口号
        String cip = request.getRemoteHost();
        String addr = request.getRemoteAddr();
        System.out.println("cip:"+cip);
        System.out.println("客户端addr："+addr);

5.2.4、接收参数的方法

String value = request.getParameter(“name”)

参数传递时，请求中携带的参数都符合key-value，我们根据key来接收value

String[] value = request.getParameterValues("name");

参数传递时，请求中携带的参数都符合key-value，一个key有多个值

<h1><a href="demo4?uname=zs&upwd=123">get请求携带参数</a></h1>
String  uname = request.getParameter("uname");
        String  upwd  = request.getParameter("upwd");
        System.out.println(uname+"---"+upwd);

解决post请求的中文乱码问题

<form action="demo4" method="post">
        账号：<input type="text" name="uname" value=""><br/>
        密码：<input type="password" name="upwd" value=""><br/>
        <input type="submit" value="提交">
    </form>
     //设置编码   解决post中文乱码的
        request.setCharacterEncoding("utf-8");
        String  uname = request.getParameter("uname");
        String  upwd  = request.getParameter("upwd");
        System.out.println(uname+"---"+upwd);

接收一个key多个value

<form action="demo4" method="get">
        账号：<input type="text" name="uname" value=""><br/>
        密码：<input type="password" name="upwd" value=""><br/>
        爱好：<input type="checkbox" name="hobby" value="游泳">游泳
                <input type="checkbox" name="hobby" value="看书">看书
            <input type="checkbox" name="hobby" value="睡觉">睡觉<br/>
        <input type="submit" value="提交">
    </form>

 //接收爱好
        String[] arrh = request.getParameterValues("hobby");
        for(String str : arrh){
            System.out.println(str);
        }

5.2.5 、请求转发

request.getRequestDispatcher(“路径”).forword(request,response);

请求转发的特点：

地址栏发起一次请求，地址栏不会发生改变

<h1><a href="demoA">发起请求DemoA</a></h1>

 //处理并转发
        System.out.println("这是DemoA  我要接收请求");
        StringBuffer path = request.getRequestURL();
        System.out.println("请求的路径是："+path);
        request.getRequestDispatcher("demoB").forward(request, resp);

BServlet

  System.out.println("这是BServlet");
        StringBuffer path = request.getRequestURL();
        System.out.println("ServletB接收的请求："+path);

作业：

登录处理 login页面在form表单中写post请求

账号：uname=“张三” 密码=“123”

LoginServlet接收参数并处理如果是张三和123 转发到success.html

如果不是转发到login.html

6 、HttpServletResponse对象

6.1、什么是Response

response是Servlet.service方法的一个参数，类型为javax.servlet.http.HttpServletResponse。
在客户端发出每个请求时，服务器都会创建一个response对象，并传入给Servlet.service()方法。
response对象是用来对客户端进行响应的，这说明在service()方法中使用response对象可以完成对客户端的响应工作。

response对象的功能分为以下四种：

设置响应头信息；

发送状态码；

设置响应正文；

重定向；

6.2 、响应对象常用的方法

方法名称	作用
setStatus(int code)	设置响应状态码
setHeader(name,value)	设置响应信息头
setCharacterEncoding(String);	设置编码格式
setContentType(String)	设置返回数据mimetype
getWriter()	获取字符输出流
getOutputStream()	获取字节输出流

6.2.1 、响应正文

PrintWriter out = response.getWriter()：获取字符流；给指定请求会写字符串

ServletOutputStream out = response.getOutputStream()：获取字节流；多用于文件下载

//给浏览器写响应正文
        PrintWriter out = response.getWriter();
        out.write("我是Demo1  给你发消息");

6.2.2、响应的乱码问题

在使用response.getWriter()时需要注意默认字符编码为ISO-8859-1，但是我们希望设置字符流的字符编码为utf-8 response.setCharaceterEncoding(“utf-8”) 设置响应时编码为utf-8

response.setContentType("text/html;charset=utf-8") 设置浏览器的读取和编码最好的解决方案

//设置响应的乱码问题
       /* response.setCharacterEncoding("utf-8");*/
        response.setContentType("text/html;charset=utf-8");
        //给浏览器写响应正文
        PrintWriter out = response.getWriter();
        out.write("我是Demo1  给你发消息");

6.2.3、响应头的操作

response.setHeader("Refresh","5; URL=www.baidu.com")：5秒后自动跳转到指定页面

//设置浏览器  5秒以后跳转淘宝
        response.setHeader("Refresh", "10;url=http://www.taobao.com");

6.2.4、设置状态码的方法

response.setStatus(200)：设置状态码；

response.sendError(404, “您要查找的资源不存在”)：当发送错误状态码时，Tomcat会跳转到固定的错误页面去，但可以显示错误信息。

//设置服务器响应的状态码
        /*response.setStatus(404);*/
        response.sendError(404, "访问信息不存阿紫啊");
        response.getWriter().write("这是信息");

6.2.5、重定向

服务器告诉浏览器我处理完了你去下个页面吧

重定向发送两次请求，地址栏会发生改变

response.sendRedirect ("新路径")

302是重定向的状态码我们可以通过设置响应头引起地址栏发生改变

//重定向
        /*//设置状态码
        response.setStatus(302);
        //重定向要让页面发起新的请求
        response.setHeader("Location", "http://localhost:8080/javaweb004/002responseDemo2.html");*/
        //重定向的方法
        response.sendRedirect("002responseDemo2.html");

6.2.6、案例：图片验证码

需要添加第三方jar包validatecode.jar

HTML页面

<!DOCTYPE html>
<html>
  <head>
    <title>login.html</title>
    <meta name="keywords" content="keyword1,keyword2,keyword3">
    <meta name="description" content="this is my page">
    <meta name="content-type" content="text/html; charset=UTF-8">
    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
  </head>
  <body>
      <form action="/Day11_Response1/servlet/LoginServlet"  method="post">
      	  <input type="text" name="username" placeholder="请输入账号！" />
      	  <input type="submit" value="登录"/>
      </form>
      <img src="/Day11_Response1/servlet/CodeServlet" onclick="changeCodes()" alt="验证码" title="验证码"/>
      <a href="javascript:changeCodes()" >看不清？</a>
      <script type="text/javascript">
      	function changeCodes(){
      	    var img= document.getElementsByTagName("img")[0];
      	    img.src = "/Day11_Response1/servlet/CodeServlet?r="+Math.random();
      	}
      </script>
  </body>
</html>

Servlet代码

public class CodeServlet extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1.设置生成规则
		/**
		 * width：验证码的宽度  px 像素
		 * height: px
		 * codeCount:生成验证码有几个数
		 * lineCount:有几根线
		 */
        //200高，50宽，6个数字，20干扰线
		ValidateCode code = new ValidateCode(200, 50, 6, 20);
		//2.获取生成的验证码的字符串值
		System.out.println(code.getCode()); //获取正确值
		//3.响应写回验证图片
		code.write(response.getOutputStream());
	}
}

7、简单的MVC分层

开发分为三层 mvc

m:model   模型  一般存放实体类    bean  dao    提供对象的

v:view  视图   页面  能看到的

c:controller  处理器   当前只学过Servlet     逻辑

项目的分包：

bean|entity|domain:放实体类

dao：连接数据库的包 database Object

controller|servlet：放servlet的

util：工具类

任务：连接数据库完成登录注册

数据库：userinfo

字段： user_id user_name user_pwd

CREATE TABLE servlet04.userinfo( user_id int NOT NULL AUTO_INCREMENT, user_name varchar(255) NULL, user_pwd varchar(255) NULL, PRIMARY KEY (user_id) );

附加任务：

注册账号唯一

登录成功在main.html中写一个a标签

查询当前数据库中所有数据，在后台打印

8、jsp

8.1、什么是jsp

jsp:java Server page java的服务页面技术

①JSP的本质是一个Servlet，Servlet能做的事情JSP都能做。

②JSP能够以HTML页面的方式呈现数据，是一个可以嵌入Java代码的HTML。

③JSP不同于HTML，不能使用浏览器直接打开，而必须运行在Servlet容器中。

jsp=HTML+Java代码

jsp的本质是servlet,servlet是被服务器创建并运行的，jsp需要被服务器编译

jsp的运行流程：

一个jsp页面在服务器要经过三个步骤：

1 翻译、转译 .jsp -> .java tomcat

2 编译 .java -> .class jvm

3 运行 .class -> .html(静态页面)

第一次请求一个jsp页面三个过程必须走一次。

在没有修改jsp页面之前，再次访问只要运行就可以了。

8.2、jsp的基本语法

8.2.1、 jsp的脚本

JSP脚本就是Java代码片段，它分为三种：

<%...%>：Java语句； java片段在一个页面中所有的片段相通

<%=…%>：Java表达式；用于页面输出 ===》out.wirte()===>response.getWriter().write();

<%!...%>：Java定义类成员；

<%--jsp的指令  --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   
    <%
    <%--jsp中可以同时容纳  HTML代码和java脚本
        HTML语言是标签语言  可以直接放在HTML中
        java代码  需要放在特定语法中  <% java代码块%>
    --%>
        String name = "张三";
        System.out.println("name值："+name);
        out.write(name);
    %>
<h1>这是我的第一个jsp</h1>
</body>
</html>

<% java代码%> 这是一段java程序在一个页面中所有的java程序都是相通的

<%
    int age = 16;
    if(age<18){
 %>
<font color="red">
    <% out.write("未成年人禁止入内");%>
</font>
<%
    }else{
%>
<font color="blue">
    <%
        out.write("成年了");
    %>
</font>
<%
    }
%>

<%= java表达式%> 主要作用是输出替代 <% out.write("这是out对象的输出");%>

<h1>这是demo3.jsp</h1>
<%="hello jsp  这是java的输出"%>
<% out.write("这是out对象的输出");%><br/>
<%= 5+6 %>  <%= 5<6 %>
<%
    int a =60;
    int b = 6;
    int sum = a+b;
%>
<h1><%out.write(sum);%></h1>
<h2><%=sum%></h2>

<%!...%>：Java定义类成员；一般不在jsp上定义类成员

8.2.2、 jsp的指令

JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。

JSP指令的基本语法格式：

<%@ 指令名属性名="值" %>

举例：<%@ page contentType="text/html;charset=utf-8" %>

注意：属性名部分是大小写敏感的

在目前的JSP2.0中，定义了page、include和taglib这三种指令，每种指令中又都定义了一些各自的属性

8.2.2.1、page指令

page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面。为了保持程序的可读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置

JSP 2.0规范中定义的page指令的完整语法：
<%@ page 
	[ language="java" ] 
	[ extends="package.class" ] 
	[ import="{package.class | package.*}, ..." ] 
	[ session="true | false" ] 
	[ buffer="none | 8kb | sizekb" ] 
	[ autoFlush="true | false" ] 
	[ isThreadSafe="true | false" ] 
	[ info="text" ] 
	[ errorPage="relative_url" ] 
	[ isErrorPage="true | false" ] 
	[contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ]
	[ pageEncoding="characterSet | ISO-8859-1" ] 
	[ isELIgnored="true | false" ] 
%>

[1]import属性：指定 JSP 页面转换成 Servlet时应该导入的包。

[2]pageEncoding属性：设置JSP页面翻译成Servlet源文件时使用的字符集。

[3]contentType属性：设置 Content-Type 响应报头，标明即将发送到客户程序的文档的 MIME 类型以及浏览器对  			    响应内容的解码字符集。 

[4]errorPage属性：指定当前JSP抛出异常时的转发页面。

[5]isErrorPage属性：指定当前页面是不是一个显示错误消息的页面，如果是，则会自动创建exception对象，否则就					不会创建exception对象。

[6]session属性：控制页面是否参与HTTP会话，其本质是要不要自动创建session隐含对象以供使用。

[7]isELIgnored属性：指定当前页面是否忽略EL表达式，如果忽略，EL表达式的内容将会原封不动的输出到浏览器						端。

<%--指令 标识当前页面  遵守的编码规则
    language：支持的开发语言
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java"  %>
<%--利用指令 导包  --%>
<%@page import="com.bjpn.bean.User,java.util.Map" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.HashMap" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%
        User user = new User();
       user.setUid(1001);
       user.setUname("大朗");
       user.setUpwd("123");
    %>
    输出对象：<%=user%><br/>
    user名字:<%=user.getUname()%>

</body>

8.2.2.2、include指令包含

• include指令用于通知JSP引擎在翻译当前JSP页面时将其他文件中的内容合并进当前JSP页面转换成的Servlet源文件中，这种在源文件级别进行引入的方式称之为静态引入，当前JSP页面与静态引入的页面紧密结合为一个Servlet。

• 语法：

<%@ include file="relativeURL"%>

其中的file属性用于指定被引入文件的相对路径。

• 细节：

被引入的文件必须遵循JSP语法，其中的内容可以包含静态HTML、JSP脚本元素、JSP指令和JSP行为元素等普通JSP页面所具有的一切内容。

被引入的文件可以使用任意的扩展名，即使其扩展名是html，JSP引擎也会按照处理JSP页面的方式处理它里面的内容，为了见明知意，JSP规范建议使用.jspf（JSP fragments）作为静态引入文件的扩展名。

在将JSP文件翻译成Servlet源文件时，JSP引擎将合并被引入的文件与当前JSP页面中的指令元素（设置pageEncoding属性的page指令除外），所以，除了import和pageEncoding属性之外，page指令的其他属性不能在这两个页面中有不同的设置值。

8.2.2.3、taglib指令

taglib指令用来引用标签库并设置标签库的前缀。这个指令允许JSP页面使用用户自定义的标签。

taglib指令的语法格式为：

<%@ tagliburi="标签库URI" prefix="自定义标签前缀" %>

taglib指令包含两个属性，一个是uri，用来指定标签文件或标签库的存放位置；另一个是prefix，用来指定该标签库使用的前缀。

8.3、jsp的九大内置对象

jsp是对servlet进行了一定程度的封装，服务器给jsp提供了9个隐式对象，可以直接使用

对象名	类型	说明
request	javax.servlet.http.HttpServletRequest
response	javax.servlet.http.HttpServletResponse
session	javax.servlet.http.HttpSession	由session=“true”开关
application	javax.servlet.ServletContext	Servlet中的ServletContext
config	javax.servlet.ServletConfig	Servlet中的ServletConfig
exception	java.lang.Throwable	由isErrorPage=“false”开关
out	javax.servlet.jsp.JspWriter	javax.servlet.jsp.JspWriter
pageContext	javax.servlet.jsp.PageContext	域对象，获取其他八大对象
page	java.lang.Object当前对象this	当前servlet实例

1 out 输出流，向客户端浏览器输出的流对象。 <%=%>

2 request* 请求对象，封装了客户端向服务器发送的数据。 ***

3 response 响应对象，封装了服务器向客户端发送的数据。 ***

4 session* 会话对象 ***

5 application 应用程序对象 ***

6 exception 异常报错用的

7 page 页面，当前页面对象

8 pageContext 页面上下文对象

9 config 配置对象

 <%
        /*接收参数*/
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        String uname = request.getParameter("uname");
        String upwd = request.getParameter("upwd");
        String code = "888679";
        if(uname.equals("zs") && upwd.equals("123")){
    %>
    <font color="green">登录成功,您的卡号是：<%=code%></font>
    <%
        }else{
    %>
    <font color="red">账号或密码错误</font>
    <%
        }
    %>

案例：查询数据库表中所有信息并显示在页面

8.3.1、隐式对象的获取

在普通类中可以通过PageContext获取其它JSP隐式对象,具体如下

getException方法返回exception隐式对象 
getPage方法返回page隐式对象
getRequest方法返回request隐式对象 
getResponse方法返回response隐式对象 
getServletConfig方法返回config隐式对象
getServletContext方法返回application隐式对象
getSession方法返回session隐式对象 
getOut方法返回out隐式对象

8.4、jsp的四大域对象

域对象	作用范围	起始时间	结束时间
pageContext	当前JSP页面	页面加载	离开页面
request	同一个请求	收到请求	响应
session	同一个会话	开始会话	结束会话
application	当前Web应用	Web应用加载	Web应用卸载

域对象，可以存取属性值，用来在域中共享。

四大域对象是我们传递参数的容器

在JavaWeb中一共四个域对象，其中Servlet中可以使用的是request、session、application三个对象，而在JSP中可以使用pageContext、request、session、application四个域对象。

域对象有各自的传值范围：域对象的生命周期

pageContext:只在当前页有效

request：一次请求发起一个请求 A到B request域可以传值

session：一次会话浏览器和服务的一次稳定联系

appliaction：服务器不关闭该域就存在

域对象的使用

作用域对象都是基于MAP格式（key-value）的容器。

1 void setAttribute(String key , Object value) ; 保存数据

2 Object getAttribute(String key) ; 获取数据

getAttribute方法只能获取使用setAttribute方法放入的数据。

3 void removeAttribute(String name);删除指定的数据

//连接数据库查询
        UserDao userDao = new UserDao();
        User u = userDao.userLogin(userCode, userPwd);
        if(u!=null){
            //账号密码正确 登录成功  成功去main页面
            //main页面需要知道登录人的姓名
            //页面跳转  logindo.jsp---->main.jsp
            //使用request容器  传递参数
            request.setAttribute("useraaa", u);//  Object obj = u;
            request.setAttribute("bbb", "你好main");
            request.getRequestDispatcher("main.jsp").forward(request, response);
        }else{
            //账号密码错误
            response.sendRedirect("login.jsp");
        }

获取参数

<%--  接收request容器中的参数 --%>
        <%
            Object obj = request.getAttribute("useraaa");
            User u = (User)obj;
            String str = (String)request.getAttribute("bbb");
        %>
    <h1>登录成功</h1>
    <h2>欢迎<%=u.getUserName()%>  </h2>
    <h3><%= str%></h3>

8.5、EL表达式

JSP2.0要把html和css分离、要把html和javascript分离、要把Java脚本替换成标签。标签的好处是非Java人员都可以使用。

JSP2.0 – 纯标签页面，即：不包含<% … %>、<%! … %>，以及<%= … %>

EL（Expression Language）是一门表达式语言，它对应<%=…%>。我们知道在JSP中，表达式会被输出，所以EL表达式也会被输出。

el表达式格式：${}

${}:表示输出数据用来替代<%=%>

${表达式} 例如：$ {1 + 2}

核心功能:取域对象的值  
格式如： ${EL表达式} 等价于getAttribute(name)

关闭EL表达式

如果希望整个JSP忽略EL表达式，需要在page指令中指定isELIgnored=”true”。

如果希望忽略某个EL表达式，可以在EL表达式之前添加“\”，例如：${1 + 2}。

8.5.1、 EL表达式的运算符

运算符	说明	范例	结果
+	加	${17+5}	22
-	减	${17-5}	12
*	乘	${17*5}	85
/或div	除	${17/5}或{17 div 5}	3
%或mod	取余	${17%5}或{17 mod 5}	2
==或eq	等于	${5==5}或{5 eq 5}	true
!=或ne	不等于	${5!=5}或{5 ne 5}	false
<或lt	小于	${3<5}或{3 lt 5}	true
>或gt	大于	${3>5}或{3 gt 5}	false
<=或le	小于等于	${3<=5}或{3 le 5}	true
>=或ge	大于等于	${3>=5}或{3 ge 5}	false
&&或and	并且	${true&&false}或{true and false}	false
!或not	非	${!true}或{not true}	false
\|\|或or	或者	${true\\|\\|false}或$ {true or false}	true
empty	是否为空	${empty “”}，可以判断字符串、数据、集合的长度是否为0，为0返回true。empty还可以与not或!一起使用。$ {not empty “”}	true

注：

+加号在el表达式中只有一个功能，进行加法运算。不支持字符串的连接。

/ 除法在el表达式中可以进行正常的除法计算的。${10/4} --- 2.5

当EL表达式的值为null时，会在页面上显示空白，即什么都不显示。

8.5.2、 EL表达式的应用

操作bean的属性： ${person.name}、$ {person[‘name’]}，对应person.getName()方法；

操作List和数组： ${list[0]}、$ {arr[0]}；

操作Map的值： ${map.key}、$ {map[‘key’]}，对应map.get(key)。

1 获取对象中的值

<%
//我在request域中方入值
request.setAttribute("message", "来自servlet的request域信息");
//session与
HttpSession session = request.getSession();
session.setAttribute("sMessage", "session中的值");
//application域
ServletContext app = session.getServletContext();
app.setAttribute("appMessage", "全局作用域的值");
//request.getRequestDispatcher("elMessage.jsp").forward(request, response);
//重定向
response.sendRedirect("elMessage.jsp");
%>

用el表达式接收值:${message}<br/>
接收Session域:${sMessage}<br/>
接收application域:${appMessage}

2、存入对象

//在域中存入对象
User user = new User(1,"大郎",18);
session.setAttribute("userKey", user);

user对象：${userKey}<br/>
user对象值:${userKey.getUid()}---${userKey.getUname()}---${userKey.getUage()}
简化写法：${userKey.uid}---${userKey.uname}----${userKey.uage}

3、使用list和map

<%
List<String> list =new ArrayList<String>();
list.add("aa");
list.add("bb");
list.add("cc");
pageContext.setAttribute("list", list);

Map<String,String> map =new HashMap<String,String>();
map.put("aa", "11");
map.put("bb", "22");
map.put("cc", "33");

pageContext.setAttribute("map", map);

%>

<h1>1.以数组的下标形式获取list值</h1>
${list[0]}<br>
${list[1]}<br>
${list[2]}<br>
<h1>2.以提供的方法get(index)</h1>
${list.get(0)}

<h1>3.使用El表达式获取map中的值(以key的形式获取)</h1>
${map.aa}<br>
${map.bb}<br>
${map.cc}<br>
<h1>4.使用El表达式获取map中的值</h1>
${map['aa']}

4、使用EL表达式的empty关键字

<% String s1="";
pageContext.setAttribute("s1", s1);
String s2=null;
pageContext.setAttribute("s2", s2);
String s3="122222";
pageContext.setAttribute("s3", s3);
List list1 =new ArrayList();
pageContext.setAttribute("list1", list1);
%>

<!-- empty关键只要内容是空true -->
not empty
${empty s1}<br>
${empty s2}<br>
${empty  s3}<br>
${empty  list1}<br>

8.5.3、 EL表达式的内置对象

EL一共11个内置对象，无需创建即可以使用。这11个内置对象中有10个是Map类型的，最后一个是pageContext对象。

pageScope	page域
requestScope	request域
sessionScope	session域
applicationScope	appliaction域
param；
paramValues；
header；
headerValues；
initParam；
cookie；	会话管理对象
pageContext；	上下文

pageScope：${pageScope.name}等同与pageContext.getAttribute(“name”)；

requestScope：${requestScope.name}等同与request.getAttribute(“name”)；

sessionScoep： ${sessionScope.name}等同与session.getAttribute(“name”)；

applicationScope：${applicationScope.name}等同与application.getAttribute(“name”)；

工作中避免出现重名key

//不同域中有重名
      request.setAttribute("error", "requestError");
      session.setAttribute("error", "sessonError");
      application.setAttribute("error", "appError");

request:${requestScope.error}<br/>
    session:${sessionScope.error}<br/>
    全局：${applicationScope.error}

8.6、JSTL标签库

8.6.1、什么是JSTL

Java Server Pages Standard Tag Library——JSP标准标签库。

JSTL是一个标准的、已制定好的标签库，可以应用于各种领域，如：基本输入输出、流程控制（分支、迭代）、XML文件剖析、数据库查询及国际化和文字格式标准化的应用等。

JSTL所提供的标签函数库主要分为五大类：

①核心标签库（Core tag library）

②I18N格式标签库（I18N-capable formatting tag library）低版本的jdk和Tomcat需要

③SQL标签库（SQL tag library）不需要

④XML标签库（XML tag library）

⑤函数标签库（Functions tag library）

导入jar:

jstl核心包

standard辅助包

在jsp上引入jstl标签库:

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

8.6.2、常用的标签

功能分类	标签名称
表达式操作	out
	set
	remove
流程控制	if
	choose
	when
	otherwise
	forEach
	forTokens
URL操作	param
	url
	redirect

c:out
输出域对象指定属性名所对应的属性值, 如果为null, 显示默认值
<c:out value="${name}" default="defaultValue"/>
c:set
①向域对象中保存指定的属性名和属性值
<c:set value="${person.name}" var="myName"/>
②修改域对象中JavaBean的属性值
<c:set target="${person}" property="name" value="Jack"/>
c:remove
删除域对象中的指定属性
<c:remove var="myName"/>

if标签的test属性必须是一个boolean类型的值，如果test的值为true，那么执行if标签的内容，否则不执行。

一重条件判断[c:if]
多个c:if之间是没有任何关系的
<% pageContext.setAttribute("age", "25"); %>
<c:if test="${age < 18 }">祖国的花骨朵</c:if>
<c:if test="${age >= 18 && age < 25 }">2B青年</c:if>
<c:if test="${age >= 25 && age < 40 }">苦B青年</c:if>
<c:if test="${age >= 40 && age < 50 }">年富力强</c:if>
<c:if test="${age >= 50 && age < 65 }">享受成功</c:if>
<c:if test="${age >= 65 }">退休生活</c:if>

choose标签对应Java中的if/else if/else结构。when标签的test为true时，会执行这个when的内容。当所有when标签的test都为false时，才会执行otherwise标签的内容。

多重条件判断[c:choos/c:when/c:otherwise]
程序执行时，按照从上往下的顺序执行c:when，一旦找到满足条件的c:when就不再继续执行了，如果没有任何满足的c:when则执行c:otherwise。
<c:choose>
	<c:when test="${age < 18 }">祖国的花骨朵</c:when>
	<c:when test="${age < 25 }">2B青年</c:when>
	<c:when test="${age < 40 }">苦B青年</c:when>
	<c:when test="${age < 50 }">年富力强</c:when>
	<c:when test="${age < 65 }">享受成功</c:when>
	<c:otherwise>退休生活</c:otherwise>
</c:choose>

forEach当前就是循环标签了，forEach标签有多种两种使用方式：

使用循环变量，指定开始和结束值，类似for(int i = 1; i <= 10; i++) {}；

 <%--  这种方式  for(int i=0;i<10;i++){}--%>
    <c:forEach begin="1" end="10" var="i">
        ${i}<br/>
    </c:forEach>

循环遍历集合，类似for(Object o : 集合)；

<%--  增强for  for(数据类型 变量 : 集合){}--%>
    <c:forEach items="${集合}" var="变量" varStatus="index">
        ${变量}
    </c:forEach>

//传递list集合到页面
        List<User> userList = new ArrayList<User>();
        User user = new User(1, "大郎", "111", "222");
        User user1 = new User(2, "金莲", "111", "222");
        User user2 = new User(3, "西门", "111", "222");
        userList.add(user);
        userList.add(user1);
        userList.add(user2);
        request.setAttribute("userList",userList);
        request.getRequestDispatcher("jstlDemo1.jsp").forward(request, response);

<c:forEach items="${userList}" var="u" varStatus="i">
        ${i.index+1}+${u.userName}<br/>
    </c:forEach>

练习：传递Map集合

URL操作：了解

重定向

<%-- 使用context属性指定项目虚拟路径，使用url属性指定重定向的目标位置 --%>
<c:redirect
 context="${pageContext.request.contextPath }"
 url="/target2.jsp" />

传递请求参数

<%-- 使用context属性指定项目虚拟路径，使用url属性指定重定向的目标位置 --%>
<c:redirect
 context="${pageContext.request.contextPath }"
 url="/target2.jsp">
	<%-- 使用name属性指定请求参数名，使用value属性指定请求参数值 --%>
	<c:param name="sayHi" value="hi..."></c:param>
</c:redirect>

JavaWeb-学习笔记分享（一)