1.前言

1.1 JSP

部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。JSP技术以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序共同处理复杂的业务需求。

JSP将Java 代码和特定变动内容嵌入到静态的页面中，实现以静态页面为模板，动态生成其中的部分内容。

1.2 C/S和B/S架构

（1）C/S client/service 客户端/服务端 ----> 客户端安装客户端软件，来访问服务端，获得服务

例如： qq服务器在服务端， qq软件安装在每一个客户端

服务器接收客户端的请求request ，并相应response请求

缺点：

若软件升级，则全部软件都要升级

维护麻烦，需要维护每一台客户端软件

每一台客户端，都需要安装客户端软件

（2）B/S Browser/Server，浏览器/服务器模式----->客户端通过浏览器，直接访问服务端

三层C/S架构：

第一层是浏览器，即客户端，只有简单的输入输出功能，处理极少部分的事务逻辑。由于客户不需要安装客户端，只要有浏览器就能上网浏览；

第二层是WEB服务器，扮演着信息传送的角色。当用户想要访问数据库时，就会首先向WEB服务器发送请求，WEB服务器统一请求后会向数据库服务器发送访问数据库的请求，这个请求是以SQL语句实现的。

第三层是数据库服务器，他扮演着重要的角色，因为它存放着大量的数据。当数据库服务器收到了WEB服务器的请求后，会对SQL语句进行处理，并将返回的结果发送给WEB服务器，接下来，WEB服务器将收到的数据结果转换为文本形式发送给浏览器，也就是我们打开浏览器看到的界面。

1.3 Tomcat

1.目录介绍：

bin:可执行文件（包含 startup.bat 开启 shutdown.bat 关闭）

conf: 配置文件（server.xml)

lib : tomcat依赖的jar文件

temp: 临时文件

webapps: 可执行的项目（将开发的项目放到该目录）

work: 存放由jsp翻译成的java,以及编译成的class文件写jsp--> 产生java -->产生并执行class文件

2.配置Tomcat

(1) jdk

(2)配置catalina_home

3.修改端口号：

默认端口号是8080（此端口号比较常见，易冲突）

conf: 配置文件（server.xml) 再重启

4.访问Tomcat：

先 startup.bat 开启!!!!

在浏览器访问http://localhost:8080

常见的状态码：

404：资源不足

500：服务器内部错误（一般是代码有误）

403：权限不足（例如访问某目录，但它设置是不可见）

3开头：页面重定向（页面的跳转）

5.访问自己的项目：

(1)要建自己的项目：

在webapps文件夹里自定义一个文件夹 JspProject:
必须包含的文件，参考同目录下的ROOT文件夹，其中的WEB-INF文件夹及其此文件夹里的web.xml是必须要有的
所以，直接复制ROOT文件夹中的WEB-INF文件夹到JspProject中
一般，还需要在JspProject/WEB-INF 中新建 classes 和 lib 文件夹
（tomcat 会自动将jsp文件变为class文件，最终执行class文件就放在 classes文件夹中
lib 文件夹存放此项目要引用的一些jar包，即第三方类库；而tomcat的lib文件夹存放所有项目的jar包，就是所有项目都可以用此jar包；就是全局和局部的关系
web.xml是一些描述信息,此内容直接从别处复制过来，之后信息可以自己改正）
在JspProject目录中新建 index.jsp

<html>
    <head>
		<title>my first jsp project</title>
	</head>
	<body>
			hello jsp!!!!
			<%
					out.print("hello world!");
			%>
	</body>
</html>

项目就写完了，开启Tomcat 在bin中的startup
在浏览器中访问： localhost:8080/JspProject/

页面显示：hello jsp!!!!hello world!

所以，jsp是在html中嵌套的java 代码通过<% java 代码 %>

(2) 在项目/WEB-INF/web.xml中设置默认的初始页面

此时，在同一个目录下新建文件index2.jsp 内容为：

 <html>
    <head>
		<title>my first jsp project</title>
	</head>
	<body>
			hello jsp!!!!
			<%
					out.print("hello heihei!");
			%>
	</body>
</html>

在浏览器中访问： localhost:8080/JspProject/
仍然是输出index.jsp的内容

这和web.xml文件中的信息有关：

在标签 <welcom-file></welcom-file>中页面为默认访问页面，当第一个不存在时，再依次往下访问;

多数版本是采用index做默认初始页面即

<welcom-file>index.jsp</welcom-file>

在web.xml 中：（手动往里面添加以下内容，一开始可以直接到别的目录中的web.xml 把含有此标签的部分复制过来，再修改一下）

<welcome-file-list>
	<welcome-file>index2.jsp</welcome-file>
	<welcome-file>index.jsp</welcome-file>	
</welcome-file-list>

这时就可以显示index2的页面了

6.虚拟路径

方式一：

把项目放到webapps文件夹中，在浏览器中输入项目名就可以访问了
那项目不放到webapps文件夹中，该怎么识别项目的路径呢？

在Tomcat的 conf\server.xml 中找到 <Host>标签它里面限定了虚拟路径：
<Host name = "localhost" appbase = "webapps" > </Host>
直接在此标签内部添加：
<Context docBase="" path=""/>
解释：
docBase是实际路径,就是项目的实际路径：D:\study\JspProject
path是虚拟路径：使用绝对路径或相对路径
相对路径：path="/JspProject"-------->相对于webapps 就是：D:\study\tomcat\webapps\JspProject

所以：<Context docBase="D:\study\JspProject" path="/JspProject"/>
见到path的相对路径，实际上是直接访问的 docBase

将web项目配置到webapps以外的目录：
在conf\server.xml中配置：在Host标签中，添加：<Context docBase="D:\study\JspProject"  path="/JspProject"/>

虚拟路径的配置后要重启！！！

方式二：

在conf\Catalina\localhost\中：
新建文本文档，自命名为项目名改后缀为xml 例如JspProject.xml
在其中配置：
<Context docBase="D:\study\JspProject" path="/JspProject"/>
（别忘了在server.xml删掉上一个方式）

此虚拟路径的配置后不需要重启！！！

7.jsp的执行流程: 请求响应

客户端（浏览器）和服务端（Tomcat服务器）采用 BS架构

客户端（浏览器）发出请求，服务端（Tomcat服务器）响应此请求

客户端第一次请求某网址：
请求发给 Tomcat服务器后：
接收jsp 文件，将jsp翻译成java（Servlet文件），再Java编译成 class文件进行响应此请求

客户端第二次请求某网址：
直接访问class文件（若服务端修改代码，要重新翻译和编译）

8.使用Eclipse 开发Web项目（JSP）：

确保Tomcat服务器处于关闭状态--》因端口号会冲突

Tomcat服务器和 Eclipse 中的服务器是两个独立的，比如你在其中一个中修改了端口号并不会影响另一个的，那两个相同，就冲突了

（1）首先，用Eclipse将Tomcat关联（集成）起来：

Window--Preference--Sever--Runtime Evironment--add--Apache找到Tomcat版本--next--JRE版本 --apply
再在下方的面板处的Servers 中的链接--找到Tomcat版本next--finish

说明：

一般将eclipse 中的tomcat与本地tomcat的配置信息保持一致：将eclipse 中的tomcat设置为托管模式：

第一次创建一个tomcat实例之后，双击，在Server Locations中选择第二项：Use Tomcat installation ---->此时相当于两个tomcat是同步，配置一样当在将eclipse 中的tomcat 在Servers--server.xml 中修改端口号，此时也会同步修改本地tomcat的server.xml

此处的Ports(端口号)：

Tomcat admin port ：8081

和

HTTP/1.1：8080

就是二者不要一样

（2）其次，创建项目：

File--New--Other--搜web 选择Dynamic Web Project--next--起项目名字 MyJspProject --在Target runtine 处选择Tomcat--next ----next --勾勾--finish

（3）新建jsp文件

在左栏找到项目MyJspProject--WebContent 右键--New--other--搜jsp ,点击JSP File ,在File name处输入：index1.jsp

然后
建第二个，在MyJspProject--WebContent--WEB-INF右键--New--JSP File ,在File name处输入：index2.jsp

将eclipse 中的tomcat与本地tomcat的配置信息保持一致后！！！！

此时，

MyJspProject--webapp--右键--New--other--搜jsp ,点击JSP File ,在File name处输入：index1.jsp

MyJspProject--webapp--WEB-INF--右键--New--other--搜jsp ,点击JSP File ,在File name处输入：index2.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
	hello  index1 
</body>
</html>

（4）启动：

再在下方的面板处的Servers的链接处右键 Add and Remove --- 选择已经自动显示的项目名 MyJspProject -- add--finish
--链接处右键 Start

(5)运行： localhost:8080/MyJspProject/index1.jsp 成功

在浏览器窗口直接访问 localhost:8080/MyJspProject 不可以
因为默认访问的文件并不是index1.jsp；要修改默认访问的初始页面要在web.xml 文件中修改
在左栏的 MyJspProject/WebContent/WEB-INF/lib/web.xml
加入index1.jsp ----》是依次从上到下访问各个默认页面
在下方的面板处的Servers的链接处右键 Restart 重启！！！
localhost:8080/MyJspProject 可以啦
即：

localhost:8080/项目名/WebContent的子目录中的子文件（jsp文件）名
    而对于WebContent/WEB-INF/index2.jsp  不可以直接访问

http://localhost:8080/MyJspProject/WEB-INF/index2.jsp  不成功
http://localhost:8080/MyJspProject/index1.jsp  和 http://localhost:8080/MyJspProject 成功

总结：
浏览器可以直接访问WebContent中文件，但是WEB-INF中的文件无法通过客户端（浏览器）直接访问，只能通过请求转发来访问

配置Tomacat运行时环境（若代码的第一行飘红就是 jsp和Servlet文件不可同时运行，即此时不可相互转换）
MyJspProject右键 -- Build Path--Configure--Add Library--Server Runtime--next--tomcat--finish

统一字符集编码：
1.编码的分类：
(1)设置jsp文件的编码： (就是从 jsp 翻译为java)
通过jsp文件中的 pageEncoding 的属性在开头标签page 中：
<page pageEncoding = "UTF-8 ">

(2)设置浏览器读取jsp文件的编码：
通过jsp文件中的 content 属性在开头标签charset 中：

<mate charset = "UTF-8 ">
一般将上述设为一样的，常设为 UTF-8

 <%@ 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>
	hello  index1 你好
</body>
</html>

(3) 文本编码
1.法一：将整个eclipse的文件统一设置（推荐）
Window--Preference--搜 jsp 选择 JSP Files ，在右边 Encoding处选择UTF-8

  2. 法二：设置某一个项目：
        JspProject右键 -- properties--选择UTF-8
  3. 法二：设置单独文件：
      右键 -- properties--选择UTF-8

9. 分析JSP页面元素

（1）脚本：<% %> <%! %> <%= %>

局部变量，java语句

<body>
	hello  index1 你好
	<%
		String name = "zhangsan";	//局部变量
		out.print("hello.."+name);
	%>
</body>

<%!

全局变量，定义方法（java）

<body>
	<%!
		public String bookname ;	//全局变量
		public void init(){		   //定义方法
			bookname = "javaweb";
		}
	%>

<%=输出表达式%>
```
<%="hello.."+bookname %>
```
它和out.print("hello"); 语句功能一样注意区别后者有分号

out.println("hello"); 也不会回车因为最终编译后不会使用java代码,可以使用<br/>
```
回车:
out.print("hello"+<br/>)

<%="hello"+<br/>%>
即 out.print() 和   <%= %>  可以直接解析html代码
```

一般,修改 web.xml ,配置文件, java 需要重启tomcat服务

但修改jsp/html/css/js 需要重启tomcat服务 ,仅需要刷新一下页面

<%@ 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>
	<%!
		public String bookname ;	//全局变量
		public void init(){		   //定义方法
			bookname = "javaweb";
		}
	%>
	
	hello  index1 你好  <br/>
	
	
	<%
		String name = "zhangsan";   //局部变量
		out.print("hello.."+name+"<br/>");
		init();  					//调用方法
	%>
	
	<%="hello.."+bookname+"<br/>" %>	
	
</body>
</html>

(2) 指令

在最开头

以page指令为例: <%@ page ... %> 的属性:

language:jsp页面使用的脚本语言

import: 导入类例如，现在导入日期类包 date : import = "java.util.Date"

pageEncoding: jsp文件自身编码 contentType :浏览器解析jsp的编码二者保持一致

 <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"  import = "java.util.Date" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%!
		public String bookname ;	//全局变量
		public void init(){		   //定义方法
			Date date = new Date();
			bookname = "javaweb" + date;//返回当前时间
		}
	%>

(3)注释

html注释 (可以被客户通过浏览器查看源码看到)

java 注释 //

jsp注释 <%-- --%>

10.JSP内置对象 (不需要new,也可以使用的)

(1) out :

输出对象,向客户端输出内容

(2) request:

请求对象,存储"客户端(浏览器)向服务端(tomcat)发送的请求信息"

常用的方法:

String getParameter(String name): 根据请求的字段名key(此处就是input标签中的name属性值）,返回字段值value (input标签中的value属性值)
String[] getParameterValues(String name):根据请求的字段名key,返回多个字段值value,常见的是 checkbox(表单里的多选按钮)
void setCharacterEncoding("编码格式 "):设置请求编码
getRequestDispatcher().forward() :请求转发的跳转页面页面a跳转到页 b ; getRequestDispatcher("b.jsp").forward(request,response)

ServletContext getServerContext():获取项目的ServletContext对象

实例:

注册页 register.jsp 展示页 show.jsp （在webapp 同一根目录下建文件）

（1）在注册页 register.jsp中编写好表单

 <body>
	<form action="show.jsp">
		用户名：<input type="text" name="uname"/><br/>
		密码：<input type="password" name="upwd"/><br/>
		年龄：<input type="text" name="uage"/><br/>
		爱好：<br/>
		<input type="checkbox" name="uhobbies" value = "足球"/>足球
		<input type="checkbox" name="uhobbies" value = "篮球"/>篮球
		<input type="checkbox" name="uhobbies" value = "排球"/>排球<br/>
		<input type="submit" value="注册">
	</form>
</body>

（2）在展示页 show.jsp要获取到表单的内容：

首先告诉它获取时所用的编码格式void setCharacterEncoding("编码格式 ")

它是request内置对象的方法，它是java对象，要在java语言中编写
```
<%
		request.setCharacterEncoding("utf-8");
	%>
```

依次由key 取出值 value：

对应于表单 input标签中的name属性值通过方法来获取input标签中的value属性值

String getParameter(String name): 取单个值

String[] getParameterValues(String name):取多个值

<%@ 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.setCharacterEncoding("utf-8");	//设置编码
		String name = request.getParameter("uname");
		String password = request.getParameter("npwd");
		int age = Integer.parseInt(request.getParameter("uage"));
		//此处age是整数，要用Integer.parseInt(),将request.getParameter（）方法的返回值字符串转为整数
		
		//获取的是input中的value的值
		String[] hobbies = request.getParameterValues("uhobbies");
	%>
	
	<!-- 要显示的页面上的内容，就是html代码,   要写在java代码的外面  要注意写的地方不同 --> 
	 
	 	注册成功，信息如下：<br/>
	 	姓名：<%=name %><br/>
	 	密码：<%=password %><br/>
	 	年龄：<%=age %><br/>
	 	<%
	 		//爱好是多个值，可以利用java中的循环实现  
	 		for(String hobby : hobbies){
	 			// System.out.ptint()  这样写会写到控制台中去 想写到页面里面，要使用 out.print() 通过内置对象out实现
	 			out.print("爱好："+hobby+ "&nbsp");  //空格的实现 用html中的"&nbsp"
	 		}
	 	%>
</body>
</html>

（3）访问 http://localhost:8080/MyJspProject/register.jsp

输入信息后，点击注册后，就会跳转到 show.jsp 显示信息

注册成功，信息如下：
姓名：aa
密码：null
年龄：11
爱好：足球篮球排球

此时，浏览器里面：http://localhost:8080/MyJspProject/show.jsp?uname=aa&upwd=11&uage=11&uhobbies=足球&uhobbies=篮球&uhobbies=排球

此时将register.jsp删除，直接访问地址栏里地址，也是可以显示上述信息

将表单默认的'

' 和地址栏的请求方式和超链接（')' 都属于get提交方式：

连接/文件？参数名1=参数值1 & 参数名2=参数值2& & 参数名3=参数值3

get提交方式和post提交方式的区别：

（1）get方式会在地址栏上显示请求信息；post 不显示

（2）文件上传操作，必须是post

统一请求的编码 request：

get方式请求，出现请求页面出现乱码的情况解决：

修改server.xml ,一次性的更改tomcat默认get提交方式的编码，例如 utf-8

在改端口号的地方加上URIEncoding = "UTF-8"

<Connector connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"
URIEncoding = "UTF-8"/>

建议，使用tomcat时，首先在server.xml中统一get方式请求的编码

对于request.setCharacterEncoding("utf-8"); 是设置的post方式请求的编码 tomcat8之后默认是UTF-8

表单默认是get提交，一般采用post方式 method = "post"

(3)response

响应对象：存储"服务端(tomcat)向客户端(浏览器)发送的响应信息"

常用方法：

void addCookie(Cookie cookie) 服务端(tomcat)向客户端(浏览器) 增加coolie对象

void sendRedirect(String location) throws IOException 页面跳转的一种方式（重定向）

viod setContetType(String type) 设置服务端响应时的编码

—————————————————————————————————————————

实例：登录功能实现：用户登录完信息后，提示“欢迎您！”

登录页：login.jsp

判断登录的合法性: check.jsp

若合法，则跳转到 success.jsp

可以在webapp目录中新建文件夹 myjspfiled，来存放自己的jsp文件

（1）在登录页：login.jsp 中编写好表单

<body>	
		<form action = "check.jsp" method = "post">
			用户名：<input type="text" name="uname"/><br/>
			密码：<input type="password" name="upwd"/><br/>
			<input type="submit" value="登陆"><br/>
		</form>
</body>

(2)判断登录的合法性: check.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.setCharacterEncoding("utf-8");//统一了post提交方式的编码，仅是保险，tomcat8之后默认是UTF-8
		//对应于表单 input标签中的name属性值   通过方法   来获取input标签中的value属性值
		String name = request.getParameter("uname");
		String password = request.getParameter("npwd");
		//检查输内容的合法性: 用java的方法： 受检查内容.equals(正确内容)  
		if(name.equals("zhangsan")&&password.equals("abc")){// 假设用户名必须是zhangsan 密码是abc
			//登录成功，要跳转到页面 success.jsp   使用方法：void sendRedirect(String location)  throws IOException
			response.sendRedirect("success.jsp");
			
		}else{
			out.print("用户名或密码有错误");
		}
	%>
</body>
</html>

(3) success.jsp页面

<body>
			登录成功！<br/>
			欢迎你：
			<%
				String name = request.getParameter("uname");
				out.print(name);
			
			%>
</body>

(4)登录 http://localhost:8080/MyJspProject/myjspfiled/login.jsp

使用equals进行字符串比较时，若其中一个被比较的字符串已经知道内容，在不为null的情况下建议放在equals前面，将变量放在括号里面进行比较，可以避免空指针异常；若比较的字符串都是变量，建议将其中一个字符串先判空再在放在equals前面进行比较，也可以避免空指针异常。

页面跳转的方法2种：

（1）重定向不成功，就算成功，会导致数据丢失; response.sendRedirect("success.jsp");

（2）请求转发：

request.getRequestDispatcher("跳转的页面").forward(request,response)

可以获取到数据，并且地址栏没有改变，仍然保留转发时的页面 check.jsp

<body>
	<%
	 
	String name = request.getParameter("uname");
	String password = request.getParameter("npwd");
	if ("zs".equals(name) && "abc".equals(password)) {// 假设用户名必须是zs 密码是abc 
		 request.getRequestDispatcher("success.jsp").forward(request,response);
	}
	else {
		   out.print("用户名或密码有错误");
	}
	%>
</body>

请求转发和重定向

请求转发重定向

地址栏是否改变：不变改变（success.jsp)

是否保留第一次请求时的数据：保留不保留

请求的次数： 1次 2次

跳转发生的位置：服务端客户端发出第二次跳转

实例：

转发：张三（客户端）到服务窗口A(服务端)满足请求，实际上服务窗口A需要在寻求服务窗口B办理，只不过张三不需要知道这个内部过程

重定向：

张三（客户端）到服务窗口A(服务端)满足请求，服务窗口A说要找服务窗口B办理，张三再去找服务窗口B

(4）session

先学一下，

4.1Cookie(客户端，不是内置对象)：

(1)Cookie是由服务端生成的，再发送给客户端保存；相当于本地缓存的作用

比如，客户端第一次访问服务端，服务端将访问信息生成Cookie 对象保存到客户端，下次请求同一网站时就发送该Cookie 给服务器，提高访问服务端的效率；Cookies 最典型的应用是判定注册用户是否已经登录网站，用户可能会得到提示，是否在下一次进入此网站时保留用户信息以便简化登录手续。

(2)Cookie包含一个键值对 key -value

Cookie对象是由类 javax.servlet.http.Cookie  产生，常用方法：

public Cookie(String key,String value) --->构造方法

String getName() --->获取key

String getValue() --->获取value

void setMaxAge(int expiry) --->设置最大有效时间（秒）

(3)服务端将访问信息生成Cookie 对象保存到客户端

服务端准备Cookie ： response.addCookie(Cookie cookie)
再页面跳转（转发或重定向）到客户端
客户端获取Cookie: request.getCookie()

注意：服务端增加Cookie 通过response对象，客户端获取 Cookie 通过request对象,而且获取的是全部的Cookie 对象

实例，模拟服务端和客户端：
```
<body>
	<%
		//模拟服务端
		     //创建Cookie对象，并赋值
		Cookie cookie1 = new Cookie("name","zs");
		Cookie cookie2 = new Cookie("pwd","abc");
			//服务端准备Cookie
		response.addCookie(cookie1);
		response.addCookie(cookie2);
			//页面跳转到客户端
		response.sendRedirect("requestc.jsp");
	%>
```
```
<body>
		<%
			//模拟客户端
				//客户端获取Cookie(获取到全部的Cookie对象)
			Cookie[] cookies = request.getCookies();
			for(Cookie cookie : cookies){
				out.print("所有Cookie对象的键值对"+cookie.getName() + "--->"+cookie.getValue()+"<br/>");
			}
		
		%>

</body>
```
输出结果：
```
所有Cookie对象的键值对name--->zs
所有Cookie对象的键值对pwd--->abc
所有Cookie对象的键值对JSESSIONID--->9DECDBEB875307895C8F447BD8939B49
```
4.2 session

session 意思是“会话” ，例如：浏览商品，从开始到关闭，称为一次会话

(1)运行机制：

客户端第一次请求服务端时，服务端会产生一个session对象（用于保存该客户的信息）,每个session对象与客户端的请求一一对应，是不会混的，每个session自带一个sessionID ,再把 sessionID赋值到JSESSIONID保存到Cookie的name 里面，再发送给客户端，客户端接收保存Cookie,Cookie里的JSESSIONID和 session 里的sessionID 相同，实现客户端的Cookie和服务端的session一一对应

客户端第二次/n次请求服务端时，服务端会先用客户端的Cookie里的JSESSIONID去和session 里的sessionID 进行匹配，若匹配成功，说明不是第一次访问；其实，每次都会进行匹配

顾客有口袋cookie 有钥匙JSESSIONID 去柜子session 的编号sessionID 开锁
- session存储在服务端
- session是在同一个用户请求时，共享；或者说，session：同一次会话共享
- 实现机制：用户第一次请求时，产生一个sessionID 并复制给cookie 的JSESSIONID ，发给客户端
（2） session方法

String getId() ---> 获取sessionID

boolean isNew()----> 判断是否是新用户（第一次访问）

void invalidate()----> 使session 失效（例如，退出登录，注销）

void setMaxInactiveInterval(秒)---> 设置最大有效非活动时间，超过，要重新登陆

int getMaxInactiveInterval(秒)---> 获取最大有效非活动时间

属性：

void setAttribute(String key,Object value) 以key/value的形式保存对象值

Object getAttribute(String key) 通过key获取对象值

实例：模拟session 获取和保存用户信息

登录页：login.jsp

判断登录的合法性: check.jsp

登录成功，把信息即属性值放到session 中，再跳转到欢迎页面
```
<body>
	   <form action="check.jsp"   method="post">
			用户名：<input type="text" name="uname"/><br/>
			密码：<input type="password" name="upwd"/><br/>
			<input type="submit" value="登陆"><br/>
		</form>
</body>
```
```
<body>
	<%
	 
	String name = request.getParameter("uname");
	String pwd = request.getParameter("upwd");
	if ("zs".equals(name) && "abc".equals(pwd)) {// 假设用户名必须是zs 密码是abc 
		 //只有登录成功时，会把uname = zs  和  upwd = abc  放入session 中
		 //获取用户名和密码放到session对象中
		 session.setAttribute("uname",name);
		 session.setAttribute("npwd",pwd);
		 //再跳转到一个欢迎页面 welcome.jsp
		 request.getRequestDispatcher("welcome.jsp").forward(request,response);	 
		 
	}
	%>
</body>
```
```
<%@ 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>
		欢迎您：
		<% 
			String name = (String)session.getAttribute("uname");//这里要强转一下
			//如果用户没有登录，而是直接通过地址栏访问welcom.jsp,则必然获取到的name是null(因为只有check.jsp检查后，才会存入session中) 
			//如果没有登录，要跳转到登录页面
			if(name!=null){
				out.print(name);
			}else{
				response.sendRedirect("login.jsp");
			}
//已经在浏览器登录后，直接访问http://localhost:8080/MyJspProject/ss/welcome.jsp  也是返回    欢迎您： zs
//换个浏览器，直接访问http://localhost:8080/MyJspProject/ss/welcome.jsp 
//会直接跳转到 http://localhost:8080/MyJspProject/ss/login.jsp
		%>
		
</body>
</html>
```
说明：

1. request ：数据仅同一次请求有效

本来已经访问check.jsp,就是把login.jsp中的zs 和 abc 数据提交给check.jsp

若在地址栏，按回车，相当于发出第二次请求，可能会报错或者空白

若点击F5刷新，则浏览器会自动重复刚才的行为，就是再次同样的请求
1. 理解一下：session：同一次会话共享，
会话可以举例为浏览一次网页，那在同一浏览器上通过 uname/pswd 访问服务端后

服务端会session与之对应；那用户以 uname/pswd 访问login.jsp ,a.jsp,b.jsp 等等

login.jsp ,a.jsp,b.jsp 等等是共享session

因此，在login.jsp ,a.jsp,b.jsp 等等都可以得到uname/pswd(通过session)

例如：新建a.jsp
```
<body>
		<%=session.getAttribute("uname") %>
</body>
```
在经过： login.jsp--->check.jsp 后，直接访问 a.jsp 是可以直接获取到用户名 zs

(3) 创建注销按钮

把注销放到超链接里面，而其在html中，注销让其超链接到 invalid.jsp

welcom.jsp
```
<body>
	欢迎您：
	<%
String name = (String) session.getAttribute("uname");

if (name != null) {
	out.print(name);
%>
  <a href="invalid.jsp">注销</a>
	<%
	} else {
	response.sendRedirect("login.jsp");
	}
	%>

</body>
```
invalid.jsp
```
<body>
	<% 
		session.invalidate();  // 把当前用户在session中所有信息删除
		//失效后让其返回登录页面
		response.sendRedirect("login.jsp");
	%>
</body>
```
(4)Cookie 和 session的区别

session Cookie

保存位置服务端客户端

安全性较为安全较不安全

保存的内容 Object String

void	setAttribute(String key,Object value)	以key/value的形式保存对象值
Object	getAttribute(String key)	通过key获取对象值

	session	Cookie
保存位置	服务端	客户端
安全性	较为安全	较不安全
保存的内容	Object	String

(5)pageContext

(6)application

全局对象

String getContextPath( ) 虚拟路径

String getRealPath( String name) 虚拟路径的绝对路径 ---->所以，先求出虚拟路径

 <body>
	<%="当前项目的虚拟路径："+application.getContextPath() %><br/>
	<%="当前项目的虚拟路径对应的绝对路径："+application.getRealPath("/MyJspProject") %><br/>

输出结果：

当前项目的虚拟路径：/MyJspProject
当前项目的虚拟路径对应的绝对路径：E:\Tomcat\wtpwebapps\MyJspProject\MyJspProject

(7)config

(8)page

(9)exception

javaweb_jsp elements javaweb jsp

javaweb_jsp javaweb error page

javaweb-jsp脚本javaweb笔记

javaweb-jsp-jstl javaweb foreach 2023

javaweb-jsp javaweb标签2023

526互联

javaweb 之 JSP 入门基础篇