JavaWeb：jsp已经过时，了解即可

最新推荐文章于 2025-02-21 14:37:05 发布

原创最新推荐文章于 2025-02-21 14:37:05 发布 · 4.6k 阅读

28 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

JavaWeb

该博客围绕JavaWeb开发展开，介绍了jQuery、XML、Tomcat、Servlet、jsp等技术。涵盖各技术的定义、使用方法、核心函数等内容，还涉及JSON、AJAX、i18n国际化等知识，同时讲解了cookie和session原理、Filter过滤器使用等。

JavaWeb

课程地址：尚硅谷Javaweb

jsp已过时，了解即可

文章目录

JavaWeb

第1章：jQuery

1.1 定义

jQuery：就是JavaScript和查询(Query)，辅助JavaScript开发的js类库

1.2 使用

使用JavaScript绑定单击事件

window.onload = function () {
		 	var btnObj = document.getElementById("btnId");
			 alert(btnObj);//[object HTMLButtonElement]   ====>>>  dom对象
		 	btnObj.onclick = function () {
			alert("js 原生的单击事件");
		 	}
		 }

使用jQuery，需要导入jquery.js

<script type="text/javascript" src="../script/jquery-1.7.2.js"></script>
<script type="text/javascript">

	//使用$()代替window.onload
	$(function(){
		//使用选择器获取按钮对象，随后绑定单击响应函数
		$("#btnId").click(function(){
			//弹出Hello
			alert('Hello');
		});
	});

</script>

<body>
	<button id="btnId">SayHello</button>
</body>

$为一个函数

绑定单击事件

1.3 核心函数

** $* * 是 j Q u e r y 的核心函数，$ ()调用$函数

传入参数为函数时

$(function(){

});

相当于

window.onload=function(){}

传入参数为HTML字符串时，会创建这个HTML标签对象

$("    <div>" +
            "        <span>div-span1</span>" +
            "        <span>div-span2</span>" +
            "    </div>").appendTo("body");

传入参数为选择器字符串时：

$("#id 属性值");		//id选择器，根据id查询标签对象
$("标签名");			//标签名选择器，分局指定标签名查询标签对象
$(".class 属性值");	//类型选择器，根据class属性查询标签对象

传入参数为dom对象时，将dom对象转换为jQuery对象

1.4 jQuery对象和dom对象区分

Dom对象：通过以下方式都是dom对象

getElementById()
getElementByName()
getElementByTagName()
createElement()

Dom对象通过Alert()出来的效果：[object HTML 标签名 Element]

jQuery对象

通过jQuery提供的API创建的对象
通过jQuery提供的API查询的对象
通过jQuery包装的Dom对象

jQuery对象Alert()出来的效果是：[object Object]

jQuery对象的本质：

jQuery对象是dom对象的数组+jQuery提供的一系列功能函数

jQuery对象和Dom对象的使用区别

jQuery对象不能使用Dom对象的属性和方法
Dom对象不能使用jQuery对此昂的属性和方法

jQuery对象和Dom对象相互转换

$(Dom对象)	#就是jQuery对象了

jQuery对象[index]		#用下标取出Dom对象

1.5 jQuery选择器

基本选择器：

$("#one")		//选择id
$(".mini")		//选择class
$("div")		//选择标签
$("*")			//选择所有
$("span,#two")	//选择俩

层级选择器：

$("body div")		//选择祖先 body 内的所有 div 元素
$("body > div")		//在父 body 内, 选择div子元素  
$("#one+div")		//选择 id 为 one 的下一个 div 元素 
$("#two~div")		//选择 id 为 two 的元素后面的所有 div 兄弟元素

过滤选择器：

基本过滤器：

$("div:first")		//1.选择第一个 div 元素  
$("div:last")		//2.选择最后一个 div 元素
$("div:not(.one)")		//3.选择class不为 one 的所有 div 元素
$("div:even")		//4.选择索引值为偶数的 div 元素
$("div:odd")		//5.选择索引值为奇数的 div 元素
$("div:gt(3)")		//6.选择索引值为大于 3 的 div 元素
$("div:eq(3)")		//7.选择索引值为等于 3 的 div 元素
$("div:lt(3)")		//8.选择索引值为小于 3 的 div 元素
$(":header")		//9.选择所有的标题元素
$(":animated")		//10.选择当前正在执行动画的所有元素
$("div:not(:animated):last")		//11.选择没有执行动画的最后一个div

内容过滤器：

$("div:contains('di')")		//1.选择 含有文本 'di' 的 div 元素
$("div:empty")			//2.选择不包含子元素(或者文本元素) 的 div 空元素
$("div:has(.mini)")		//3.选择含有 class 为 mini 元素的 div 元素
$("div:parent")			//4.选择含有子元素(或者文本元素)的div元素

可见性过滤选择器：

不可见：display属性设置为none，或visible设置为hidden

$()			//1.选取所有可见的  div 元素
$().show("slow")		//2.选择所有不可见的 div 元素
$().attr("value")		//3.选择所有不可见的 input 元素

属性过滤器：

$("div[title]")		//1.选取含有 属性title 的div元素
$("div[title='test']")		//2.选取 属性title值等于'test'的div元素
$("div[title!='test']")		//3.选取 属性title值不等于'test'的div元素(*没有属性title的也将被选中)
$("div[title^='te']")		//4.选取 属性title值 以'te'开始 的div元素
$("div[title$='est']")		//5.选取 属性title值 以'est'结束 的div元素
$("div[title*='es']")		//6.选取 属性title值 含有'es'的div元素
$("div[id][title*='es']")		//7.首先选取有属性id的div元素，然后在结果中 选取属性title值 含有'es'的 div 元素
$("div[title][title!='test']")		//8.选取 含有 title 属性值, 且title 属性值不等于 test 的 div 元素

表单过滤器：

	/**
		:input 		
		:text 		
		:password 	
		:radio 		
		:checkbox 	
		:submit 	
		:image 		
		:reset 		
		:button 	
		:file 		
		:hidden 	
		
		表单对象的属性
		:enabled 		
		:disabled 		
		:checked 		
		:selected 		
		*/

表单对象属性过滤器：

$(":text:enabled").val("我是万能的程序员");		//1.对表单内 可用input 赋值操作,val()可以操作表单项的value属性值,它可以设置和获取
$(":text:disabled").val("管你可用不可用，反正我是万能的程序员");		//2.对表单内 不可用input 赋值操作
$(":checkbox:checked").length		//3.获取多选框选中的个数  使用size()方法获取选取到的元素集合的元素个数

var $checkboies = $(":checkbox:checked");		//4.获取多选框，每个选中的value值

$checkboies.each(function () {		// each方法是jQuery对象提供用来遍历元素的方法
						alert( this.value );
					});

var $options = $("select option:selected");		//5.获取下拉框选中的内容 

$options.each(function () {
						// 在each遍历的function函数中，有一个this对象。这个this对象是当前正在遍历到的dom对象
						alert(this.innerHTML);
					});

1.6 jQuery元素筛选

$("div").eq(3)			//1.eq()  选择索引值为等于 3 的 div 元素
$("div").first()		//2.first()选择第一个 div 元素
$("div").last()			//3.last()选择最后一个 div 元素
$("div").filter(":even")	//4.filter()在div中选择索引为偶数的
$("#one").is(":empty")		//5.is()判断#one是否为:empty或:parent
$("div").has(".mini")		//6.has()选择div中包含.mini的
$("div").not('.one')		//7.not()选择div中class不为one的
$("body").children("div.one")		//8.children()在body中选择所有class为one的div子元素
$("body").find("div.mini")			//9.find()在body中选择所有class为mini的div元素
$("#one").next("div")			//10.next() #one的下一个div
$("#one").nextAll("span")		//11.nextAll() #one后面所有的span元素
$("#one").nextUntil("span")		//12.nextUntil() #one和span之间的元素
$(".mini").parent()			//13.parent() .mini的父元素
$("#two").prev("div")		//14.prev() #two的上一个div
$("span").prevAll("div")		//15.prevAll() span前面所有的div
$("span").prevUntil("#one")		//16.prevUntil() span向前直到#one的元素
$("#two").siblings()			//17.siblings() #two的所有兄弟元素
$("span").add("#two").add("#one")		//18.add()选择所有的 span 元素和id为two的元素

第2章：XML

2.1 XML简介

xml是可扩展的标记性语言

用来保存数据
配置文件
网络传输数据的格式（现在以JSON为主）

2.2 XML语法

<?xml version="1.0" encoding="utf-8" ?>
<!-- xml声明 version是版本的意思   encoding是编码  -->
<books> <!-- 这是xml注释 -->
    <book id="SN123123413241"> 
        <name>java编程思想</name> 
        <author>华仔</author>		
        <price>9.9</price>		
    </book>
    
    <book id="">
    
    <books>
</books>

element元素从开始标签到结束标签
大小写敏感
属性必须加引号
文本区域：（CDATA区）

2.3 XML解析技术

dom技术

document对象表示的是整个文档（HTML/xml）

过时的：dom解析–>SAX解析

第三方解析：

jdom 在 dom 基础上进行了封装
dom4j 对jdom进行了封装
pull 主要用在 Android 手机开发，是在跟 sax 非常类似都是事件机制解析 xml 文件。

2.4 dom4j 解析技术（重点）

需要导入dom4j的jar包

dom4j 操作步骤：

第一步：先加载 xml 文件创建 Document 对象
第二步：通过 Document 对象拿到根元素对象
第三步：通过根元素.elelemts(标签名); 可以返回一个集合，这个集合里放着。所有你指定的标签名的元素对象
第四步：找到你想要修改、删除的子元素，进行相应的操作
第五步，保存到硬盘上

解析的xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<books>
    <book sn="SN12341232">
        <name>辟邪剑谱</name>
        <price>9.9</price>
        <author>班主任</author>
    </book>
    <book sn="SN12341231">
        <name>葵花宝典</name>
        <price>99.99</price>
        <author>班长</author>
    </book>
</books>

解析步骤：

第一步，通过创建 SAXReader 对象。来读取 xml 文件，获取 Document 对象
第二步，通过 Document 对象。拿到 XML 的根元素对象
第三步，通过根元素对象。获取所有的 book 标签对象
第四步，遍历每个 book 标签对象。然后获取到 book 标签对象内的每一个元素，再通过 getText() 方法拿到
起始标签和结束标签之间的文本内容

public class MyTest {
    public static void main(String[] args) throws DocumentException {
        MyTest myTest = new MyTest();
        myTest.readXML();
    }
    
    public void readXML() throws DocumentException {
        SAXReader reader = new SAXReader();
        Document document = reader.read("src/books.xml");
        Element root = document.getRootElement();
        System.out.println(root.asXML());

        List<Element> books = root.elements("book");

        for (Element book : books) {
            Element name = book.element("name");
            Element price = book.element("price");
            Element author = book.element("author");
            System.out.println("书名："+name.getText()+",价格："+price.getText()+",作者："+author.getText());
        }

    }
}

第3章：Tomcat

3.1 请求和响应

JavaWeb：所有通过 Java 语言编写可以通过浏览器访问的程序的总称，基于请求和响应来开发的。

3.2 Web资源分类

静态资源： html、css、js、txt、mp4 视频、jpg 图片

动态资源： jsp 页面、Servlet 程序

3.3 常用的Web服务器

Tomcat：由 Apache 组织提供的一种 Web 服务器，提供对 jsp 和 Servlet 的支持。它是一种轻量级的 javaWeb 容器（服务器），也是当前应用最广的 JavaWeb 服务器（免费）。
Jboss：是一个遵从 JavaEE 规范的、开放源代码的、纯 Java 的 EJB 服务器，它支持所有的 JavaEE 规范（免费）。
GlassFish：由 Oracle 公司开发的一款 JavaWeb 服务器，是一款强健的商业服务器，达到产品级质量（应用很少）。
Resin：是 CAUCHO 公司的产品，是一个非常流行的服务器，对 servlet 和 JSP 提供了良好的支持，性能也比较优良，resin 自身采用 JAVA 语言开发（收费，应用比较多）。
WebLogic：是 Oracle 公司的产品，是目前应用最广泛的 Web 服务器，支持 JavaEE 规范，而且不断的完善以适应新的开发要求，适合大型项目（收费，用的不多，适合大公司）

3.4 Tomcat服务器和Servlet版本的对应关系

3.5 Tomcat的使用

目录介绍：

bin 专门用来存放 Tomcat 服务器的可执行程序
conf 专门用来存放 Tocmat 服务器的配置文件
lib 专门用来存放 Tomcat 服务器的 jar 包
logs 专门用来存放 Tomcat 服务器运行时输出的日记信息
temp 专门用来存放 Tomcdat 运行时产生的临时数据
webapps 专门用来存放部署的 Web 工程。
work 是 Tomcat 工作时的目录，用来存放 Tomcat 运行时 jsp 翻译为 Servlet 的源码，和 Session 钝化的目录。

启动tomcat：

双击 Tomcat 目录下的 bin 目录下的 startup.bat 文件

关闭：

关闭命令行窗口
双击shutdown.bat

**注意：**黑屏闪退，需要配置好jdk环境变量

修改tomcat默认端口号：8080

tomcat目录下的conf下的server.xml配置文件

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

修改8080，改完需要重启

部署web项目：

拷贝项目到webapps目录下

访问：http://localhost:8080/工程名/目录/文件名

把html页面拖动到浏览器

使用的是file://协议

file协议表示告诉浏览器直接读取file：协议后面的路径，解析展示在浏览器上即可

使用http://ip:端口号/工程名/ 访问的区别

用的是http协议

请求响应过程

3.6 IDEA整合Tomcat

3.7 IDEA中动态Web工程

第4章：Servlet

4.1 Servlet技术

Servlet 是运行在服务器上的一个 java 小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。
Servlet 就 JavaWeb 三大组件之一。
三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器

手动实现servlet程序：

项目添加web支持
导入tomcat->lib目录下的servlet-api.jar包
实现Servlet接口
web.xml配置文件中配置

HelloServlet程序

public class HelloServlet implements Servlet {

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("Hello Servlet 被访问了");
    }

}

service方法是专门用来处理请求和响应

web.xml配置文件

<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.servlettest.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

访问

url访问

HelloServlet被访问了

web.xml配置解析：


    <!-- servlet标签给Tomcat配置Servlet程序 -->
    <servlet>
        <!--servlet-name标签 Servlet程序起一个别名（一般是类名） -->
        <servlet-name>HelloServlet</servlet-name>
        <!--servlet-class是Servlet程序的全类名-->
        <servlet-class>com.servlettest.HelloServlet</servlet-class>
    </servlet>

    <!--servlet-mapping标签给servlet程序配置访问地址-->
    <servlet-mapping>
        <!--servlet-name标签的作用是告诉服务器，我当前配置的地址给哪个Servlet程序使用-->
        <servlet-name>HelloServlet</servlet-name>
        <!--
            url-pattern标签配置访问地址                                     
               / 斜杠在服务器解析的时候，表示地址为：http://ip:port/工程路径          
               /hello 表示地址为：http://ip:port/工程路径/hello             
        -->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

访问过程：

客户端访问过程

Servlet生命周期：

执行 Servlet 构造器方法
执行 init 初始化方法
第一、二步，是在第一次访问，的时候创建 Servlet 程序会调用。
执行 service 方法第三步，每次访问都会调用。
执行 destroy 销毁方法第四步，在 web 工程停止的时候调用

get()和post()请求分发处理


public class HelloServlet implements Servlet {

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service HelloServlet被访问了");
       HttpServletRequest httpServletRequest= (HttpServletRequest)servletRequest;
        String method = httpServletRequest.getMethod();		//HttpServlet抽象类中实现了doGet和doPost方法

        if ("GET".equals(method)){
            doGet();
        }else if ("POST".equals(method)){
            doPost();
        }
    }


    public void doGet(){
        System.out.println("get请求");
        System.out.println("get请求");
    }

    public void doPost(){
        System.out.println("post请求");
        System.out.println("post请求");
    }
}

get请求

通过继承HttpServlet实现Servlet程序

继承HttpServlet类
重写doGet()或doPost()方法
web.xml中配置Servlet


public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HelloServlet的doGet方法");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HelloServlet的doPost方法");
    }
}

doget方法

Servlet继承体系

Servlet继承

4.2 ServletConfig类

Servlet 程序的配置信息类

ServletConfig 是每个 Servlet 程序创建时，就创建一个对应的 ServletConfig 对象。

ServletConfig类作用：

可以获取 Servlet 程序的别名 servlet-name 的值
获取初始化参数 init-param
获取 ServletContext 对象

web.xml


    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.servlettest.HelloServlet</servlet-class>
        
        <!--init-param是初始化参数-->
        <init-param>
            <!--是参数名-->
            <param-name>username</param-name>
            <!--是参数值-->
            <param-value>root</param-value>
        </init-param>
        <!--init-param是初始化参数-->
        <init-param>
            <!--是参数名-->
            <param-name>url</param-name>
            <!--是参数值-->
            <param-value>jdbc:mysql://localhost:3306/test</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>


public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HelloServlet的doGet方法");
    }


    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        super.init(servletConfig);
        System.out.println("init初始化方法");
        System.out.println("HelloServlet程序的别名：" + servletConfig.getServletName());
        System.out.println("初始化参数username:" + servletConfig.getInitParameter("username"));
        System.out.println("初始化参数url的值：" + servletConfig.getInitParameter("url"));
        System.out.println("servletContext对象:" + servletConfig.getServletContext());
    }
}

servletConfig获取参数

4.3 ServletContext接口

ServletContext 是一个接口，它表示 Servlet 上下文对象。
一个 web 工程，只有一个 ServletContext 对象实例。
ServletContext 对象是一个域对象。
ServletContext 是在 web 工程部署启动的时候创建。在 web 工程停止的时候销毁。

域对象：像Map一样存取对象，操作范围为整个web工程

	存数据	取数据	删除数据
Map	put()	get()	remove()
域对象	setAttribute()	getAttribute()	removeAttribute()

ServletContext接口作用：

获取 web.xml 中配置的上下文参数 context-param
获取当前的工程路径，格式:/工程路径
获取工程部署后在服务器硬盘上的绝对路径
像 Map 一样存取数据

web.xml

    <!--上下文参数，属于整个web工程-->
    <context-param>
        <param-name>username</param-name>
        <param-value>admin</param-value>
    </context-param>
    <context-param>
        <param-name>password</param-name>
        <param-value>123456</param-value>
    </context-param>

    <servlet>
        <servlet-name>ContextServlet</servlet-name>
        <servlet-class>com.servlettest.ContextServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ContextServlet</servlet-name>
        <url-pattern>/contextServlet</url-pattern>
    </servlet-mapping>


public class ContextServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取配置文件中上下文参数context-param
        ServletContext context = getServletConfig().getServletContext();

        String username = context.getInitParameter("username");
        String password = context.getInitParameter("password");


        System.out.println("context-param参数username 的值:"+username);
        System.out.println("context-param参数password 的值:"+password);

        System.out.println("当前工程名："+context.getContextPath());

        System.out.println("项目部署的路径是："+context.getRealPath("/"));
        System.out.println("项目css目录的绝对路径是："+context.getRealPath("/css"));
        System.out.println("项目imgs目录1.jpg的绝对路径是："+context.getRealPath("/imgs/1.jpg"));
    }
}

context获取参数

配置web.xml

ContextServlet1类


public class ContextServlet1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取servletContext对象
        ServletContext context = getServletContext();
        System.out.println(context);
        System.out.println("保存之前：context获取key1的值："+context.getAttribute("key1"));

        context.setAttribute("key1","阿巴阿巴");

        System.out.println("context中获取域数据key1的值："+context.getAttribute("key1"));
    }
}

context域null

ContextServlet2类


public class ContextServlet2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取servletContext对象
        ServletContext context = getServletContext();

        System.out.println("context2中获取域数据key1的值："+context.getAttribute("key1"));
    }
}

context域

结论：域对象context范围为整个web工程

4.4 HTTP协议

所谓 HTTP 协议，就是指客户端和服务器之间通信时，发送的数据，需要遵守的规则。

HTTP 协议中的数据又叫报文。

GET 请求有哪些：

form 标签 method=get
a 标签
link 标签引入 css
Script 标签引入 js 文件
img 标签引入图片
iframe 引入 html 页面
在浏览器地址栏中输入地址后敲回车

POST 请求有哪些：

form 标签 method=post

Get请求说明：

get请求

Post请求说明：

post请求

常用请求头说明：

Accept: 表示客户端可以接收的数据类型
Accpet-Languege: 表示客户端可以接收的语言类型
User-Agent: 表示客户端浏览器的信息
Host：表示请求时的服务器 ip 和端口号

响应的HTTP协议格式：

响应HTTP协议

常用响应状态码：

响应状态码	表示
200	表示请求成功
302	表示请求重定向
404	表示请求服务器已经收到了，但是你要的数据不存在（请求地址错误）
500	表示服务器已经收到请求，但是服务器内部错误（代码错误）

4.5 HttpServletRequest类

**作用：**每次只要有请求进入 Tomcat 服务器，Tomcat 服务器就会把请求过来的 HTTP 协议信息解析好封装到 Request 对象中。然后传递到 service 方法（doGet 和 doPost）中给我们使用。我们可以通过 HttpServletRequest 对象，获取到所有请求的信息。

常用方法：

方法	说明
getRequestURI()	获取请求的资源路径
getRequestURL()	获取请求的统一资源定位符（绝对路径
getRemoteHost()	获取客户端的 ip 地址
getHeader()	获取请求头
getParameter()	获取请求的参数
getParameterValues()	获取请求的参数（多个值的时候使用）
getMethod()	获取请求的方式 GET 或 POST
setAttribute(key, value);	设置域数据
getAttribute(key);	获取域数据
getRequestDispatcher()	获取请求转发对象


public class RequestAPIServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("请求的资源路径URI:"+req.getRequestURI());
        System.out.println("URL:"+req.getRequestURL());
        System.out.println("客户端IP地址："+req.getRemoteHost());
        System.out.println("请求头User-Agent:"+req.getHeader("User-Agent"));
        System.out.println("请求的方式："+req.getMethod());

    }
}

request常用方法

获取请求的参数：


public class ParameterServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取请求参数
        String username = req.getParameter("username");
        
         //解决乱码
        //1.先以iso-8859-1进行编码
        //2.再以utf-8进行编码
        username=new String(username.getBytes("iso-8859-1"),"UTF-8");
        
        String password = req.getParameter("password");
        String[] hobby = req.getParameterValues("hobby");

        System.out.println("用户名：" + username);
        System.out.println("密码：" + password);
        System.out.println("兴趣爱好：" + Arrays.asList(hobby));
    }
}

user.html


<body>
<form action="http://localhost:8080/netStudy/parameterServlet" method="get">
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    兴趣爱好：<input type="checkbox" name="hobby" value="cpp">C++
    <input type="checkbox" name="hobby" value="java">Java
    <input type="checkbox" name="hobby" value="js">JavaScript<br>
    <input type="submit">
</form>
</body>

访问user.html

获取表单参数

当采用post请求方式时会产生乱码问题：

post张三

post乱码

解决：doPost()方法首行设置字符集

req.setCharacterEncoding("UTF-8");

请求转发：

请求转发是指，服务器收到请求后，从一次资源跳转到另一个资源的操作叫请求转发。

请求转发

base标签的作用：

base标签

base标签设置页面相对路径工作时参照的地址

<base href="http://localhost:8080/07_servlet/a/b/">

Web中相对路径和绝对路径

相对路径是：
- . 表示当前目录
- … 表示上一级目录
- 资源名表示当前目录/资源名
绝对路径： http://ip:port/工程路径/资源路径

实际开发用绝对路径：

绝对路径
base+相对

/的不同意义：

/被浏览器解析，得到地址：http://ip:port/

<a href="/">斜杠</a>

/被服务器解析，得到地址：http://ip:port/工程路径

<url-pattern>/servlet1</url-pattern> 
servletContext.getRealPath(“/”); 
request.getRequestDispatcher(“/”);

重定向把/发送给浏览器，得到地址：http://ip:port/

 response.sendRediect(“/”);

4.6 HttpServletResponse类

**作用：**每次请求进来，Tomcat 服务器都会创建一个 Response 对象传递给 Servlet 程序去使用。HttpServletRequest 表示请求过来的信息，HttpServletResponse 表示所有响应的信息，我们如果需要设置返回给客户端的信息，都可以通过 HttpServletResponse 对象来进行设置。

两个输出流

流	方法	说明
字节流	getOutputStream();	常用于下载（传递二进制数据
字符流	getWriter();	常用于回传字符串（常用）

两个流同时只能使用一个，否则报异常

往客户端回传数据


public class ResponseIOServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {


        // 它会同时设置服务器和客户端都使用UTF-8字符集，还设置了响应头
        // 此方法一定要在获取流对象之前调用才有效
        resp.setContentType("text/html; charset=UTF-8");


//        要求 ： 往客户端回传 字符串 数据。
        PrintWriter writer = resp.getWriter();
        writer.write("你好，我叫张三");
    }
}

你好我叫张三

请求重定向

resp.sendRedirect("http://localhost:8080");

第5章：jsp

5.1 什么是jsp

JSP( javaserverpages)：Java 的服务器页面

主要作用：代替 Servlet 程序回传 html 页面的数据。

public class PringHtml extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		//JspWriter

        // 通过响应的回传流回传html页面数据
        resp.setContentType("text/html; charset=UTF-8");
        PrintWriter writer = resp.getWriter();
        writer.write("<!DOCTYPE html>\r\n");
        writer.write("  <html lang=\"en\">\r\n");
        writer.write("  <head>\r\n");
        writer.write("      <meta charset=\"UTF-8\">\r\n");
        writer.write("      <title>Title</title>\r\n");
        writer.write("  </head>\r\n");
        writer.write(" <body>\r\n");
        writer.write("    这是html页面数据 \r\n");
        writer.write("  </body>\r\n");
        writer.write("</html>\r\n");
        writer.write("\r\n");

    }
}

网页源码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    这是html页面数据

</body>
</html>

5.2 jsp的本质

jsp 页面本质上是一个 Servlet 程序。

当我们第一次访问 jsp 页面的时候。Tomcat 服务器会帮我们把 jsp 页面翻译成为一个 java 源文件。并且对它进行编译成为.class 字节码程序。

5.3 jsp的三种语法

jsp头部page指令

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

language 属性表示 jsp 翻译后是什么语言文件。暂时只支持 java。

contentType 属性表示 jsp 返回的数据类型是什么。也是源码中 response.setContentType()参数值
pageEncoding 属性表示当前 jsp 页面文件本身的字符集。
import 属性跟 java 源代码中一样。用于导包，导类。
autoFlush 属性设置当 out 输出流缓冲区满了之后，是否自动刷新冲级区。默认值是 true。
buffer 属性设置 out 缓冲区的大小。默认是 8kb
errorPage 属性设置当 jsp 页面运行时出错，自动跳转去的错误页面路径
isErrorPage 属性设置当前 jsp 页面是否是错误信息页面。默认是 false。如果是 true 可以获取异常信息。
session 属性设置访问当前 jsp 页面，是否会创建 HttpSession 对象。默认是 true。
extends 属性设置 jsp 翻译出来的 java 类默认继承谁。

jsp中常用脚本

声明脚本

<%!
	private Integer id; 
    private String name; 
    private static Map<String,Object> map;
%>

作用：可以给 jsp 翻译出来的 java 类定义属性和方法甚至是静态代码块，内部类等。

表达式脚本

<%=12 %> <br> 
<%=12.12 %> <br> 
<%="我是字符串" %> <br> 
<%=map%> <br> 
<%=request.getParameter("username")%>

所有的表达式脚本都会被翻译到_jspService() 方法中_
表达式脚本都会被翻译成为 out.print()输出到页面上
由于表达式脚本翻译的内容都在_jspService() 方法中,所以_jspService()方法中的对象都可以直接使用。
表达式脚本中的表达式不能以分号结束。

代码脚本

<%
for (int j = 0; j < 10; j++) {
%>
<tr> 
    <td>第 <%=j + 1%>行</td> 
</tr>
<%
	}
%>

代码脚本的作用是：可以在 jsp 页面中，编写我们自己需要的功能（写的是 java 语句）。

<%-- 这是jsp注释 --%>

5.4 jsp九大内置对象

是指 Tomcat 在翻译 jsp 页面成为 Servlet 源代码后，内部提供的九大对象，叫内置对象。

5.5 四大域对象

域对象	所属类	范围
pageContext	(PageContextImpl 类)	当前 jsp 页面范围内有效
request	(HttpServletRequest 类)、	一次请求内有效
session	(HttpSession 类)、	一个会话范围内有效（打开浏览器访问服务器，直到关闭浏览器）
application	(ServletContext 类)	整个 web 工程范围内都有效（只要 web 工程不停止，数据都在）

域对象是可以像 Map 一样存取数据的对象。四个域对象功能一样。不同的是它们对数据的存取范围。

从小到大范围顺序：

pageContext =>>> request =>>> session =>>> application

5.6 jsp中out输出和response.getWriter区别

response 中表示响应，我们经常用于设置返回给客户端的内容（输出）
out 也是给用户做输出使用的。
- out.write() 输出字符串没有问题
- out.print() 输出任意数据都没有问题（都转换成为字符串后调用的 write 输出）

5.7 jsp常用标签

jsp静态包含

静态包含不会翻译被包含的jsp页面

把被包含的jsp页面代码拷贝到包含的位置执行输出

<%@ include file="/include/footer.jsp"%>

jsp动态包含

会把包含的jsp页面也翻译成java代码

还可以传递参数

<jsp:include page="/include/footer.jsp"> 
    <jsp:param name="username" value="bbj"/> 
    <jsp:param name="password" value="root"/> 
</jsp:include>

动态包含原理：

jsp标签-转发

请求转发

<jsp:forward page="/scope2.jsp"></jsp:forward>

5.8 Listener监听器

JavaWeb 的三大组件：

Servlet 程序
Filter 过滤器
Listener 监听器。

监听某种事物的变化。然后通过回调函数，反馈给客户（程序）去做一些相应的处理

ServletContextListener 监听器

ServletContextListener 它可以监听 ServletContext 对象的创建和销毁。
ServletContext 对象在 web 工程启动的时候创建，在 web 工程停止的时候销毁。
监听到创建和销毁之后都会分别调用 ServletContextListener 监听器的方法反馈。

public interface ServletContextListener extends EventListener {
    //ServletContext对象创建之后调用，做初始化
    default void contextInitialized(ServletContextEvent sce) {
        
    }

    //ServletContex对象销毁之后调用
    default void contextDestroyed(ServletContextEvent sce) {
        
    }
}

使用：

编写一个类去实现 ServletContextListener
实现其两个回调方法
到 web.xml 中去配置监听器

<!-配 置 监 听 器 --> 
<listener> 
  <listenerclass>com.wgg.MyServletContextListenerImpl</listener-class> 
</listener>

第6章：EL表达式和JSTL标签库

6.1 EL表达式

EL 表达式的全称是：Expression Language。是表达式语言。
EL 表达式的作用**：EL 表达式主要是代替 jsp 页面中的表达式脚本在 jsp 页面中进行数据的输出。
EL 表达式的格式是：${表达式}
EL 表达式在输出 null 值的时候，输出的是空串。
jsp 表达式脚本输出 null 值的时候，输出的是 null 字符串。
EL 表达式主要是在 jsp 页面中输出数据。主要是输出域对象中的数据


public class Person {

    private String name;
    private String[] phones;
    private List<String> cities;
    private Map<String,Object> map;

}

<body>
    <%
        Person person = new Person();
        person.setName("张三");
        person.setPhones(new String[]{"18610541354","18688886666","18699998888"});

        List<String> cities = new ArrayList<String>();
        cities.add("北京");
        cities.add("上海");
        cities.add("深圳");
        person.setCities(cities);

        Map<String,Object>map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        person.setMap(map);

        pageContext.setAttribute("p", person);
    %>

    输出Person：${ p }<br/>
    输出Person的name属性：${p.name} <br>
    输出Person的pnones数组属性值：${p.phones[2]} <br>
    输出Person的cities集合中的元素值：${p.cities} <br>
    输出Person的List集合中个别元素值：${p.cities[2]} <br>
    输出Person的Map集合: ${p.map} <br>
    输出Person的Map集合中某个key的值: ${p.map.key3} <br>
    输出Person的age属性：${p.age} <br>


</body>

6.5 EL运算

emty运算

empty 运算可以判断一个数据是否为空，如果为空，则输出 true,不为空输出 false。
以下几种情况为空：

值为 null 值的时候，为空
值为空串的时候，为空
值是 Object 类型数组，长度为零的时候
list 集合，元素个数为零 5、map 集合，元素个数为零

6.6 11个隐含对象

变量	类型	说明
pageContext	PageContextImpl	它可以获取 jsp 中的九大内置对象
pageScope	Map<String,Object>	它可以获取 pageContext 域中的数据
requestScope	Map<String,Object>	它可以获取 Request 域中的数据
sessionScope	Map<String,Object>	它可以获取 Session 域中的数据
applicationScope	Map<String,Object>	它可以获取 ServletContext 域中的数据
param	Map<String,String>	它可以获取请求参数的值
paramValues	Map<String,String[]>	它也可以获取请求参数的值，获取多个值的时候使用
header	Map<String,String>	它可以获取请求头的信息
headerValues	Map<String,String[]>	它可以获取请求头的信息，它可以获取多个值的情况
cookie	Map<String,Cookie>	它可以获取当前请求的 Cookie 信息
initParam	Map<String,String>	它可以获取在 web.xml 中配置的上下文参数

pageContext 对象的使用

<body>
    <%--
    request.getScheme() 它可以获取请求的协议
    request.getServerName() 获取请求的服务器ip或域名
    request.getServerPort() 获取请求的服务器端口号
    getContextPath() 获取当前工程路径
    request.getMethod() 获取请求的方式（GET或POST）
    request.getRemoteHost()  获取客户端的ip 地址
    session.getId() 获取会话的唯一标识
    --%>
    <%
        pageContext.setAttribute("req", request);
    %>
    <%=request.getScheme() %> <br>
    1.协议： ${ req.scheme }<br>
    2.服务器ip：${ pageContext.request.serverName }<br>
    3.服务器端口：${ pageContext.request.serverPort }<br>
    4.获取工程路径：${ pageContext.request.contextPath }<br>
    5.获取请求方法：${ pageContext.request.method }<br>
    6.获取客户端ip地址：${ pageContext.request.remoteHost }<br>
    7.获取会话的id编号：${ pageContext.session.id }<br>

</body>

6.7 JSTL标签库

JSTL 标签库全称是指 JSPStandardTagLibrary JSP 标准标签库。

6.8 JSTL使用

导入jstl的jar包
taglib指令

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

6.9 core核心库使用

`<c:set/>`:往域中保存数据

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

`<c:if/>`：判断

<c:if test="${ 12 == 12 }"> 
    <h1>12 等于 12</h1> 
</c:if>

`<c:choose><c:when><c:otherwise>`：多路判断，可以嵌套

<c:choose> 
    <c:when test="${requestScope.height > 160}"> 
        <h3>大于 160</h3> </c:when> 
    <c:when test="${requestScope.height > 150}"> 
        <h3>大于 150</h3> </c:when> 
    <c:when test="${requestScope.height > 140}"> 
        <h3>大于 140</h3> </c:when> 
    <c:otherwise> 其他小于 140 </c:otherwise> 
</c:choose

<c:forEach/>

<table border="1"> 
    <c:forEach begin="1" end="10" var="i"> 
        <tr> 
            <td>第${i}行</td> 
        </tr> 
    </c:forEach> </table>

<c:forEach items="${ requestScope.arr }" var="item"> 
    ${ item } <br> 
</c:forEach>

第7章：cookie和session

7.1 什么是cookie

Cookie 是服务器通知客户端保存键值对的一种技术。
客户端有了 Cookie 后，每次请求都发送给服务器。
每个 Cookie 的大小不能超过 4kb

7.2 创建cookie

 protected void createCookie(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1 创建Cookie对象
        Cookie cookie = new Cookie("key4", "value4");
        //2 通知客户端保存Cookie
        resp.addCookie(cookie);
        //1 创建Cookie对象
        Cookie cookie1 = new Cookie("key5", "value5");
        //2 通知客户端保存Cookie
        resp.addCookie(cookie1);

        resp.getWriter().write("Cookie创建成功");
    }

7.3 服务器如何获取cookie

修改cookie值：

方案一：

先创建一个要修改的同名（指的就是 key）的 Cookie 对象
在构造器，同时赋于新的 Cookie 值。
调用 response.addCookie(Cookie);

方案二：

先查找到需要修改的 Cookie 对象
调用 setValue()方法赋于新的 Cookie 值。
调用 response.addCookie()通知客户端保存修改

cookie生命控制

setMaxAge()

正数，表示在指定的秒数后过期
负数，表示浏览器一关，Cookie 就会被删除（默认值是-1）
零，表示马上删除 Cookie

cookie.setMaxAge(60 * 60); //设置一小时后删除/无效

使用cookie实现免用户名登录

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="http://localhost:8080/13_cookie_session/loginServlet" method="get">
        用户名：<input type="text" name="username" value="${cookie.username.value}"> <br>
        密码：<input type="password" name="password"> <br>
        <input type="submit" value="登录">
    </form>
</body>
</html>

public class LoginServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        if ("wgg".equals(username) && "123456".equals(password)) {
            //登录 成功
            Cookie cookie = new Cookie("username", username);
            cookie.setMaxAge(60 * 60 * 24 * 7);//当前Cookie一周内有效
            resp.addCookie(cookie);
            System.out.println("登录 成功");
        } else {
//            登录 失败
            System.out.println("登录 失败");
        }

    }
}

7.4 什么是session

Session 就一个接口（HttpSession）。
Session 就是会话。它是用来维护一个客户端和服务器之间关联的一种技术。
每个客户端都有自己的一个 Session 会话。
Session 会话中，我们经常用来保存用户登录之后的信息。

session的创建和修改：

request.getSession()

第一次调用是：创建 Session 会话
之后调用都是：获取前面创建好的 Session 会话对象。

isNew();

判断到底是不是刚创建出来的（新的）

true 表示刚创建
false 表示获取之前创建

每个会话都有一个身份证号。也就是 ID 值。而且这个 ID 是唯一的。 getId() 得到 Session 的会话 id 值

       protected void setAttribute(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.getSession().setAttribute("key1", "value1");
        resp.getWriter().write("已经往Session中保存了数据");

    }
   protected void getAttribute(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object attribute = req.getSession().getAttribute("key1");
        resp.getWriter().write("从Session中获取出key1的数据是：" + attribute);
    }

session生命周期：

public void setMaxInactiveInterval(intinterval) 设置 Session 的超时时间（以秒为单位），超过指定的时长，Session 就会被销毁。
1. 值为正数的时候，设定 Session 的超时时长。
2. 负数表示永不超时（极少使用）
public int getMaxInactiveInterval()获取 Session 的超时时间
public void invalidate()让当前 Session 会话马上超时无效
Session 默认的超时时间长为 30 分钟。可以配置

7.5 cookie和session原理

第8章：Filter过滤器

8.1 什么是Filter过滤器

三大组件分别是：

Servlet 程序
Listener 监听器
Filter 过滤器

**作用：**拦截请求，过滤响应

8.2 Filter的使用

Filter 过滤器的使用步骤：

编写一个类去实现 Filter 接口
实现过滤方法 doFilter()
到 web.xml 中去配置 Filter 的拦截路径

public class AdminFilter implements Filter {

    //doFilter方法，专门用于拦截请求，可以做权限检查
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;

        HttpSession session = httpServletRequest.getSession();
        Object user = session.getAttribute("user");
        if (user==null){
            servletRequest.getRequestDispatcher("/login.jsp").forward(servletRequest,servletResponse);
            return;
        }else {
            //让程序继续往下访问用户的目标资源
            filterChain.doFilter(servletRequest,servletResponse);
        }
        System.out.println("好家伙，竟然执行到这里了");
    }
}

 <filter>
        <filter-name>AdminFilter</filter-name>
        <filter-class>com.servlettest.AdminFilter</filter-class>
    </filter>
    <filter-mapping>
        <!--当前的拦截路径给哪个filter使用-->
        <filter-name>AdminFilter</filter-name>
        <!--配置拦截路径-->
        <!--http://ip:port/工程路径/admin/static/login_success.jsp-->
        <url-pattern>/static/login_success.jsp</url-pattern>
    </filter-mapping>

8.3 Filter的生命周期

构造器方法
init 初始化方法第 1，2 步，在 web 工程启动的时候执行（Filter 已经创建）
doFilter 过滤方法第 3 步，每次拦截到请求，就会执行
destroy 销毁第 4 步，停止 web 工程的时候，就会执行（停止 web 工程，也会销毁 Filter 过滤器）

8.4 FilterConfig类

Filter 过滤器的配置文件类。

作用：

获取 Filter 的名称 filter-name 的内容
获取在 Filter 中配置的 init-param 初始化参数
获取 ServletContext 对象

8.5 FilterChain过滤器链

FilterChain 就是过滤器链（多个过滤器如何一起工作）

8.6 Filter的拦截路径

精确匹配

<url-pattern>/target.jsp</url-pattern>

以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/target.jsp

目录匹配

<url-pattern>/admin/*</url-pattern>

以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/admin/*

后缀名匹配

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

以上配置的路径，表示请求地址必须以.html 结尾才会拦截到

<url-pattern>*.do</url-pattern>

以上配置的路径，表示请求地址必须以.do 结尾才会拦截到

<url-pattern>*.action</url-pattern>

以上配置的路径，表示请求地址必须以.action 结尾才会拦截到
Filter 过滤器它只关心请求的地址是否匹配，不关心请求的资源是否存在

第9章：JSON、AJAX、i18n

9.1 JSON

json 是一种轻量级的数据交换格式。

轻量级指的是跟 xml 做比较。

数据交换指的是客户端和服务器之间业务数据的传递格式。

json对象示例：

var jsonObj = { "key1":12, 
               "key2":"abc", 
               "key3":true, 
               "key4":[11,"arr",false], 
               "key5":{ "key5_1" : 551, "key5_2" : "key5_2_value" }, 
               "key6":[{ "key6_1_1":6611, "key6_1_2":"key6_1_2_value"},
                       { "key6_2_1":6621,"key6_2_2":"key6_2_2_value" }]
};

json对象和json字符串之间的转换

jString=JSON.stringify()		//转换成为 json 字符串

jObj=JSON.parse()			//转换成为 json 对象

javaBean和json字符串之间转换

 Person person = new Person();
// 创建Gson对象实例
Gson gson = new Gson();
// toJson方法可以把java对象转换成为json字符串
String personJsonString = gson.toJson(person);

 // fromJson把json字符串转换回Java对象
Person person1 = gson.fromJson(personJsonString, Person.class);

9.2 AJAX请求

异步 JavaScript 和 XML，是指一种创建交互式网页应用的网页开发技术。

ajax 是一种浏览器通过 js 异步发起请求，局部更新页面的技术。
Ajax 请求的局部更新，浏览器地址栏不会发生变化
局部更新不会舍弃原来页面的内容

jQuery中的Ajax请求

$.ajax 方法
url	表示请求的地址
type	表示请求的类型 GET 或 POST 请求
data	表示发送给服务器的数据一：name=value&name=value 二：{key:value}
success	请求成功，响应的回调函数
dataType	响应的数据类型 text/xml/json