JSP学习笔记

我们在学习之前，肯定要把环境搭建好，这是我的IDEA 环境搭建，当然也有Eclipse 环境搭建。
我的环境是：

• Win7 64bit
• Java 8
• tomcat 9.0
• MySql 5.7
• IDEA 2018.2
• Eclipse 2018 9

学习JSP的前提：有一定的html基础、有一定的Java编程基础、对网络懂一些、最后是有一定的计算机基础。

---

Web服务器和客户端

1.web服务器有很多种比如：IIS是微软的Web服务器，WebSphere（WebSphere Application Server）是IBM公式基于Java构建的，BEA WebLogic Server是一种多功能、基于标准的Web应用服务器，Apache是全球使用量最多的Web服务器，Tomcat是一个开放源代码、运行Servlet和JSP Web应用软件的基于Java的Web应用软件容器。Tomcat遵从Servlet和JSP规范，是基于Apache许可证开发的自由软件。随着Catalina Servlet引擎的出现，Tomcat第4版的性能得到提升，成为一个值得考虑的Servlet/JSP容器。因此，目前基于Java的Web应用都采用Tomcat作为Web服务器。

2.客户端是指用户计算机为用户提供本地服务的程序。通常是指用户计算机上的网页浏览器。

C/S结构
即Client/Server（客户端/服务器）结构。这种结构的出现是为了解决费用和性能的矛盾。存在的问题是：（1）必须安装专用的客户端软件，如果客户端的数量较多，则软件维护和升级的工作量较大，成本较高。（2）对客户端操作系统的限制。目前操作系统的更新换代较快，存在新的操作系统不兼容的问题，需要针对不同的操作系统提供不同的客户端软件版本，这也大大提高了软件开发和维护的成本。

B/S结构
即Browser/Server（浏览器/服务器）结构。是Web兴起后的一种网络结果模式。这种结构中，客户端使用一个通用的浏览器，代替形形色色的各种客户端软件，用户的所有操作都是通过浏览器进行的。特点是：使用相对简单、维护方便、对客户端硬件要求低、能充分利用现有资源。

---

静态网页与动态网页

静态网页是指网页的内容是固定的，不会根据浏览器的不同需求而改变。特点如下：
（1）静态网页是实实在在保存在服务器的文件，每个网页都是一个独立的文件。
（2）静态网页的内容相对稳定，因此容易被搜索引擎检索
（3）静态网页没有数据库支持，在网站制作和维护方面工作量较大，一次当网站信息量很大时完全依靠静态网页发布信息是非常困难的。
（4）静态网页的交互性差，在功能方面有较大的限制。

动态网页一般是在服务器端运行的程序、网页、组件等，它们会根据不同用户、不同时间返回不同的内容。特点如下：
（1）动态网页以数据库技术为基础，可以大大减少网站维护的工作量。
（2）采用动态Web技术的网站可以实现更多功能，如用户注册、用户登录、在线调查、用户管理很订单管理等。
（3）动态网页并不是独立在于服务器上的文件，只有当用户请求时服务器才返回一个完整的页面。

-静态网页和动态网页各有特点，采用动态网页还是静态网页主要取决于网站的功能需求和网站内容的多少。如果网站功能比较简单，内容更新量不是很大，采用纯静态网页的方式会简单；反之，则可以采用动态网页技术来实现。静态网页是网站建设的基础，静态网页和动态网页之间也并不矛盾，为了网站适应搜索引擎检索的需要和加快网页访问速度，即使采用动态网页技术，也可以将页面内容转换为静态网页发布。

-动态网站也可以采用动静结合的方法，适合动态网页的地方就使用动态网页，有必要使用静态网页的地方则考虑使用静态网页的方法来实现。在一个网站的建设过程中，动静结合的方法随处可见。

---

动态Web技术
实现动态网页必须采用动态Web技术。目前，常用的动态Web技术有JSP、PHP 和 ASP.NET。

JSP
JSP（Java Sever Pages）是sun公司于1999年6月推出的新一代动态网站开发技术，JSP在Servelt和JavaBean支持下，将网页逻辑与网页显示分离，支持可重用的基于组件的设计，使基于Web的应用开发变得更加简单快速。

Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户端浏览器。插入的Java程序段可以操作数据库、重定向网页等，以实现建立动态网页所需要的功能。JSP和Java Servlet一样、在服务器端执行，返回给客户端一个HTML文本。

JSP主要技术特点如下：

 -一次编写，各处运行。JSP作为Java平台的一部分，具有Java技术的所有特点，
 也包括Java程序语言“一次编写，各处运行”的特点
 
 -系统的多平台支持。用JSP开发的Web应用是跨平台的，既能在Linux下运行，
 也能在其他操作系统下运行
 
 -强大的可伸缩性。从只要一个小的Jar包就可以运行Servlet/JSP，到由多台服
 务器集群和负载均衡，再到多台应用服务器进行事务处理、消息处理等，充分展
 示了JSP所在Java平台的强大生命力
 
 -多样化和功能强大的开发工具支持。Java已经有了许多非常优秀的开发工具，如
 Eclipse、WebStorm、MyEclipse等

PHP
PHP是一种跨平台的服务器端的嵌入式脚本语言，它大量借用C、Java和Perl语言的语法，并耦合PHP自己的特性，使用Web开发者能够快速地开发Web应用程序。
特点如下：

-开发的源代码，免费使用
-跨平台性
-数据库连接方便
-语言简单
-效率高
-便于图像处理，使用PHP可以动态创建图像

ASP.NET
ASP.NET 是 .NET Framework的一部分，是一种使嵌入式网页中的脚本可由Web服务器执行的服务器端脚本技术，可以在通过HTTP请求文档时在Web服务器上动态创建。使用ASP.NET技术创建的动态网页运行于IIS之上，可以使用Microsoft的Visual Studio.NET开发环境进行开发，是一种所见即所得的开发环境。ASP.NET技术的特点主要如下：

-开发语言，ASP.NET允许用户选择使用功能完善的编程语言，如C#、J#等，运行
使用 .NET Framework

-运行机制，ASP.NET采用编译性的编程框架，运行的是服务器上编译好的公共语
言运行时库代码，可以利用早起绑定、实时编译来提高效率

-开发方式，ASP.NET把界面设计和程序逻辑以不同的文件分离开，复用性和可维
护性都得到了提高

对比PHP 、JSP、ASP.NET这三种动态Web技术，JSP的优势在于企业级应用；PHP的优势在于轻量级Web应用。两者的共同优势在于，一方面二者都可以跨平台部署，另一方面比起ASP.NET来更轻巧和精简。PHP的安装包，加上Apache服务器，只用几十兆；JSP更是只需JDK和App Server即可，加一起也就一百多兆。相反，ASP.NET的安装包不仅只能部署在Windows下面，并且需要.NET Framework的支持，经常大于1GB，这也给应用者带来了极大的困惑和不便。

至于下载和安装这里就不在说了，前面也给出了，如果没有的话可以到我的博客里面去找一下。

---

Tomcat基础知识

Tomcat安装目录下包含了一系列文件和文件夹：

bin：存放了启动和关闭Tomcat的脚本文件
conf：存放Tomcat的各种配置文件。其中，server.xml和web.xml是主要的
两个配置文件
lib：存放Tomcat运行时所需要的各种JAR文件
logs：存放Tomcat每次运行后产生的日志文件
temp：存放Web应用运行过程中生成的临时文件
webapps：存放Web项目的目录。发布Web项目时，默认将要发布的Web
项目存放在此。
work：存放由JSP生成的Servlet源文件和字节码文件，有Tomcat自动生成

---

JSP基础知识

JSP页面执行过程
转载地址

JSP 页面其实是一个Servlet。JSP 页面是在JSP 容器中运行的。Servlet 容器一般也是JSP 容器。例如， Tomcat 就是一个Servlet/JSP 容器。

第一次请求一个JSP 页面肘， Servlet/JSP 容器要做两件事情：

1. 将JSP 页面转换成一个J SP 页面实现类，这是一个实现javax.servlet.p.JspPage接口或其子接口javax.servlet.p.HttpjspPage 的Java 类。JspPage是javax.servlet.Servlet的子接口， 这样会使每个JSP 页面都成为一个Servlet . 所生成Servlet 的类名取决于Servlet/JSP 容器。这一点不必操心，因为不需要你直接处理。如果有转换错误，错误消息将会发送到客户端。

2. 如果转换成功， Servlet/JSP 容器将会编译Servlet 类。之后，容器加载和实例化J ava字节码，并执行它通常对Servlet 所做的生命周期操作。

对于同一个JSP 页面的后续请求， Servlet/JSP 容器会查看这个JSP 页面自从最后一次转换以来是否修改过。如果修改过，就会重新转换、重新编译，并执行。如果没有，则执行内存中已经存在的JSP Servlet 。这样，第一次调用JSP 页面的时间总是会比后续请求的更长，因为它需要转换和编译。为了解决这个问题，可以采取以下任意一种措施：

配置应用程序，以便在应用程序启动之时，调用所有的JSP 页面〈实际上是指转换和编译） ， 而不是在初始请求时才调用。

预先编译JSP页面，并将它们以Servlet 的方式进行部署。

Servlet与JSP生命周期对比
Servlet的生命周期：

1）构造方法（第1次访问）

2）init方法（第1次访问）

3）service方法

4）destroy方法

Jsp的生命周期

1）翻译： jsp->java文件

2）编译： java文件->class文件（servlet程序）

3）构造方法（第1次访问）

4）init方法（第1次访问）：_jspInit()

5）service方法：_jspService()

6）destroy方法：_jspDestroy()

Jsp的最佳实践
Servlet技术： 开发动态资源。是一个java类，最擅长写java代码

jsp技术： 开发动态资源。（通过java代码）最擅长输出html代码。

各取所长：

在web项目中涉及到逻辑：

1）接收参数 servlet做

2）处理业务逻辑，返回结果 servlet做

3）显示数据到浏览器 jsp做

4）跳转到其他页面 servlet做

servlet+jsp模式

servlet:

        1）接收参数

        2）处理业务逻辑

        3）把结果保存到域对象中

        4）跳转到jsp页面

Jsp:

        1）从域对象取出数据

        2）把数据显示到浏览器

---

JSP页面基本结构

JSP页面通常由以下基本元素组成。

HTML 标记
JSP 声明
JSP 程序片
JSP 表达式
JSP 注释
JSP 指令
JSP 动作

JSP 声明
在JSP中，声明一段Java源程序，用来定义变量和方法 语法如下：

<%! [Declarations;]+ %>

1.成员声明

在JSP声明语句块中，允许定义任意类型的变量。
在JSP声明语句块中定义的变量，我们称为成员变量

成员在整个JSP页面内都有效，与JSP声明的位置无关。（但习惯把声明语句块放到
最前面）
JSP声明的变量作为类的成员变量，其生命周期直到JSP引擎关闭才结束。当多个用
户请求同一个JSP页面时，JSP引擎会为每个用户启动一个线程，这些线程由JSP引
擎服务器管理，且共享JSP页面的成员变量。某个用户对JSP页面成员变量的操作会
影响其他用户。

下面有一段演示

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%!int count = 0;%>
	<%
		out.print("您是第" + (++count) + "个访问本站的用户.");
	%>
</body>
</html>

这个JSP页面作用是，页面访问人数的统计，每访问一次，次数就会加1.

2.声明方法
使用JSP声明方法与声明变量一样，在整个JSP页面中有效。生命的方法可以在JSP页面的任意位置被调用。

下面是一段，效果同上的JSP页面，但它是方法实现的。

<%@page import="com.sun.org.apache.regexp.internal.recompile"%>
<%@page import="org.eclipse.jdt.internal.compiler.ast.ThisReference"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>人数统计</title>
</head>
<body>
	<%!int count = 0;

	private int add() {
		return ++count;
	}%>

	<%="您是第" + add() + "个访问本站的用户."%>

</body>
</html>

JSP程序片
JSP程序片是指在JSP中嵌入的Java程序片段，它使得JSP直接具有Java编程功能。程序片只能位于<%和%>之间，语法：

<% code fragment %>

一个JSP页面可以有许多Java程序片段，JSP引擎按顺序执行这些Java程序片段。在Java程序片中定义的变量成为JSP页面的局部变量，局部变量的有效范围与其声明的位置有关，即局部声明变量在JSP页面后继的所有Java程序片段及表达式中有效。

局部变量与成员变量的区别是，局部变量是单个用户的，而成员变量是所有用户共享的变量（其实就是类变量）

“%> <%” 可用于插入标签，如下：

<%@page import="com.sun.org.apache.regexp.internal.recompile"%>
<%@page import="org.eclipse.jdt.internal.compiler.ast.ThisReference"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>人数统计</title>
</head>
<body>
	<%!static int count = 0;

	private int add() {
		return ++count;
	}%>

	<%
		
	%><p>
		您是第<%=add()%>个访问本站的用户.
	</p>
	<%
		
	%>

</body>
</html>

输出了p标签

JSP表达式
表达式在JSP请求处理阶段进行运算，运算所得的结果转换为字符串，并与模版数据结合。
JSP表达式在页面的位置就是该表达式计算结果显示的位置。语法如下：

<%=expression  %>

源码：

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%
		int a = 3, b = 9;
	%>
	计算表达式<%=a %>&lt<%=b %>的值为<%=a<b %>
</body>
</html>

JSP注释

1.输出注释
<!-- 注释内容  -->
2.隐藏注释
<%--  注释内容 --%>

JSP指令
JSP指令主要用于提供整个JSP页面的相关信息，指令并不向客户端产生任何输出，所有的指令都只在当前页面中有效。语法如下：

<%@directive {attr="value"}* %>

在JSP中常用的指令有三种：page指令、include指令、taglib指令

1.page指令
page指令作用于整个JSP页面，用来定义与页面相关的属性，包括导入包、指明输出内容类型、控制Session等一些与页面相关的信息。一个JSP页面可以包含一条或多条page指令。page指令中，同名属性只能出现一次，重复的同名属性将覆盖先前的设置。page指令中各属性的作用如下表。

1）import属性
import属性是为了JSP页面引入Java运行环境提供包中的类，这样可以在JSP页面的程序片段、变量方法定义部分及表达式部分使用包中的类。可以为属性设置多个值来引入多个包或类，包或类之间用逗号（,）隔开，如下：

<%@ import="java.io.*,java.util.Date" %>
<%@page import="java.math.*" %>

2）contentType属性和pageEncoding属性
contentType用于指定JSP输出内容的MIME类型和字符集。MIME类型通常由两部分组成，前面部分表示MIME类型，后面部分表示MIME子类型。如下：

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

其中text表示MIME类型，html表示MIME的子类型。
附上：关于MIME类型详细介绍 、MIME类型参考手册

如下：

<%@ page contentType="applicationi/msword"  %>

上述代码表示浏览器将启动本地的MS-Word应用程序来解析收到的信息。

<%@ page contentType="image/x-xbitmap"  %>

上述代表示浏览器将启动图形解码器来解析、执行收到的信息。

3)errorPage属性和isErrorPage属性
isErrorPage属性用于指明出现未被捕获的异常时，是否使用其他页面的错误处理。其实就是指定是否采用错误页…
errorPage属性用于指定当前JSP页面中出现未被捕获的异常时所要跳转的页面。如下：

<%@ page isErrorPage="true" %>
<%@ page errorPage="error.jsp" %>

上述代码表示当前JSP页面中出现错误时，会调到error.jsp页面，并由该页面处理。

4）buffer属性和autoFlush属性
buffer属性用于指定out对象向客户端输出内容时使用的缓冲区大小或者不使用缓冲区，其默认值为8KB。
autoFlush属性只能设置为true，默认也是true。设置为true表示正常输出，设置为false，当缓冲区溢出时，会导致一个意外错误的发生。
如果buffer设置为none，则autoFlush则必须为true

5）info属性
info属性用于指明JSP页面的一些说明信息，可以在JSP页面中使用getServletInfo()方法来获取info属性中设置的说明信息。

<%@ page info="Mess JSP" %>
<%=getServletInfo() %>

上述代码表示通过getServletInfo()方法获取info属性值并输出到浏览器。

6）isThreadSafa属性
isThreadSafa属性表示是否使用多线程，默认为true。
当isThreadSafa属性设置为false时，JSP页面同时一时刻只能响应一个用户线程的请求，其他用户线程必须排队等待。CPU要保证一个线程执行完毕后才会把使用权限给其他用户线程。

2.include指令
include指令用于在JSP页面中静态包含一个文件，该文件可以是JSP页面、HTML网页、文本文件或者一段Java代码。
使用include指令的JSP页面在转换时，JSP容器会在其中插入所包含的文本或代码，同时解析这个文件中的JSP语句，从而方便地实现代码的重用，提高代码的使用效率。
比如，每个JSP页面上可能需要一个导航条，以便用户在各个JSP页面之间进行切换，那么每个JSP页面都可以使用include指令在页面的适当位置整体嵌入一个相同的文件。（相同部分可以使用JSP的include指令插入…其实这就算是 一种偷懒吧！）
比如：

把time.jsp文件插入进来

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	现在的时间是：<%@include file="time.jsp" %>
</body>
</html>

输出时间

<%@page import="java.util.Date"%>
<%@page import="java.text.SimpleDateFormat"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%=new SimpleDateFormat("yyyy-MM-dd hh-mm-ss").format(new Date()) %>
</body>
</html>

3.taglib指令
taglib指令用来声明JSP文件使用了定义的标签，同时引用标签库，也指定了标签库的标签前缀。如下：

<%@ taglib uri="URITagLibrary" prefix="tagPrefix" %>

taglib指令的prefix属性用于指定这类自定义标签属于哪个标签库，即在同一个JSP页面中使用相同前缀的元素都属于这个标签库。
每个标签库都定义了一个默认的前缀，用在标签库的文档中或者JSP页面中插入自定义标签。所以，可以在JSP页面中使用诸如JSP、JSPX、JAVA之类的前缀。
taglib指令的uri属性为每个自定义标签找到对应的类。
JSP容器使用uri属性值来定位对应类的TLD文件。该文件中包含指定标签库中所有标签处理类的名称。

JSP动作
JSP动作是一种特殊的标签，它影响JSP页面运行时的功能。JSP动作标签可以将代码处理程序与特殊的JSP标签关联在一起。在JSP中，动作标签使用XML语法来表示，主要包括include、param、forward、useBean、getProperty、setProperty和plugin。

1）include动作
include动作允许在JSP页面被请求时包含一些其他资源，包括html页面、jsp页面等。语法如下：

<jsp:include page="{relativeURL|<%=expression %>}"></jsp:include>

或者

<jsp:include page="{relativeURL|<%=expression %>}">
	<jsp:param value="parameterValue" name="{parameterName 
	| <%=expression %>}"/>+
</jsp:include>

page属性：表示相对路径，或者表示相对路径表达式
param标签：用来将一个或者多个参数传递给被包含的页面
当include动作标签未包含param标签时，必须使用第一种格式。
include动作标签告诉JSP页面动态包含一个文件，在JSP页面运行时才将文件加入。
与include指令不同，当JSP引擎把JSP页面转译成Java文件时，不会把JSP页面中include动作标签所包含的文件与原JSP页面合并成一个新的JSP页面，而是在JSP运行是才包含进来。
include动作标签可以包含动态文件和静态文件，但两种包含文件的处理过程不同。
如果包含的是静态html文件，就将文件的内容直接发送到客户端，由客户端浏览器负责输出。
如果包含的是动态JSP文件，JSP引擎会执行这个文件，然后将执行结果发送到客户端，并由客户端浏览器负责输出。

虽然include动作标签和include指令的作用都是处理所包含的文件，但是他们的处理方式、处理时间等方面都有所不同。比较如下：

比较点	include指令	include动作
格式	<%@ include file="…" %>	<jsp:include page="…">
作用时间	页面转译期间	请求期间
包含内容	包含文件内容	不包含文件内容
影响主页面	会	不会
编译速度	较慢（被包含资源必须被解析）	较快
执行速度	较快	较慢（每次被包含资源必须被解析）
灵活性	较差	较好

2）param动作
param动作标签以“名称值”对的形式为其他JSP页面提供参数信息。param动作标签不能独立使用，需要作为include、forward、plugin标签的子标签来使用。语法如下：

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

name属性：参数名称
value属性：参数值

param的主要作用就是解决不同页面之间的传递值的问题！

当该标签与include的动作标签一起使用时，会将该标签中的值传递到include动作标签要加载的文件中去，被加载的JSP页面可以使用request对象获取include动作标签param子标签中name属性所提供的值。因此，include动作标签通过使用param子标签来处理加载的文件，比include指令更加灵活。

如下：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>圆的计算</title>
</head>
<body>
	<%
		double r = 3.0;
		%>
			<p>
			加载"计算.jsp"文件，圆的半径为<%=r %>，则
			</p>
			<jsp:include page="计算.jsp">
				<jsp:param value="<%=r %>" name="r"/>
			</jsp:include>		
		<%
	%>
	
	
</body>
</html>

上述代码中，有include动作标签，并使用了param传递值

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<hr>
	<%
		double r = Double.valueOf(request.getParameter("r"));
		%>
		<p>圆的周长为：<%=2*r*Math.PI %></p>
		<p>圆的面积为：<%=r*r*Math.PI %></p>
		<p>我是被加载的文件</p>
		<%
	%>
</body>
</html>

上述代码中使用了request对象获得，从param中获得值。

3）forward动作
forward动作标签允许将请求转发到其他HTML页面、JSP页面或者一个程序段。通常请求被转发后会停止执行当前JSP页面，即forward标签一下的代码不会被执行。语法如下：

<jsp:forward page={"relativeURL"|"<%=expression %>"} />

或者

	<jsp:forward page={"relativeURL"|"<%=expression %>"}>
		<jsp:param value="{parameterValue | <%=expression %>}" 
		name="parameterNmae"/>
	</jsp:forward>

page属性：表示相对路径，或者代表相对路径的表达式，其路径指向将要重定向的文件。
param子标签：为重定向文件传递一个或多个参数，使用了param子标签。重定向文件必须是一个动态文件，即可以处理request对象的文件（如ASP、CGI、PHP）。
如下：
使用forward实现不同页面跳转

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%
		int x = (int) ((Math.random() * 10) + 1);
		if (x <= 5) {
	%>
	<jsp:forward page="小于或等于5.jsp">
		<jsp:param value="<%=x%>" name="x" />
	</jsp:forward>
	<%
		} else {
	%>
	<jsp:forward page="大于5.jsp">
		<jsp:param value="<%=x%>" name="x" />
	</jsp:forward>
	<%
		}
	%>
</body>
</html>

上述代码，实现了小于或等于5跳转到"小于或等于5.jsp"页面中，如果大于5则跳转到"大于5.jsp"页面中

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%=request.getParameter("x")+"<=5" %>
</body>
</html>

小于或等于5.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%=request.getParameter("x")+">5" %>
</body>
</html>

大于5.jsp

---

JSP内置对象
JSP包括request、response、out、session、application、pageContext、config、page、exception共9个内置对象。这些对象都是Servlet API接口的实例，在客户端和服务器交互的过程中分别完成不同的功能。参考地址

request对象
request对象是javax.servlet.http.HttpServletRequest 类的实例。每当客户端请求一个JSP页面时，JSP引擎就会制造一个新的request对象来代表这个请求。

request对象提供了一系列方法来获取HTTP头信息，cookies，HTTP方法，表单的数据，网址后面带的参数等等。

1）表单的提交方式
form标签用于创建供用户输入的html表单，一般有两种提交方式：get和post。语法如下：

<form name="name" method="get|post" action="address" >
.......
</form>

name属性：指定表单的名称
method属性：指定提交方式。使用get方式，提交的信息会在提交的过程中显示在浏览器的地址栏中；使用post方式，提交的信息不会显示在地址栏中。其值默认为post。
action属性：信息提交的地址，可以是绝对地址或相对地址。

request对象常用方法请参考：http://www.runoob.com/jsp/jsp-client-request.html

实例应用：

<%@page import="java.util.Enumeration"%>
<%@page import="java.net.URLDecoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>request常用方法</title>
<style type="text/css">
p {
	font-size: 15px;
	line-height: 1.3em;
}
</style>
</head>
<body>
	<%	
		%><p>设置字符编码：request.setCharacterEncoding("utf-8");</p><%
		request.setCharacterEncoding("utf-8");
	%>

	<%="<p>字符编码：" + request.getCharacterEncoding() + "</p>"%>

	<%="<p>返回请求的路径：" + URLDecoder.decode(request.getContextPath(), "utf-8") + "</p>"%>

	<%="<p>返回MIME类型：" + request.getContentType() + "</p>"%>

	<%		
		%>
			<p>返回所有http头的名称集合：
					<%
						Enumeration e = request.getHeaderNames();
						while (e.hasMoreElements()) {
							out.println(e.nextElement() + ";");
						}
					%>
			</p>
		<%
	%>

	<%	
		%><p>返回指定http头名称的信息：</p>	<table border="1" cellpadding="5" cellspacing="0"style="text-align: center;"><%
		%><tr><td>name</td><td>value</td></tr><%
		e = request.getHeaderNames();
		while (e.hasMoreElements()) {
			String name = (String) e.nextElement();
			%><tr><td><%=name%></td><td><%
			Enumeration ee = request.getHeaders(name);
				while (ee.hasMoreElements()) {
					out.println(ee.nextElement() + ";");
				}
			%></td></tr><%
		}
		%></table><br><%			
	%>

	<%="<p>获取响应请求的服务器名：" + request.getLocalName() + "</p>"%>

	<%="<p>获取响应请求的服务器端地址：" + request.getLocalAddr() + "</p>"%>

	<%="<p>获取响应请求的服务器端地址：" + request.getLocalPort() + "</p>"%>

	<%="<p>获取表单提交方法：" + request.getMethod() + "</p>"%>

	<%="<p>获取响应请求的服务器端地址：" + request.getLocalAddr() + "</p>"%>

	<%
		%><p>获取提交的表单：</p>	<table border="1" cellpadding="5" cellspacing="0"style="text-align: center;"><%
		%><tr><td>name</td><td>value</td></tr><%		
		e = request.getParameterNames();
		while(e.hasMoreElements()){
			String s =(String) e.nextElement();
			String[] arr = request.getParameterValues(s); 
			%><tr><td><%=s %></td><td><%
			for(int i=0;i<arr.length;i++)
			{
				out.println(arr[i]+";");
			}
			%></td></tr><%
		}	
		%></table><br /><%			
	%>
	
	<%="<p>返回get方法传递的参数字符串（该方法不分解出单独的参数）"+ request.getQueryString() +"</p>" %>
	
	<%="<p>获取发出请求的客户端IP地址：" + request.getRemoteAddr() + "</p>" %>
	
	<%="<p>获取发出请求的客户端主机名：" + request.getRemoteHost() + "</p>" %>
	
	<%="<p>获取发出请求的客户端端口：" + request.getRemotePort() + "</p>" %>

	<%="<p>返回给定虚拟路径的物理路径：" + request.getRealPath("") +"</p>" %>
	
	<%="<p>返回发出请求资源的地址（不返回请求的参数）：" + URLDecoder.decode(request.getRequestURI(),"utf-8") + "</p>" %>
	
	<%="<p>返回客户端所请求的脚本文件的文件路径：" + request.getServletPath() +"</p>" %>
	
	<%="<p>返回响应请求的服务器名称或IP地址：" + request.getServerName() +"</p>" %>
	
	<%="<p>返回请求服务器的端口号：" + request.getServerPort() +"</p>" %>
</body>
</html>

结果：

还有一些实例：
获取用户信息并输出

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>用户调查</title>
</head>
<body>
<h3>信息调查</h3>
<hr>
<form action="用户信息输出.jsp" name="f1" method="post">
    姓名：<input type="text" name="uname" /><br />
    性别：<input type="radio" name="usex" value="男" checked="checked" id="man" /><label for="man">&nbsp;男&nbsp;</label><input type="radio" name="usex" value="女" id="woman" /><label for="woman">&nbsp;女&nbsp;</label><br />
    学历：<select name="eduucation">
    <option value="初中级以下" selected="selected">初中级以下</option>
    <option value="高中">高中</option>
    <option value="大专">大专</option>
    <option value="本科">本科</option>
    <option value="研究生">研究生</option>
    <option value="博士">博士</option>
</select><br />
    获取信息渠道：<input type="checkbox" name="uchannel" value="杂志" id="z1" /><label for="z1">杂志</label>
    <input type="checkbox" name="uchannel" value="网络" id="z2" /><label for="z2">网络</label>
    <input type="checkbox" name="uchannel" value="朋友推荐" id="z3" /><label for="z3">朋友推荐</label>
    <input type="checkbox" name="uchannel" value="报纸" id="z4" /><label for="z4">报纸</label>
    <input type="checkbox" name="uchannel" value="其他" id="z5" /><label for="z5">其他</label><br />
    <input type="submit" value="提交" name="submit" />
</form>
</body>
</html>

输出

<%@ page import="java.util.Enumeration" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<title>输出</title>
    <%
        request.setCharacterEncoding("utf-8");
        out.println(request.getParameter("uname"));
        out.println(request.getParameter("usex"));
        out.println(request.getParameter("eduucation"));
        for (String s: request.getParameterValues("uchannel")) {
            out.println(s);
        }
    %>
<br />
    <%
        Enumeration e = request.getParameterNames();
        while(e.hasMoreElements()){
    //        out.println(e.nextElement());
            if(!"submit".equals(e.nextElement()))
                for (String s: request.getParameterValues((String)e.nextElement())) {
                    out.println(s);
                }
        }
    %>
<br />
    <%
        // from 不没有任何提交值 ， 只有 文本框这些东西才有提交值
        // out.println(request.getParameter("f1"));
    %>

结果：

本地提交：

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

<%
    String [] arr = {"优衣库","大众","七匹狼","华为"};
    String str = "",str_R = request.getParameter("id");
    if(str_R == null)
        str_R = "0";
    str = arr[new Integer(str_R)];
%>

<table style="border: 1px;">
    <tr>
        <td>分类</td>
        <td>品牌</td>
    </tr>
    <tr>
        <td style="width: 50px; text-align: center; height: 20px;">
            <a href="表单提交.jsp?id=0">服装</a>
            <a href="表单提交.jsp?id=1">汽车</a>
            <a href="表单提交.jsp?id=2">钱包</a>
            <a href="表单提交.jsp?id=3">手机</a>
        </td>
        <td>
            <%=str %>
        </td>
    </tr>
</table>

结果：

注：不是每个文本框都会生成请求参数，只有包含name属性的文本框才生成请求参数。若文本框配置了disabled="disabled"属性，则相应表单提交数据时不会提交该文本框信息。

讨论“JAVA 的服务器重定向：使用forward()方法转发请求和使用 sendRedirect()方法重定向的区别”
http://www.cnblogs.com/flyingeagle/articles/6681270.html

补上RequestDispatcher

void forward(ServletRequest request, ServletResponse response) 
Forwards a request from a servlet to another resource (servlet, JSP file, or HTML file) on the server. 
void include(ServletRequest request, ServletResponse response) 
Includes the content of a resource (servlet, JSP page, HTML file) in the response. 

RequestDispatcher rd = requset.getRequestDispatcher();
rd.forward(request,response); //
rd.include(request,response); // 包含转发的页面 

重定向：response.sendRedirect("https://www.baidu.com");
重定向与请求转发区别

地址栏：
请求转发：地址栏不发生改变
重定向：地址栏发生改变

参数不同：
请求转发：带了两个参数：request、response 
重定向：没有参数

应用范围不一样：
请求转发：只能转发到本工程的其他页面
重定向：可以是任意工程的页面

页面转向：

1.请求转发
2.重定向
3.js 转向 location.href="";
4.表单提交
5.a标签 <a></a> get方法提交

4个作用域（area 范围）：

page -- 在本页面有效范围 -- 对应的对象 （pageContext）
request -- 在一次请求范围 （如果是请求转发，则会继续有效） -- 对应的对象（request）
session -- 在一次会话范围 -- 对应的对象 （session）
application -- 在整个应用程序有效  -- 对应的对象 （application）

方法：
setAttribute()设置属性
getAttribute()获取属性

response对象
response对象是javax.servlet.http.HttpServletResponse类的实例。当服务器创建request对象时会同时创建用于响应这个客户端的response对象。

主要用于向客户端发送数据。

response对象也定义了处理HTTP头模块的接口。通过这个对象，开发者们可以添加新的cookies，时间戳，HTTP状态码等等。

实例：
表单的提交，若表单不为空输出相关信息，否则就返回表单界面。
表单.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>表单</title>
</head>
<body>
    <form method="post" name="f1" action="表单输出.jsp">
        <label>
            姓名：<input type="text" name="t1" />
        </label>
        <input type="submit" value="提交" />
    </form>
</body>
</html>

表单输出.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@ page import="java.net.URLEncoder" %>
<title>输出</title>
<%
    String s = null;
    String sendRedirect_str = "表单.jsp";
    s = request.getParameter("t1");
    if(s == null || s.length() == 0)
    {
        // 此处要编码成url，否则无法跳转回去
        response.sendRedirect(URLEncoder.encode(sendRedirect_str,"utf-8"));
    }
    else{
        out.println(s + "欢迎您。");
    }
%>

页面自动刷新

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/25
  Time: 上午 10:57
  To change this template use File | Settings | File Templates.
--%>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
    <title>自动刷新</title>
<%
    String s = new SimpleDateFormat("hh-mm-ss").format(new Date());
    out.println(s);
    // 为response添加一个响应头Refresh，其值为1，表示每隔1秒刷新一次
    response.setHeader("Refresh","1");
%>

还有就是关于响应内容类型设置、响应内容字节数设置、响应内容编码设置

<%--
下面这条是必须设置的，
表示页面采用的编码方式，
如果不设置就不是utf-8的编码，返回数据会有误！！！
--%>
<%@ page pageEncoding="UTF-8" %>
<%
    String s = "我是响应页面";
    // 设置响应类型
    response.setContentType("text/html;charset=utf-8;");
    // 设置响应字节数
    // 如果设置的不精确的话，浏览器那边会有点小毛病 ，
    // 设置小了浏览器显示的内容不足，设置大了浏览器总是在获取内容不显示
    // 所以一般不设置，除非可以确定，
    // 但是servlet自动封装了。。。也就是说它会自己设置，不需要我们考虑.....
//    response.setContentLength(s.getBytes().length);
    // 设置响应编码
    response.setCharacterEncoding("utf-8");
    out.print(s);
%>

附：
记一次Content-Length引发的血案
https://blog.csdn.net/stpeace/article/details/80217315
HTTP 协议中的 Transfer-Encoding 详细分析
https://blog.csdn.net/u014569188/article/details/78912469
关于Content-Length
https://blog.csdn.net/jgwei/article/details/7289792

out对象
out对象是 javax.servlet.jsp.JspWriter 类的实例，用来在response对象中写入内容。

主要用于向客户端浏览器输出内容。

最初的JspWriter类对象根据页面是否有缓存来进行不同的实例化操作。可以在page指令中使用buffered='false’属性来轻松关闭缓存。

JspWriter类包含了大部分java.io.PrintWriter类中的方法。不过，JspWriter新增了一些专为处理缓存而设计的方法。还有就是，JspWriter类会抛出IOExceptions异常，而PrintWriter不会。

下表列出了我们将会用来输出boolean，char，int，double，String，object等类型数据的重要方法：

out对象方法：

1.public abstract void clear()
清除缓冲区中的内容，不将数据发送至客户端。

2.public abstract void clearBuffer()
将数据发送至客户端后，清除缓冲区中的内容。

3.public abstarct void close()
关闭输出流。

4.public abstract void flush()
输出缓冲区中的数据。

5.public int getBufferSize()
获取缓冲区的大小。缓冲区的大小可用<%@ page buffer="size" %>设置。

6.public abstract int getRemainning()
获取缓冲区剩余空间的大小

7.public boolean isAutoFlush()
获取用<%@ page is AutoFlush="true/false"%>设置的AutoFlush值。

8.public abstract void newLine()
输出一个换行字符，换一行。

9.public abstract void print()
显示各种数据类型的内容。

10.public abstract void println()
分行显示各种数据类型的内容。 

实例：

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/25
  Time: 上午 11:29
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@ page import="java.util.*" %>
    <title>缓冲区</title>
<%
    out.println("1234");
    out.println("5678");
    out.clearBuffer();
    out.println("我是flush");
    out.flush();
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    out.println(".....");
    // 已经发送到了浏览器的 数据是不能清除的，但是刚发送的是可以清除的！
    out.clear();
    out.close();
%>

session对象
session对象是 javax.servlet.http.HttpSession 类的实例。和Java Servlets中的session对象有一样的行为。

session对象用来跟踪在各个客户端请求间的会话。

主要用于保持在服务器与客户端之间需要保留的数据，如在会话期间保持用户的登陆状态等信息。由于http协议是一个无状态协议，不保留会话间的数据，因此通过session对象扩展http的功能。比如用户登录一个网站之后，登录信息会暂时保存在session对象中，打开不同的页面时，登录信息是可以共享的，一旦用户关闭浏览器或退出登陆，会清除session对象中保存的登录信息。

sessionID 是GUID 全球 唯一的ID

验证定义：

test1.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/25
  Time: 下午 5:09
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>session测试</title>
</head>
<body>
<%
    out.println(session.getId());
%>
<br>
<a href="test2.jsp">去test2</a>
</body>
</html>

test2.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/25
  Time: 下午 5:09
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>session测试</title>
</head>
<body>
<%
    out.println(session.getId());
%>
<br>
<a href="test1.jsp">去test1</a>
</body>
</html>

结果：
test1

test2

此时，我们发现两个页面的会话ID是一样的！
这就证明了定义…

实例：

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/25
  Time: 下午 5:26
  To change this template use File | Settings | File Templates.
--%>
<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.util.Enumeration" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>测试</title>
</head>
<body>
<%
    // 这是里是以秒为单位
    session.setMaxInactiveInterval(1800);
%>
session会话创建时间：<%=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(session.getCreationTime())) %>
<br>
session会话保持的总时间：<%=session.getMaxInactiveInterval() %>
<br>
是否是新的session对象：<%=session.isNew() %>
<%
    %> <br> <%
    session.setAttribute("name","zhw");
    session.setAttribute("code","1111");
    out.print("name:"+session.getAttribute("name"));
    %> <br> <%
    out.print("code:"+session.getAttribute("code"));
%>
<br>
返回session对象的所有属性集合：<%
    Enumeration e = session.getAttributeNames();
    while(e.hasMoreElements()){
        out.println(e.nextElement());
    }
%>
<br>
返回session最后的会话时间：<%=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(session.getLastAccessedTime())) %>
<br>
</body>
</html>

结果：

application对象
application对象直接包装了servlet的ServletContext类的对象，是javax.servlet.ServletContext 类的实例。

这个对象在JSP页面的整个生命周期中都代表着这个JSP页面。这个对象在JSP页面初始化时被创建，随着jspDestroy()方法的调用而被移除。

通过向application中添加属性，所有的JSP文件都能访问到这些属性。

主要用于保存用户信息、代码片段的运行环境等。它是一个共享的内置对象，即一个容器中的多个用户共享一个application对象，故其保存的信息被所有用户共享。

实例：

<%@ page import="java.util.Enumeration" %><%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/25
  Time: 下午 8:06
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>测试</title>
    <style>
        *{
            line-height: 2em;
        }
    </style>
</head>
<body>
当前的物理路径：<%=application.getRealPath("test1.jsp") + "<br>"%>
<%
    // 添加属性
    application.setAttribute("name","zhw");
    // 获取属性
    out.print(application.getAttribute("name") + "<br>");
    // 删除属性
    application.removeAttribute("name");
%>
<%
    // application 对象属性集合
    Enumeration<String> e = application.getAttributeNames();
    %>application 对象属性：<br><%
    %><table border="1" cellpadding="5px" cellspacing="0" style="text-align: center;"><%
    %><tr>        <td>name</td>        <td>value</td>    </tr><%
    while(e.hasMoreElements()){
        String s = e.nextElement();
        // 获取对象属性值
        %><tr><td><%=s %></td><td><%=application.getInitParameter(s)%></td></tr><%
    }

    %></table><br><%
%>
<%="servlet引擎名及版本号："+application.getServerInfo() + "<br>" %>
</body>
</html>

结果：

pageContext 对象
pageContext对象是javax.servlet.jsp.PageContext 类的实例，用来代表整个JSP页面。

这个对象主要用来访问页面信息，同时过滤掉大部分实现细节。

这个对象存储了request对象和response对象的引用。application对象，config对象，session对象，out对象都可以通过访问这个对象的属性来导出。

pageContext对象也包含了传给JSP页面的指令信息，包括缓存信息，ErrorPage URL,页面scope等。

PageContext类定义了一些字段，包括PAGE_SCOPE，REQUEST_SCOPE，SESSION_SCOPE， APPLICATION_SCOPE。它也提供了40余种方法，有一半继承自javax.servlet.jsp.JspContext 类。

其中一个重要的方法就是removeArribute()，它可接受一个或两个参数。比如，pageContext.removeArribute(“attrName”)移除四个scope中相关属性，但是下面这种方法只移除特定scope中的相关属性：

pageContext.removeAttribute("attrName", PAGE_SCOPE);

config对象
config对象是 javax.servlet.ServletConfig 类的实例，直接包装了servlet的ServletConfig类的对象。

这个对象允许开发者访问Servlet或者JSP引擎的初始化参数，比如文件路径等。

以下是config对象的使用方法，不是很重要，所以不常用：

config.getServletName();

它返回包含在<servlet-name>元素中的servlet名字，注意，<servlet-name>元素在 WEB-INF\web.xml 文件中定义。

实例：

<%@ page import="java.util.Enumeration" %>
<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/11/17/017
  Time: 下午 7:44
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>pageContext</title>
</head>
<body>
返回Servlet的名称：<%=config.getServletName() %>
<br><br>
返回初始化参数的名称：<br>
<%
    Enumeration<String> e = config.getInitParameterNames();
    while(e.hasMoreElements()){
        String s = e.nextElement();
        out.print(s + "：" + config.getInitParameter(s) + "<br>");
    }
%>
</body>
</html>

page 对象
这个对象就是页面实例的引用。它可以被看做是整个JSP页面的代表。

page 对象就是this对象的同义词。

实例：

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/10/26
  Time: 上午 11:12
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>测试</title>
</head>
<body>
page对象的getClass()方法的返回值：<%=page.getClass()%> <br>
page对象的toStirng()方法的返回值：<%=page.toString()%> <br>
page对象等于Object对象：<%=page.equals(new Object())%> <br>
page对象等于this对象：<%=page.equals(this)%>
</body>
</html>

exception 对象
exception 对象包装了从页面中抛出的异常信息。它通常被用来产生对出错条件的适当响应。

注意只有在JSP页面的page指令中指定了isErrorPage="true"后，才可以在本页面中使用exception对象。

Cookie 对象
Cookie 是服务器发送给客户端浏览器的纯文本信息。
用户在访问同一个Web服务器时浏览器会把Cookie值按原样发送给服务器。

通过使用Cookie，可以维护用户提供的信息，如标志用户信息、定制用户所需信息、安全要求不高的情况下避免用户重复进行登录验证 、有针对性地投放广告等。尽管使用Cookie可以为用户带来诸多的方便，但在安全性要求较高的场合下，不建议使用Cookie。
此外，在浏览器中只允许存放300个Cookie，每个站点最多存放20个Cookie，每个Cookie的大小限制为4KB，所以不用担心Cookie会占用过多的硬盘空间。

当用户访问某个站点时，可以使用resposne对象的addCookie方法添加一个Cookie对象，并将它发送到客户端，保存的客户端浏览器所分配的内存空间或者以文本形式保存到特定的磁盘目录下。当该用户再次访问同一个站点时，浏览器会自动将该Cookie对象发送回服务器。

实例：

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/11/17/017
  Time: 下午 3:42
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<html>
<head>
    <title>测试</title>
</head>
<body>
<%
    // 创建
    Cookie c = new Cookie("name", "zhw");
    // 保存
    response.addCookie(c);
    // 读取
    Cookie[] cookies = request.getCookies();
    for (Cookie coo : cookies) {
        out.print(coo.getName() + "：" + coo.getValue() + "<br />");
    }
%>
</body>
</html>

结果：

设置Cookie对象的有效时间
将Cookie对象保存到客户端，如果没有设置有效时间或者有效时间为0，则表示此Cookie对象存放在浏览器的内存空间中（请注意是 内存 中！！！），浏览器关闭时会自动清除Cookie。
如果设置了有效时间，则表示该Cookie对象以文本形式保存在特定路径中。Cookie的有效时间以秒为单位。
如果需要使保存的Cookie对象失效，只需要将有效时间设置为一个负值即可。（实测：即使设置了负值，也返回给浏览器了，也需要等浏览器关闭后Cookie才会失效）

实例：

创建cookie

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/11/17/017
  Time: 下午 3:54
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@page import="javax.servlet.http.Cookie" %>
<html>
<head>
    <title>测试 - 创建</title>
</head>
<body>
<%
    // 创建
    Cookie c = new Cookie("name","zhw");
    // 设置保存时间
    c.setMaxAge(90);
    // 保存
    response.addCookie(c);
%>
</body>
</html>

读取cookie：

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/11/17/017
  Time: 下午 3:57
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@page import="javax.servlet.http.Cookie" %>
<html>
<head>
    <title>测试 - 查看</title>
</head>
<body>
<%
    // 读取
    Cookie[] cookies = null;
    cookies = request.getCookies();
    if(cookies == null)
    {
        out.println("无Cookie");
        return;
    }
    for (Cookie coo : cookies) {
        out.print(coo.getName() + ":" + coo.getValue() + "<br />");
    }
%>
</body>
</html>

销毁cookie：

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2018/11/17/017
  Time: 下午 3:58
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@page import="javax.servlet.http.Cookie" %>
<html>
<head>
    <title>测试 - 销毁</title>
</head>
<body>
<%
    Cookie [] cookies = request.getCookies();
    for(Cookie c: cookies){
        if(c.getName().equals("name")){
            c.setMaxAge(-1);
            response.addCookie(c);
        }
    }
%>
</body>
</html>

---

Sevlet 学习

---

原文：https://www.cnblogs.com/hujunzheng/p/4086107.html
关于WebSevlet注解说明：

@WebServlet(“/HW”)的含义：

@WebServlet(“/HW”)//默认设置的是urlPatterns属性

public class HelloServlet extends HttpServlet {

只要在Servlet上设置@WebServlet标注，容器就会自动读取当中的信息。上面的@WebServlet告诉容器，如果请求的URL是“/HW”，则由HelloServlet的实例提供服务。可以使用@WebServlet提供更多信息。
@WebServlet(
name=“Hello”,
urlPatterns={"/HW"}
)

上面的@WebServlet告知容器，HelloServlet这个Servlet的名称是Hello，这是由name属性指定的，而如果客户端请求的URL是/HW，则由具Hello名称的Servlet来处理，这是由urlPatterns属性来指定的。在Java EE相关应用程序中使用标注时，可以记得的是，没有设置的属性通常会有默认值。例如，若没有设置@WebServlet的name属性，默认值会是Servlet的类完整名称。

注意：Tomcat中， 如果web.xml和@WebServlet属性都设置了，那么对不起，@WebServlet中的urlPatterns属性就不起作用了！（可以将web.xml从WEB-INF目录中移走，或者删除这样@WebServlet中的urlPatterns属性值就可以使用了！）

---

servlet server let （服务器片段）

servlet的定义：
servlet是一个类，用来接收用户的请求，并作出响应的一个程序

如何来写：
javax.servlet.Servlet 接口
javax.servlet.GenericServlet 抽象类
javax.servlet.HttpServlet 抽象类

http: 超文本传输协议

容器：服务器i
tomcat

jsp 就是一个类（Servlet类）

servlet的写法：
1.实现Servlet 接口，然后重写5个方法。（初始化方法，销毁方法，服务方法）
2.配置servlet（web.xml文件进行配置）

servlet的生命周期
1.tomcat创建servlet对象
2.调用初始化方法（只调用一次）
3.调用服务方法（每请求一次，调用一次）
4.调用销毁方法（服务器停止时，调用一次）

1
java servlet文档
http://tomcat.apache.org/tomcat-9.0-doc/servletapi/index.html