unit08-JSP、EL、JSTL

JSP概述

什么是JSP

JSP和Servlet都是由SUN公司提供的动态Web资源开发技术。

JSP看起来像一个HTML，但和HTML不同的是，JSP中可以书写Java代码，可以通过Java代码展示动态的数据。

静态Web资源：任何人在任何条件下访问时，看到的都是相同的效果，这样的资源叫做静态Web资源。（html、css、js等）
动态Web资源：不同的人，在不同的条件下访问时，看到的都是不同的效果，这样的资源叫做动态Web资源。（Servlet、jsp、php、.NET等）

JSP本质上是一个Servlet程序

思考1：为什么要学习JSP?

Servlet是一段Java程序，适合处理业务逻辑，但是Servlet不适合向浏览器输出一个html网页。
html可以作为页面返回，但是html是一个静态Web资源，无法展示动态数据。
而JSP也是页面的开发技术，也可以作为页面返回，并且JSP中可以书写Java代码，可以通过Java代码展示动态的数据。
因此，JSP的出现即解决了Servlet不适合输出页面的问题，也解决了HTML无法展示动态数据的问题！

思考2：为什么说JSP本质是一个Servlet?

在JSP第一次被访问时，会翻译成一个Servlet程序。访问JSP后看到的html网页，其实是翻译后的Servlet执行的结果。（也就是说，访问JSP后看到的网页，是JSP翻译后的Servlet输出到浏览器的。）

JSP执行过程

访问服务器中的JSP文件，其执行过程为:

当浏览器请求服务器中的某一个JSP文件（例如：localhost:8080/day11-jsp/test.jsp），服务器会根据请求资源的路径去寻找该文件：
如果找到了，JSP翻译引擎会将JSP翻译成一个Servlet程序（JSP----> xxx.java----> xxx.class）,然后Servlet程序再执行，执行的结果是向浏览器输出一个HTML网页！
如果没有找到，服务器将会响应一个404页面，通知浏览器请求的资源不存在。

访问服务器中的HTML文件，其执行过程为:

当浏览器请求服务器中的某一个HTML文件时（例如：localhost:8080/day11-jsp/test.html），服务器会根据请求资源的路径去寻找该文件：
如果找到了，服务器会将html文件的内容作为响应实体发送给浏览器，浏览器再解析html并显示在网页上。
如果没有找到，服务器将会响应一个404页面，通知浏览器请求的资源不存在。

修改JSP默认编码

Eclipse中创建JSP默认使用的是latin-1码表，而这个码表中是没有中文数据的，如果在JSP中书写中文数据，会出现乱码提示。

将JSP使用的编码修改为utf-8，步骤如下：点击菜单栏中的 window --> Preferences，出现如下窗口:

JSP语法

模版元素

模板元素是指写在JSP中的html内容

或者除了JSP特有内容以外的其他内容称之为模板元素

模板元素在翻译后的Servlet中，被out.write原封不动的发送给浏览器，由浏览器负责解析并显示。

JSP表达式

格式：<%= 常量、变量、表达式 %>

作用：计算表达式的结果，将结果输出到浏览器中，由浏览器负责解析并显示。

<%= "Hello JSP..." %>
<% String name = "林青霞"; %>
<%= name %>
<%= 100+123 %>
<%= Math.random() %>

注意：JSP表达式中可以书写符合Java语法的代码，但是不能写Java语句(内部不能写分号;)

JSP脚本片段

格式：<% 若干Java语句 %>

作用：在翻译后的Servlet中，将脚本片段中的Java语句复制粘贴到Servlet的对应的位置执行。例如：

在JSP中代码如下：

<!-- 在页面上输出5行"hello JSP" -->
<%for(int i=0; i<5; i++){out.write("Hello JSP...<br/>");}
%>

在翻译后的Servlet中代码如下：

...
for(int i=0; i<5; i++){out.write("Hello JSP...<br/>");
}
...

另外，在某一个脚本片段中的Java代码可以是不完整的，但是在JSP中所有的脚本片段加在一起，必须是完整符合Java语法。例如，在JSP中代码如下：

<% for(int i=0;i<5;i++){ %>Hello JSP~~~<br/>
<% } %>

在翻译后的Servlet中：

for(int i=0;i<5;i++){ out.write("\r\n");out.write("\t\t\tHello JSP~~~<br/>\r\n");out.write("\t");
}

JSP注释

格式：<%-- JSP注释内容 --%>

作用：（1）为代码添加解释说明（2）将一些暂时不需要执行的代码注释掉。

在JSP翻译时，注释内容不会参与翻译，而是直接被丢弃

面试题：考察JSP中的JSP注释、Java注释、html注释

<%--
<% out.write( "aaaaa<br/>" ); %>--%>
<% //out.write( "bbbbb<br/>" ); %>
<!--
<% out.write( "ccccc<br/>" ); %>-->

问题：（1）上面输出的三行内容，在访问时，会显示哪一行内容？

第一行被JSP注释给注释了，JSP注释的内容不会参与翻译，也不会执行，更不会发送给浏览器，也不会在浏览器上显示。

第二行被Java注释给注释了，放在脚本片段中的内容会参与翻译，会将其中的Java代码复制到翻译后的Servlet中，但由于代码被注释了，所以不会执行，也不会发送给浏览器，更不会在浏览器上显示。

第三行被html注释给注释了，html注释在JSP中是模板元素，注释本身会发送给浏览器，注释中的脚本片段会参与翻译，其中的java代码也会执行，也会将内容（ccccc）发送给浏览器，但由于发送到浏览器后的ccccc被html注释包裹，因此也不会显示在浏览器上。

（2）上面输出的三行内容，哪一行会发送到浏览器中？（不管是否显示）

其中第三行内容会发送到浏览器中，但不会显示，因为前后有html注释。

JSP指令

指令的格式：<%@ 指令名称若干属性声明... %>

指令的作用：用于指挥JSP解析引擎如何将一个JSP翻译成一个Servlet程序。

1、page指令：用于声明JSP的基本属性信息（比如JSP使用的编码，JSP使用的开发语言等）

<%@ page language="java"%>
-- language属性用于指定当前JSP使用的开发语言，目前只有java语言支持，可以省略不写！<%@ page import="java.util.Date"%>
-- import属性用于导入包，如果不导入包，在使用其他包下的类时，就需要在类名前面加上包路径，例如： java.util.Date date = new java.util.Date();<%@ page pageEncoding="UTF-8"%>
-- pageEncoding属性是用于指定当前JSP使用的编码，Eclipse工具会根据这个编码保存JSP文件。
保证pageEncoding属性指定的编码和JSP文件保存时使用的编码相同,可以避免JSP文件出现乱码!

2、taglib指令：用于引入JSTL标签库或者其他的自定义标签库

后面讲解JSTL标签库时会讲解！

JSP标签技术

在JSP页面中写入大量的java代码会导致JSP页面中html代码和java代码混杂在一起，会造成jsp页面结构的混乱，导致后期难于维护，并且代码难以复用。

于是在JSP的2.0版本中，sun提出了JSP标签技术，推荐使用标签来代替JSP页面中java代码，并且推荐，JSP2.0以后不要在JSP页面中出现任何一行java代码。

EL表达式

格式：${ 常量/表达式/变量 } （放在EL中的变量得先存入域中，才可以获取变量的值）

作用：（1）计算放在其中的表达式的结果，将结果输出在当前位置。

（2）主要作用：用于从域对象中获取数据，将获取到的数据输出在当前位置。

域对象：pageContext、request、session、application

1、获取常量、表达式、变量的值（变量得先存入域中）

${ "hello el" }
hello el    <br/>
${ 100+123 }
${ 12*12 > 143 ? "yes" : "no" } <br/><% String name = "马云";request.setAttribute( "name123" , name );
%>
${ name123 }
<%= request.getAttribute("name123") %>
<%-- 在EL表达式中书写变量,底层会根据变量名到四个作用域中寻找该名称的属性值如果找到对应的属性值, 就直接返回, 输出到当前位置; 如果找不到就接着寻找直到找完四个作用域, 最后还找不到就什么都不输出!到四个作用域中寻找的顺序为: pageContext->request->session->application--%>

2、获取作用域中数组或集合中的元素

Servlet中的代码：

//声明一个数组, 为数组添加元素, 并将数组存入到域中
String[] names = {"刘德华", "郭富城", "张学友", "黎明" };
request.setAttribute( "names", names );
//将请求转发到jsp, 在JSP中获取域中的数组中的元素
request.getRequestDispatcher( "/02-el.jsp" ).forward(request, response);

JSP中的代码：

<%-- 获取从Servlet转发带过来的域中的数组中的元素 --%>
${ names[0] } <%-- 刘德华 --%>
${ names[1] } <%-- 郭富城  --%>
${ names[2] } <%-- 张学友 --%>
${ names[3] } <%-- 黎明 --%>

3、获取作用域中map集合中的元素

Servlet中的代码：

//声明一个map集合,为集合添加元素, 并将map集合存入到域中
Map map = new HashMap();
map.put( "name" , "尼古拉斯赵四" );
map.put( "age" ,  28 );
map.put( "addr", "中国" );
request.setAttribute( "map1", map );
//将请求转发到jsp, 在JSP中获取域中的数组中的元素
request.getRequestDispatcher( "/02-el.jsp" ).forward(request, response);

JSP中的代码：

${ map1.name } <%-- 尼古拉斯赵四 --%>
${ map1.age } <%-- 28 --%>
${ map1.addr } <%-- 中国 --%>

4、获取作用域中JavaBean对象的属性值

Bean：指可重用的组件
JavaBean：指Java中可重用的组件
业务Bean：专门用于处理业务逻辑（例如：处理注册请求时，在将用户的注册信息保存到数据库之前，需要对注册薪资进行校验）
实体Bean：是专门用于封装数据的（例如：User user = new User() ...）

Servlet中的代码：

//声明一个User对象, 为对象的属性赋值, 并将User对象存入到域中
User u1 = new User();
u1.setName( "刘德华" );
u1.setAge( 18 );
u1.setAddr( "中国香港" );
request.setAttribute( "user" , u1 );//将请求转发到jsp, 在JSP中获取域中的数组中的元素
request.getRequestDispatcher( "/02-el.jsp" ).forward(request, response);

JSP中的代码：

<%--
${ user.getName() }
${ user.getAge() }
${ user.getAddr() } --%>
<hr/>
<%-- user.name 底层调用的仍然是 getName()方法--%>
${ user.name }
<%-- user.age 底层调用的仍然是 getAge()方法--%>
${ user.age }
<%-- user.addr 底层调用的仍然是 getAddr()方法--%>
${ user.addr }

JSTL标签库

JSTL标签库是为JavaWeb开发人员提供的一套标准通用的标签库；

JSTL标签库和EL配合使用可以取代JSP中大部分的Java代码；

在使用JSTL标签库之前需要完成：

导入JSTL的开发包

在使用JSTL标签库的JSP中引入JSTL（taglib指令）

其中常用的标签如下:

1、<c:set></c:set> – 用于往域中添加属性，或者修改域中已有的属性值

c:set 标签属性总结:

(1)var -- 指定存入作用域中的属性名称
(2)value -- 指定存入作用域中属性的值
(3)scope -- 指定将属性存入哪一个作用域中,默认值是page,表示pageContext域
可取值: a)page表示pageContext域 b)request表示request域c)session表示session域 d)application表示ServletContext域

代码示例：

<%-- request.setAttribute("name", "张三"); --%>
<c:set var="name" value="张三" scope="request"/>
${ name }<% String job = "java开发工程师"; %>
<c:set var="job" value="<%= job %>" scope="request"/>
${ job }<c:set var="name" value="张三丰" scope="request"/>
${ name }

2、<c:if></c:if> – 构造简单的 if…else…结构语句

c:if 标签属性总结:

test属性 -- 指定一个布尔表达式，当表达式的结果为true时，将会执行（输出）c:if标签中的内容，如果表达式结果为false,将不会输出c:if标签中的内容

代码示例：往域中存入一个成绩, 根据成绩判断成绩所属的等级

<c:if test="${ 3>5 }">yes</c:if>
<c:if test="${ 3<=5 }">no</c:if>
<hr>
<!-- 根据成绩判断成绩所属的等级 -->
<c:set var="score" value="-35"/>
<c:if test="${ score>=80 and score<=100 }">您的成绩属于: 优秀!</c:if>
<c:if test="${ score>=60 and score<80 }">您的成绩属于: 中等!</c:if>
<c:if test="${ score>=0 and score<60 }">您的成绩属于: 不及格!</c:if>
<c:if test="${ score<0 or score>100 }">您的成绩有误!</c:if>

3、<c:forEach></c:forEach> – 对集合或数组等中元素进行循环遍历或者是执行指定次数的循环.

(1) 遍历域中数组或集合中的元素

<%String[] name = {"王海涛","刘沛霞","陈子枢","齐雷"};request.setAttribute( "names", name );
%>
<c:forEach items="${ names }" var="name" varStatus="vs">${ vs.count }, ${ vs.first }, ${ vs.last }, ${ name } <br/>
</c:forEach>

(2) 遍历域中map集合中的元素

<%//声明一个map集合并将map集合存入域中  Map<Object,Object> map = new HashMap<Object,Object>();map.put( "name" , "尼古拉斯.赵四" );map.put( "age" , 35 );map.put( "addr" , "中国" );request.setAttribute( "map1", map );
%>
<c:forEach items="${ map1 }" var="entry">${ entry } <br/>
</c:forEach>

(3) 遍历0~100之间的整数，将是3的倍数的数值输出到浏览器中

<c:forEach begin="1" end="100" var="i" step="1">${ i%3==0 ? i:""}
</c:forEach><hr/><c:forEach begin="1" end="100" var="i" step="1"><c:if test="${ i%3==0 }">${ i }</c:if>
</c:forEach>

c:forEach 标签属性总结:

(1)items: 指定需要遍历的集合或数组
(2)var: 指定用于接收遍历过程中的每一个元素
(3)begin: 指定循环从哪儿开始
(4)end: 指定循环到哪儿结束
(5)step: 指定循环时的步长, 默认值是1
(6)varStatus: 用于表示循环遍历状态信息的对象, 这个对象上有如下属性:first属性: 表示当前遍历是否是第一次, 若是, 则返回true;last属性: 表示当前遍历是否是最后一次, 若是, 则返回true;count属性: 记录当前遍历是第几次

代码示例：

JSP作业

06-13作业：

(1) 完成<<Servlet、request、response练习题>>

(2) 完成<<day11-jsp作业>>中的练习题

(3)练习课上讲的c:set标签、c:if标签以及c:foreach标签

unit09-Maven

今日学习目标：

了解什么是Maven及Maven的作用
掌握Maven安装及整合到Eclipse中
掌握如何使用Maven构建Java项目和Web项目
掌握使用Eclipse导入现有的Maven项目
了解Maven的三种仓库(本地仓库、远程仓库（私服）、中央仓库（公服）)
了解Maven如何管理依赖（即管理jar包）

Maven介绍

Maven是什么?

Maven: 翻译为"专家"、“内行”，是Apache下的一个纯Java开发的一个开源项目。

Maven是一个项目管理工具，使用Maven可以来管理企业级的Java项目开发及依赖的管理。

使用Maven开发，可以简化项目配置，统一项目结构。总之，Maven可以让开发者的工作变得更简单。

什么是依赖管理？要明白依赖管理，首先要知道什么是依赖？

一个Java项目中往往会依赖一些第三方的jar包。比如JDBC程序中要依赖数据库驱动包，或者在使用c3p0连接池时，要依赖c3p0的jar包等。这时我们称这些Java项目依赖第三方jar包。

而所谓的依赖管理，其实就是对项目中所有依赖的jar包进行规范化管理。

为什么要使用Maven?

传统的项目（工程）中管理项目所依赖的jar包完全靠人工进行管理，而人工管理jar包可能会产生诸多问题。

1、不使用Maven，采用传统方式管理jar包的弊端：

(1)在一些大型项目中会使用一些框架，比如SSM或者SSH框架，而框架中所包含的jar包非常多（甚至还依赖其他第三方的jar包），如果这些jar包我们手动去网上寻找，有些jar包不容易找到，比较麻烦。

(2)传统方式会将jar包添加到工程中，比如Java工程中将jar包放在工程根目录或者放在自建的lib目录下；JavaWeb工程会将jar包放在:/WEB-INF/lib目录下，这样会导致项目文件的体积暴增（例如，有些项目代码本身体积可能仅仅几兆，而加入jar包后，工程的体积可能会达到几十兆甚至百兆）。

(3)在传统的Java项目中是将所有的jar包统一拷贝的同一目录中，可能会存在jar包文件名称冲突的问题！

(4)在进行项目整合时，可能会出现jar包版本冲突的问题。

(5)在传统java项目中通过编译（手动编译或者在eclipse保存自动编译）、测试（手动在main函数中测试、junit单元测试）、打包部署(手动打war包/手动发布)、运行(手动启动tomcat运行)，最终访问程序。

2、使用Maven来管理jar包的优势：

(1)Maven团队维护了一个非常全的Maven仓库(中央仓库)，其中几乎包含了所有的jar包，使用Maven创建的工程可以自动到Maven仓库中下载jar包，方便且不易出错。

另外，在Maven构建的项目中，如果要使用到一些框架，我们只需要引入框架的核心jar包，框架所依赖的其他第三方jar包，Maven也会一并去下载。

(2)在Maven构建的项目中，不会将项目所依赖的jar包拷贝到每一个项目中，而是将jar包统一放在仓库中管理，在项目中只需要引入jar包的位置(坐标)即可。这样实现了jar包的复用。

(3)Maven采用坐标来管理仓库中的jar包，其中的目录结构为【公司名称+项目/产品名称+版本号】，可以根据坐标定位到具体的jar包。即使使用不同公司中同名的jar包，坐标不同（目录结构不同），文件名也不会冲突。

(4)Maven构建的项目中，通过pom文件对项目中所依赖的jar包及版本进行统一管理，可避免版本冲突。

(5)在Maven项目中，通过一个命令或者一键就可以实现项目的编译（mvn complie）、测试（mvn test）、打包部署（mvn deploy）、运行（mvn install）等。

还有发布到tomcat服务器中运行: mvn tomcat7:run。如果想实现上面的所有过程，只需要记住一个命令：mvn install

总之，使用Maven遵循规范开发有利于提高大型团队的开发效率，降低项目的维护成本，大公司都会优先使用Maven来构建项目.

Maven安装

下载、安装Maven

1、官方下载地址：http://maven.apache.org/download.cgi

2、下载绿色版，解压之后就可以使用。

原则: 安装的路径中不要有中文和空格!!

3、若要下载旧版本Maven，可以访问：

https://archive.apache.org/dist/maven/maven-3/

Maven的相关配置

在开发中更多是通过Eclipse+Maven来构建Maven项目，所以这里我们需要将Maven配置到Eclipse开发工具中。

在将安装好的Maven工具配置的Eclipse开发工具中之前，需要做一些相关的配置。

配置本地仓库位置

本地仓库：其实就是本地硬盘上的某一目录，该目录中会包含maven项目中所需要的所有jar包及插件。当所需jar包在本地仓库没有时，从网络上下载下来的jar包也会存放在本地仓库中。

因此本地仓库其实就是一个存放jar包的目录，我们可以指定Maven仓库的位置。

如果不指定，maven本地仓库的默认位置是在c盘，在：

C:/Users/{当前用户}/.m2/repository，例如:

可以保持默认，当然也可以修改本地仓库的位置到别的盘符路径。

修改方法：找到[MAVEN_HOME]/conf/目录中的配置文件settings.xml，修改maven仓库的路径。

配置该目录后，以后通过maven下载的jar包将会保存在配置的目录下。

以上内容可以总结为：

什么是本地仓库？
本地仓库的默认位置在哪儿？
配置和不配置本地仓库有什么区别？

配置远程仓库(私服)

当maven项目中需要依赖jar包时，如果本地仓库中没有，就会到远程仓库去下载jar包。

如果不配置远程仓库，默认连接的是中央仓库，由于中央仓库面向的是全球用户，所以在下载jar包时，速度可能会比较慢，效率会比较低。

可以在settings.xml文件中配置连接达内远程仓库（前提是在达内教室，连接的是达内内网）或者连接阿里云远程仓库（需要有外网）。

1、如果连接的是达内内网，可以连接达内远程仓库（如果不配置，默认连接中央仓库，没有外网，连接不了中央仓库，会导致jar包无法下载）。

需要做的是，在settings.xml文件中的<settings>标签下的<mirrors>标签内部添加如下配置，配置达内远程仓库：

<mirror><id>nexus-tedu</id><name>Nexus tedu</name><mirrorOf>central</mirrorOf><url>http://maven.tedu.cn/nexus/content/groups/public/</url>
</mirror>

2、如果在家里、在公司连接的是外网，是无法连接达内的远程仓库，可以选择什么都不配置，默认连接中央仓库，或者可以配置连接阿里云远程仓库（不要使用手机热点网络连接），配置如下：

配置阿里云远程仓库：

<mirror><id>nexus-aliyun</id><name>Nexus aliyun</name><mirrorOf>central</mirrorOf><url>http://maven.aliyun.com/nexus/content/groups/public/</url>
</mirror>

远程仓库配置总结：

当所需jar包在本地仓库没有时，会从网络上下载。配置远程仓库其实就是配置，去网络中哪个位置下载jar包到本地。
如果在公司，并且公司有搭建镜像服务器，推荐使用公司的镜像服务器下载jar包，速度会更快。（如果在达内，使用的是内网，只能配置达内的远程仓库。否则，没有外网也连接不了中央仓库，下载jar包会失败！）
如果在家里，使用的是外网，可以不配置远程仓库，默认连接中央仓库下载jar包，或者配置阿里云的远程仓库。连接阿里云服务器下载jar包。（注意，如果配置阿里云镜像服务器，不可使用手机热点网络！）

配置JDK版本

通过 Maven创建的工程，JDK版本默认是JDK1.5，每次都需要手动改为更高的版本。

这里可以通过修改maven的settings.xml文件, 达到一劳永逸的效果。

配置方式为：打开 {maven根目录}/conf/settings.xml 文件并编辑，在 settings.xml文件内部的 <profiles> 标签内部添加如下配置：

<profile><id>development</id><activation><jdk>1.8</jdk><activeByDefault>true</activeByDefault></activation><properties><maven.compiler.source>1.8</maven.compiler.source><maven.compiler.target>1.8</maven.compiler.target><maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion></properties>
</profile>

将Maven配置到Eclipse中

将Maven工具配置到Eclipse中，就可以通过Eclipse和自己安装的Maven创建Maven项目了。

1、window右键–> Preferences：

2、点击Maven选项，在右侧选项中勾选 “Download Artifact Sources”：

3、点击add将自己安装的Maven添加进来：

4、添加自己安装的Maven：

**一定要注意:**自己安装的Maven不要放在桌面上(容易丢失，并且路径中往往有空格)，maven的安装路径中也不要包含中文和空格!!

5、将默认的maven切换为自己配置的maven：

6、设置maven的settings文件的位置：

**7、测试是否配置成功：**window—> show view —> other中搜索"maven"，点击下面的选框中的选项

在弹出的窗口中，查看自己配置的本地仓库和远程仓库镜像:

Maven的项目构建

通过Maven构建Java项目分为两种方式：

（1）使用简单方式创建：创建Maven的简单Java工程以及创建Maven的简单Web工程

（2）使用模板方式创建：创建使用模板的Java工程以及创建使用模板的Web工程

在利用Maven构建项目时分两种，第一种是：创建简单工程**（Create a simple
project）**，即在创建时勾选前面的框。

(不勾选前面的框，即创建使用骨架（其实就是模版）创建Maven工程)

另，在创建简单工程时，还分为创建Java工程和JavaWeb工程。下面分别进行演示。

创建简单工程—Java工程

1、空白处右键New —> Maven Project：

2、在弹出的窗口中，勾选前面的框，创建一个简单工程（即不使用骨架），进入下一步。

3、在弹出的窗口中，填写内容(Package选择jar，即创建java工程)，点击完成即可。

在上述内容中，必填的内容有四项：

(1)Group Id – 组的名称，通常填写公司名称（比如com.tedu）或者组织名称(org.apache…)

(2)Artifact Id – 项目名称或者模块名称

(3)Version – 项目的版本，创建的项目默认是0.0.1-SNAPSHOT快照，也叫非正式版，正式版是RELEASE)

(4)Package – 项目的类型：jar表示创建的是Java工程，war表示创建的是web工程，pom表示创建的是父工程（当然相对的还有子工程）或者聚合工程，pom目前我们不讨论。

填写完毕后，点击完成即可完成创建简单Java工程

4、切换工程视图为包视图：window --> show view，在弹出的窗口中搜索：

创建简单工程—Web工程

1、空白处右键New —> Maven Project：

2、在弹出的窗口中，勾选前面的框，创建一个简单工程（即不使用骨架），进入下一步。

3、在弹出的窗口中，填写内容(Package选择war，即创建web工程)，点击完成即可。

4、创建完成后pom.xml文件会报错，说找不到web.xml文件，例如：

手动添加(拷贝)即可，例如:

5、创建Servlet程序，测试运行环境。

上面的错误是因为运行环境中缺少Servlet的jar包，将tomcat运行环境添加过来即可！

!!缺少Servlet运行环境解决方案：

在项目上点击鼠标右键，选择 “Properties” —> “Targeted Runtimes”:

或者，在项目中的pom.xml文件中的根标签下添加Servlet的jar包的坐标，引入Servlet的jar包，如下：

<dependencies><dependency><groupId>javax.servlet</groupId><artifactId>servlet-api</artifactId><version>2.5</version><scope>provided</scope></dependency><dependency><groupId>javax.servlet</groupId><artifactId>jsp-api</artifactId><version>2.0</version><scope>provided</scope></dependency>
</dependencies>

添加后保存pom文件。若还报错，在项目上右键选择 “Maven” —> “UpdateProject…” 更新工程即可！

6、实现Servlet程序

**7、测试访问：**打开浏览器访问地址：http://localhost/MavenSimpleProJavaweb/HelloServlet

Maven的目录结构

使用Maven创建的工程我们称它为Maven工程，Maven工程具有一定的目录规范，对目录结构有严格的要求，一个Maven工程要具有如下目录结构：

下面以Maven的Web项目为例，介绍Maven项目中的目录结构：

Maven项目名称(Web项目)|-- src/main/java(源码目录)：用于存放程序/项目所需要的java源码文件|-- src/main/resources(源码目录)：用于存放程序/项目所需要的配置文件|-- src/test/java(源码目录)：用于存放测试程序的java源文件|-- src/test/resources(源码目录)：用于存放测试程序所需要配置文件|-- src/main/webapp：(Web应用的根目录，作用类似于WebContent)|-- WEB-INF：(受保护的目录)|-- web.xml：(Web应用的核心配置文件)|-- target/classes(类目录)：源码目录中的资源经过编译后，会输出到类目录下。|-- pom.xml：Maven项目中非常重要的文件，将来项目需要任何jar包或插件，都可以通过pom文件来导入这些jar包或插件。

导入已有的Maven项目

现将后面通过SSM框架实现的<<永和大王门店管理系统>>（Maven）项目导入到我们的Eclipse开发环境中。

在导入项目时我们通常会通过 “File” --> “Import…” 来导入项目，但是这样能会产生环境问题，例如：如果项目本身自带的环境和我们当前使用的开发环境不一致，就会产生问题。可以按照下面的方式来进行导入。

下面是导入的步骤：

1、创建一个新的Maven工程（JavaWeb工程）

确保已经配置好Maven的环境后，在Eclipse中创建一个新的Maven工程（Javaweb工程），新工程的名字和所导入的工程的名字可以相同也可以不同，例如：

2、解压yonghe-ssm.zip压缩包

将下发的 yonghe-ssm 项目解压出来，解压后的结构如下：

打开 yonghe-ssm 目录：

3、将解压后的目录中的src目录选中并复制。

4、点击新创建的Maven工程右键粘贴，将复制的src目录粘贴到新建的工程中

5、打开解压后的目录中的pom.xml文件, 复制其中的内容：

如果复制后项目或pom文件仍然报错, 可以更新Maven工程

**更新Maven工程：**在项目上右键选择 “Maven” —> “Update
Project…”，在弹出的窗口中直接点击OK即可！

6、执行SQL脚本文件，导入数据

打开cmd，连接mysql数据库，执行yonghedb.sql中的SQL语句，创建数据库、表及插入记录。

7、部署项目到服务器并启动服务器，访问测试

在正确完成上面的操作后，打开浏览器访问如下地址：http://localhost/yonghe-ssm/index
，可以看到如下界面：

Maven的依赖管理

依赖(jar包)管理

依赖管理即jar包的管理，那么通过Maven创建的工程是如何管理jar包的？

1、在Maven项目中如何引入jar包？

在Maven创建的项目中，如果需要引用jar包，只需要在项目的pom.xml文件中添加jar包的坐标(GroupID + ArtifactID + Version)即可将jar包引进项目中，之后就可以在项目中使用所引入的jar包了。

例如，现在我们在pom.xml文件中，添加servlet的jar包的坐标如下：

<dependency><groupId>javax.servlet</groupId><artifactId>servlet-api</artifactId><version>2.5</version><scope>provided</scope>
</dependency>

在pom.xml文件中，添加mysql驱动包的坐标如下：

<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.32</version>
</dependency>

2、项目中引入的jar包存放在哪里？

那么问题来了，在pom文件中添加的servlet的jar包坐标，添加的仅仅是一个jar包对应的坐标，而这个jar包到底存放在哪里呢?

了解Maven管理jar包的规则之后，我们可以找到jar包的存放位置是在本地仓库（仓库默认是在：C:\Users\{当前用户}\.m2\repository）的 /javax/servlet/servlet-api/2.5/目录下，例如：

总结：

在Maven中，所有的jar包全都存放在本地仓库的目录中，如果项目中需要使用某一个jar包，直接在项目的pom.xml文件中通过坐标(GroupID + ArtifactID + Version)引入指定位置的jar包即可。
这样可以将项目中所有使用的jar包集中在一个目录（本地仓库）中统一进行管理，需要时通过坐标直接引入即可，而不是在每个项目中都拷贝一份，减少了项目体积，也节省了磁盘空间。
将来如果别人需要导入你的项目，只需要将项目（当然包括pom.xml文件）代码整体传给对方，无需将jar包发送给对方，对方在配置Maven的环境后，Maven会自动根据项目中pom.xml文件里配置的坐标，引入（或下载后再引入）对应的jar包。

3、如果引入的jar包在本地仓库中没有呢？

如果是刚配置的Maven环境，本地仓库中还没有太多jar包，此时在pom文件中通过坐标引入jar包，而本地仓库中没有这个jar包，这时会怎么样呢？
若本地仓库没有所需要的jar包，则会到远程仓库（也叫私服）或者到中央仓库（也叫公服）中下载。下面我们就来介绍Maven的这三种仓库。

Maven三种仓库

在上面所提到的本地仓库、远程仓库、中央仓库是用来Maven用来更好的管理jar包的所采用的一种方式。下面来了解Maven的三种仓库，以及三种仓库之间的潜在联系。

通过maven构建的项目，会通过项目中的pom.xml文件从远程仓库下载，并保存到本地仓库

本地仓库：默认的本地仓库位置在：c:/${user.dir}/.m2/repository，其中${user.dir}表示windows下的用户目录。本地仓库的作用是，用于保存（存储）从私服或者从中央仓库下载下来的jar包（或插件）。当项目中需要使用jar包和插件时，优先从本地仓库查找。

如果本地仓库中没有所需的jar包，可以到私服或者到中央仓库中下载后再保存到本地仓库。

远程仓库：远程仓库也叫做私服（Nexus），私服一般由公司搭建并维护（也可以自己搭建）。比如达内有搭建自己的私服服务器（http://maven.tedu.cn/nexus/content/groups/public/），以及阿里云私服服务器（http://maven.aliyun.com/nexus/content/groups/public/）。

如果项目中使用到的jar包或者插件本地仓库中没有，则可以到私服中下载，如果私服中有就直接将jar包保存到本地仓库中；而如果私服中也没有所需的jar包，就到中央仓库（公服）上下载所需要的jar包，下载之后先在私服上保存一份，最后再保存到本地仓库。

中央仓库：中央仓库也叫做公服，在maven软件中内置了一个仓库地址（http://repo1.maven.org/maven2）它就是中央仓库，服务于整个互联网，由Maven团队自己搭建并维护，里面存储了非常全的jar包，它包含了世界上大部分流行的开源项目的jar包。

那么我们在使用Maven构建的Java项目，项目中所使用的jar包会来自哪里呢？例如，通过Maven先后构建项目A和项目B，在项目中都需要依赖第三方jar包：

如果项目A中需要依赖第三方jar包，只需要在项目下的pom文件中引入jar包在本地仓库中的坐标即可使用。如果本地仓库没有所需要的jar包，则会连接私服（需要提前配置）下载所需jar包到本地仓库供项目使用。
如果私服上也没有所需的jar包，则会连接中央仓库下载所需要的jar包保存到私服，再将jar包从私服下载至本地仓库，供项目使用。
如果没有配置私服，则默认连接中央仓库下载所需要的jar包到本地仓库中供项目使用
当项目B也需要依赖第三方jar包时，先到本地仓库中查找所需jar包，如果有则直接引用而无需再次下载，如果仍有部分jar包本地仓库中没有，则同上，即连接私服下载所需jar包到本地仓库。若私服中也没有所需jar包，则连接中央仓库下载jar包到私服，再从私服下载jar包到本地仓库中，供项目使用。

添加依赖:方式一

使用maven插件的索引功能快速添加jar包

这种方式需要本地仓库中已经包含了该jar包，否则搜索不到!!!

1、如果本地仓库中有我们需要的jar包，可以在项目中的pom.xml文件中空白处右键–> Maven --> Add Dependency在弹出的窗口中添加所需要的依赖(jar包)，如图：

**2、**添加依赖示例：添加spring的jar包的坐标到项目中

(1) 在项目中的pom.xml文件中右键 -> Maven -> Add Dependency，在弹出的窗口中输入
“spring”:

选中要添加的jar包（坐标会自动填写），点击OK即可完成添加

(2)如果搜索不到jar包（保证本地仓库中已经下载了该jar包），可以尝试重建索引。

在

“Maven Repositories” 视图窗口中可以看到如下内容：

在"Local Repositories"上右键选择 “Rebuild Index” 即可重建索引。

完成后，再尝试搜索jar包进行添加。

添加依赖:方式二

1、直接在pom.xml文件中的标签内部添加。例如：在pom.xml文件中添加如下配置，就可以将junit单元测试的jar包引入到项目中来了。

添加依赖：

<dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.9</version><scope>test</scope><dependency>
<dependencies>

2、手动添加依赖需要指定所依赖jar包的坐标，但是在大部分情况下，我们是不知道jar包的坐标的。可以通过访问如下网址，在互联网上搜索查询：

http://mvnrepository.com

或者在公司远程仓库中搜索查询:

http://maven.tedu.cn/nexus

3、示例：添加c3p0的jar包的坐标到项目中

访问上面其中的一个网址，在搜索框中搜索 “c3p0”
在搜索出来的内容中，选择所需要的版本并点击版本，查看该版本的c3p0
jar包所对应的坐标：
将坐标直接拷贝到项目的pom.xml文件中即可：

4、将上图中右侧选中的坐标拷贝到pom.xml文件中:

扩展:Maven常见问题

拷贝Maven仓库

如果因为网络环境的问题（比如：电脑没有网络），导致jar包无法下载，也可以将别人下载好的（完整的）Maven的本地仓库拷贝过来，放在自己配置的本地仓库中。因为Maven可以支持拷贝别人的仓库。

常见环境问题

问题描述1：

创建Maven项目时报如下错误：

或者创建Maven项目目录结构不全（比如只有src目录），如下图：

导入已有的Maven项目，项目运行不了（jar没有下载完全）

此时是因为maven的环境被破坏了，导致Maven基础运行环境不全，无法创建Maven项目，或者无法下载所需要的jar包。解决方法：

(1)在项目的pom文件中敲一个空白行,再保存文件，目的是让maven检测到pom文件发生变化，再根据pom文件中的配置到本地仓库中寻找对应的jar包，如果没有相应的jar包，maven会重新下载。
(2)如果上面的方式不行,可以尝试在项目上,右键---> Maven ---> Update Project...,强制更新项目,此时maven也会检查pom文件，在本地仓库中有没有相应的jar包。
(3)如果上面的方式仍然没有解决问题，检查当前网络环境是否能连接上所配置的远程仓库。（比如在家里使用外网，无法连接达内的远程仓库，或者使用手机热点网络无法连接阿里云的远程仓库等）a) 在达内教室，连接的是达内内网：在settings.xml文件中配置连接达内的远程仓库b) 在家里，用的是外网（不是手机热点）：可以不配置，默认连接中央仓库，或者 在settings.xml文件中配置连接阿里云仓库c) 用的是手机热点网络：不可以配置连接达内远程仓库或者阿里云仓库，连不上！！
(4)如果网络能够连接上所配置的远程仓库，到本地仓库的目录下，将本地仓库中所有的目录都删除，删除时，eclipse正在使用本地仓库中的资源文件，所以会阻止删除，此时将eclipse关闭，再将本地仓库中的所有目录删除，重启eclipse。
(5)启动eclipse后,再将上面的第(1)步和第(2)步再做一遍!
(6)如果还是不行,就使用老师下发的本地仓库替换你的本地仓库!

**问题描述2：**每天第一次打开Eclipse发现之前创建的Maven工程报错（比如项目上有叉号或者叹号，但项目之前是OK的），解决方法：在菜单栏中找到 Project —> Clean…

或者是：在报错的项目上鼠标右键 --> Maven --> Update Project：

找不到jar包问题

在项目中通过坐标引入了jar包（或者插件），并且本地仓库中也存在对应的jar包，但是项目还是报错，提示内容说找不到。

解决方法：如果引入的jar包，在本地仓库中存在，但是还是提示找不到，可以将本地仓库中jar包或插件的所在目录整个删除(如果删除时提示文件正在被占用，关闭eclipse再删除即可)，重新保存pom.xml文件，并更新工程，让maven再次下载上面的jar包即可！

未下载完全示例：

正常下载完全示例：

Maven的依赖范围

下面添加了一个 jsp-api 的依赖，maven就会去下载 jsp-api 的jar包及它依赖的一些jar包。

<dependency><groupId>javax.servlet</groupId><artifactId>jsp-api</artifactId><version>2.0</version><scope>provided</scope>
</dependency>

依赖配置中有一个scope之前没讲过，它就是依赖范围。

1、什么是依赖范围：就是指定你这个jar包在哪个阶段时才有效。

compile - 编译依赖范围。默认的范围，可以不填，表示在所有过程中都有效，如编译期、测试过程中、运行期间等。
provided - 已提供依赖范围。这个范围表示只提供编译和测试阶段有效，运行期间不需要，像tomcat等容器本身已经提供的 servlet-api、jsp-api 等依赖。
runtime - 运行时依赖范围。这个范围表示只有在运行和测试期间才有效，编译期间不需要，像连接数据库的jdbc驱动程序等。
test - 测试依赖范围。这个范围只有测试阶段有效，编译和运行不需要，像单元测试提供的junit包。
system - 系统依赖范围。这个范围表示不依赖本地仓库，jar在其他的目录，需要通过systemPath指定路径，这个不建议使用。
import - 引用依赖范围。Maven2.0.9之后新增的范围，只能用在中，并且导入的type为pom类型的父工程配置，一般用来解决多继承问题。

2、什么是依赖传递：

依赖的传递前面讲过通过继承和聚合的方式可以达到，通过继承的方式可以轻松的从父项目继承过来，通过聚合的方式也可以间接的传递过来。

继承：A继承B，A就可以继承B的dependencies依赖。

聚合：A依赖C，C依赖D，那么A就要依赖D自然也就获取了D的依赖。

3、什么是依赖排除：

在依赖传递过程中，如 A 依赖 B、S2.0，B 依赖C、S1.0，这样A就有了S1.0和S2.0两个依赖，这样某些情况下会造成冲突需要手动把B间接传递过来的依赖排除掉，就是不依赖B带过来的S1.0的包。

<dependency><groupId>org.testgroupId><artifactId>B</artifactId><version>1.0</version><!-- 排除B传递过来的S依赖 --><exclusions><exclusion><groupId>com.test</groupId><artifactId>S</artifactId></exclusion></exclusions>
</dependency>

或者直接设置排除所有间接依赖：

<dependency><groupId>org.testgroupId><artifactId>B</artifactId><version>1.0</version><!-- 排除B传递过来的所有依赖 --><exclusions><exclusion><groupId>*</groupId><artifactId>*</artifactId></exclusion></exclusions>
</dependency>

maven作业

1、练习将Maven整合到Eclipse中（可以切换一个新的工作空间进行练习）

2、练习使用Maven创建简单的Java工程

3、练习使用Maven创建简单的JavaWeb工程

4、练习导入已有的Maven工程

5、Maven的三种仓库每种仓库的作用，以及三种仓库之间的联系

6、Maven项目中是如何管理jar包的？

(1)Maven项目是如何引入jar包
(2)Maven项目中引入的jar包存放在哪里
(3)Maven项目引入的jar包在本地仓库中没有会怎样

总结：

1、掌握Maven的下载、安装、配置

（1）配置本地仓库的位置

（2）配置远程仓库：如果不配置，默认连接中央仓库（需要外网）；也可以配置连接达内的远程仓库（在达内，有达内内网）；或者配置连接阿里云的远程仓库（需要外网，并且不可以使用手机热点）；

（3）配置JDK版本（Maven创建的工程JDK版本默认是JDK1.5，可以通过配置修改JDK的版本）

（4）将Maven配置到Eclipse中（Eclipse整合Maven）

2、重点掌握：通过Maven创建Java项目、Web项目；导入已有的Maven项目

3、了解Maven的三种仓库（本地仓库、远程仓库、中央仓库）

4、重点掌握：为Maven项目添加依赖（方式一(要求本地仓库中必须有这个jar文件)、方式二）

unit10-Cookie、Session

什么是会话

什么是会话：当浏览器发请求访问服务器开始，一直到访问服务器结束，浏览器关闭为止，这期间浏览器和服务器之间产生的所有请求和响应加在一起，就称之为浏览器和服务器之间的一次会话。

在一次会话中往往会产生一些数据，而这些数据往往是需要我们保存起来的，如何保存会话中产生的这些数据呢？

比如在购物过程中，将商品加入购物车，其实就是将商品信息保存到数据库中。（不讨论）
如果在没有登录时，将商品加入购物车，其实就是将商品信息保存到了cookie或session中。

可以使用cookie或者session保存会话中产生的数据。

如何将会话中产生的数据保存到cookie或者是session中？

cookie原理及应用

cookie的工作原理

Cookie是将会话中产生的数据保存在客户端，是客户端技术。
Cookie是基于两个头进行工作的：分别是Set-Cookie响应头和Cookie请求头
通过Set-Cookie响应头将cookie从服务器端发送给浏览器，让浏览器保存到内部；而浏览器一旦保存了cookie，以后浏览器每次访问服务器时，都会通过cookie请求头，将cookie信息再带回服务器中。在需要时，在服务器端可以获取请求中的cookie中的数据，从而实现某些功能。

cookie的API及应用

1、创建Cookie对象

Cookie c = new Cookie(String name, String value);
// 创建cookie的同时需要指定cookie的名字和cookie要保存的值
// Cookie的名字一旦指定后，就无法修改！

2、将Cookie添加到response响应中

response.addCookie( Cookie c );
// 将cookie添加到响应中，由服务器负责将cookie信息发送给浏览器，再由浏览器保存到内部（可以多次调用该方法，添加一个以上的cookie）

3、获取请求中的所有cookie对象组成的数组

Cookie[] cs = request.getCookies();
// 获取请求中携带的所有cookie组成的cookie对象数组，如果请求中没有携带任何cookie，调用该方法会返回null。

4、删除浏览器中的Cookie

// cookie的API中没有提供直接删除cookie的方法，可以通过别的方式间接删除cookie
// 删除名称为cart的cookie：可以向浏览器再发送一个同名的cookie（即名称也叫做cart），并设置cookie的最大生存时间为零，由于浏览器是根据cookie的名字来区分cookie，如果前后两次向浏览器发送同名的cookie，后发送的cookie会覆盖之前发送的cookie。而后发送的cookie设置了生存时间为零，因此浏览器收到后也会立即删除！

代码示例：

//创建一个名称为cart的cookie
Cookie c = new Cookie("cart", "");
//设置cookie的最大生存时间为零
c.setMaxAge( 0 );
//将cookie添加到响应中,发送给浏览器
response.addCookie( c );
out.write( "成功删除了名称为cart的cookie..." );

5、Cookie的常用方法

cookie.getName(); // 获取cookie的名字
cookie.getValue(); // 获取cookie中保存的值
cookie.setValue(); // 设置/修改cookie中保存的值(没有setName方法,因为cookie的名字无法修改)
cookie.setMaxAge(); //设置cookie的最大生存时间（如果不设置，cookie默认在一次会话结束时销毁!）

6、setMaxAge方法：设置cookie的最大生存时间

如果不设置该方法，cookie默认是会话级别的cookie，即生存时间是一次会话。当浏览器关闭，会话结束时，cookie也会被销毁（cookie默认存在浏览器的内存中，当浏览器关闭，内存释放，cookie也会随着内存的释放而销毁。）
如果设置了该方法，cookie将不会保存到浏览器的内存中，而是以文件形式保存到浏览器的临时文件夹中（也就是硬盘上），这样再关闭浏览器，内存释放，保存到硬盘上的cookie文件不会销毁，再次打开浏览器，还可以获取硬盘上的cookie信息。

代码示例：

//创建一个Cookie对象，将商品信息保存到cookie中
Cookie cookie = new Cookie( "cart", prod  );
//设置cookie的最大生存时间, 单位:秒
cookie.setMaxAge( 60*60*24 );
//将cookie对象添加到response响应中
response.addCookie( cookie );

案例:使用cookie模拟购物车

1.index.html

...
<body><h3>点击下面的商品链接, 可以将商品加入购物车</h3><!-- http://localhost/day13-cookie/CartServlethttp://localhost/day13-cookie/index.html--><p><a href="CartServlet?prod=iphone11">iphone11</a></p><p><a href="CartServlet?prod=vivonex3">vivonex3</a></p><p><a href="CartServlet?prod=xiaomishouji">xiaomishouji</a></p><p><a href="CartServlet?prod=huaweip30">huaweip30</a></p><p><a href="CartServlet?prod=海尔洗衣机">海尔洗衣机</a></p><h3>点击下面的支付链接, 可以对购物车中的商品进行结算</h3><a href="PayServlet">支付</a>
</body>
...

2.CartServlet

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html;charset=utf-8");PrintWriter out = response.getWriter();//-------------------------------------------------------//获取请求中携带的商品信息(将要加入购物车的商品信息)String prod = request.getParameter( "prod" );//创建一个Cookie对象，将商品信息保存到cookie中Cookie cookie = new Cookie( "cart", prod  );//设置cookie的最大生存时间, 单位:秒cookie.setMaxAge( 60*60*24 );//将cookie对象添加到response响应中response.addCookie( cookie );//做出回应out.write( "成功将"+prod+"加入了购物车....." );
}

3.PayServlet

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html;charset=utf-8");PrintWriter out = response.getWriter();//------------------------------------------------------//获取请求中的所有cookie信息(null/cookie数组)Cookie[] cs = request.getCookies();//遍历所有cookie数组, 找出名称为cart的cookieString prod = null;if( cs != null ) {for (Cookie c : cs) {if( "cart".equals( c.getName() ) ) {//获取cookie中保存的商品信息prod = c.getValue();}}}//为商品进行结算if( prod == null ) {out.write( "您还没有将商品加入购物车...." );}else {out.write( "成功为"+prod+"支付了1000.00元...." );}
}

session原理及应用

session的工作原理

Session是将会话中产生的数据保存在服务器端，是服务器端技术
Session是一个域对象，session中也保存了一个map集合，往session中存数据，其实就是将数据保存到session的map集合中。
通过session.setAttribute()方法可以将数据保存到session中，通过session.getAttribute()方法可以将数据从session中取出来。

session是一个域对象

获取session对象：

request.getSession()
// 获取一个session对象；如果在服务器内部有当前浏览器对应的session，则直接返回该session对象；如果没有对应session，则会创建一个新的session对象再返回；

Session是一个域对象，session中也保存了一个map集合，并且session中也提供了存取数据的方法，如下：

session.setAttribute(String attrName, Object attrValue);
// 往session域中添加一个域属性，属性名只能是字符串类型，属性值可以是任意类型。
session.getAttribute(String attrName);
// 根据属性名获取域中的属性值，返回值是一个Object类型

Session域对象的三大特征：

(1)生命周期：

**创建session：**第一次调用request.getSession()方法时，会创建一个session对象。（当浏览器在服务器端没有对应的session时，调用request.getSession()方法服务器会创建一个session对象。）

销毁session：

超时销毁：默认情况下，当超过30分钟没有访问session，session就会超时销毁。（30分钟是默认时间，可以修改，但不推荐修改）
自杀：调用session的invalidate方法时，会立即销毁session。
意外身亡：当服务器非正常关闭时（硬件损坏，断电，内存溢出等导致服务器非正常关闭），session会随着服务器的关闭而销毁；

当服务器正常关闭，在关闭之前，服务器会将内部的session对象序列化保存到服务器的work目录下，变为一个文件。这个过程叫做session的钝化（序列化）；再次将服务器启动起来，钝化着的session会再次回到服务器，变为服务器中的对象，这个过程叫做session的活化（反序列化）。

**(2)作用范围：**在一次会话范围内（获取到的都是同一个session对象）

**(3)主要功能：**在整个会话范围内实现数据的共享

案例:使用session模拟购物车

1、index.html

<body><h3>点击下面的商品链接, 可以将商品加入购物车</h3><!-- http://localhost/day13-cookie/CartServlethttp://localhost/day13-cookie/index.html--><p><a href="CartServlet?prod=iphone11">iphone11</a></p><p><a href="CartServlet?prod=vivonex3">vivonex3</a></p><p><a href="CartServlet?prod=xiaomishouji">xiaomishouji</a></p><p><a href="CartServlet?prod=huaweip30">huaweip30</a></p><p><a href="CartServlet?prod=海尔洗衣机">海尔洗衣机</a></p><h3>点击下面的支付链接, 可以对购物车中的商品进行结算</h3><a href="PayServlet">支付</a>
</body>

2、CartServlet

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html;charset=utf-8");PrintWriter out = response.getWriter();//------------------------------------------------------//获取将要添加到购物车的商品信息String prod = request.getParameter( "prod" );//获取一个session对象，将商品信息保存到session中HttpSession session = request.getSession();//设置session的超时时间为30秒//session.setMaxInactiveInterval( 30 );session.setAttribute( "cart" , prod );//做出响应out.write( "成功将 [ "+prod+" ] 加入了购物车~~~" );
}

3、PayServlet

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html;charset=utf-8");PrintWriter out = response.getWriter();//获取一个session对象(之前的session)HttpSession session = request.getSession();//从session中获取到要结算的商品信息String prod = (String)session.getAttribute( "cart" );//对商品进行结算,做出回应out.write( "成功为 [ "+prod+" ] 支付了2000.00元~~~~" );
}

总结:两者的区别

Cookie和session都属于会话技术，都可以保存会话中产生的数据，但由于cookie和session的工作原理和特点不同，因此两者的应用场景也不一样。

Cookie的特点：

cookie是将会话中产生的数据保存在浏览器客户端, 是客户端技术（JS可以访问cookie）
cookie是将数据保存在客户端浏览器，容易随着用户的操作导致cookie丢失或者被窃取，因此cookie中保存的数据不太稳定，也不太安全。
但cookie将数据保存在客户端，对服务器端没有太多影响，可以将数据保存很长时间。
总结：因此cookie中适合存储需要长时间保存、但对安全性要求不高的数据。
浏览器对cookie的大小和个数都有限制，一般推荐每一个站点给浏览器发送的cookie数量不超过20个，每一个cookie的大小不超过1kb。
Cookie的应用：实现购物车、记住用户名、30天内自动登录等。

Session的特点

session是将会话中产生的数据保存在服务器端，是服务器端技术
session将数据存在服务器端的session对象中，相对更加的安全，而且更加稳定。不容易随着用户的操作而导致session中的数据丢失或者是被窃取。
但session是服务器端的对象，在并发量较高时每一个浏览器客户端在服务器端都要对应一个session对象，占用服务器的内存空间，影响效率。
总结：因此session中适合存储对安全性要求较高，但不需要长时间保存的数据。
Session的应用：保存登录状态、保存验证码

扩展内容

cookie中保存中文数据的问题

以下问题是针对Tomcat8.0及8.0以下的版本，在Tomcat8.5及8.5以后的版本中已经解决了该问题！

HTTP协议中规定了请求信息和响应信息中不能包含中文数据！

因此通过浏览器向服务器发送中文数据时，浏览器会将中文数据进行URL编码，编码为下面这种格式：

http://localhost/day13-cookie/index.html?user=%E5%BC%A0%E9%A3%9E%E9%A3%9E

将中文数据转成下面这种格式，叫做URL编码：

张飞飞 ---> URL编码 ---> %E5%BC%A0%E9%A3%9E%E9%A3%9E

将下面这种格式再次转回中文数据，叫做URL解码：

%E5%BC%A0%E9%A3%9E%E9%A3%9E ---> URL解码---> 张飞飞

问题：当cookie中保存中文数据，将cookie添加到响应中时，会报一个500异常，如下：

解决方法是：

将存入cookie中的先进行URL编码，再存入Cookie中，例如：

从cookie取出来的数据是进行URL编码后的数据，在使用之前需要进行URL解码，例如：

获取不到之前的session的问题

将商品保存到session中后，关闭浏览器再打开浏览器，访问服务器，此时获取不到之前的session。因为session是基于Cookie工作的。

在服务器创建一个session后，会为session分配一个独一无二的编号，称之为session的id，在此次响应时，服务器会将session的id以一个名称为JSESSIONID的cookie发送给浏览器保存到浏览器内部。

由于保存sessionid的cookie默认是会话级别的cookie，在浏览器关闭后，cookie会跟着销毁，sessionid也丢失了。因此下次访问服务器，没有session的id就获取不到之前的session。也获取不到session中的商品信息

解决方法：我们可以创建一个名称为JSESSIONID的cookie，其中保存session的ID，并设置cookie的最大存活时间，让cookie保存到硬盘上（即使浏览器关闭，cookie也不会销毁），这样下次访问服务器时，还可以将sessionid带给服务器，服务器可以通过sessionid获取到之前的session。从session中获取到商品信息

04-02作业：

1、描述Cookie保存数据的原理

2、描述session保存数据的原理

3、练习课上案例:使用cookie技术实现购物功能

4、练习课上案例:使用session技术实现购物功能

unit11-MySQL数据库事务

今日目标:

了解事务的作用
掌握事务的四大特性(面试)
了解事务的三个并发读问题
掌握mysql开启和结束事务
了解事物的四个隔离级别

事务及四大特性

什么是事务

数据库事务(Database Transaction)，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。

简单的说：事务就是将一堆的SQL语句(通常是增删改操作)绑定在一起执行，要么都执行成功，要么都执行失败，即都执行成功才算成功，否则就会恢复到这堆SQL执行之前的状态。

下面以银行转账为例，张三转100块到李四的账户，这至少需要两条SQL语句：

给张三的账户减去100元；

update 账户表 set money=money-100 where name='张三';

给李四的账户加上100元。

update 账户表 set money=money+100 where name='李四';

如果在第一条SQL语句执行成功后，在执行第二条SQL语句之前，程序被中断了（可能是抛出了某个异常，也可能是其他什么原因），那么李四的账户没有加上100元，而张三却减去了100元，在现实生活中这肯定是不允许的。

如果在转账过程中加入事务，则整个转账过程中执行的所有SQL语句会在一个事务中，而事务中的所有操作，要么全都成功，要么全都失败，不可能存在成功一半的情况。

也就是说给张三的账户减去100元如果成功了，那么给李四的账户加上100元的操作也必须是成功的；否则，给张三减去100元以及给李四加上100元都是失败的。

事务的四大特性

事务的四大特性(ACID)是：

(1)原子性（Atomicity）：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。

(2)一致性（Consistency）：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，无论事务执行成功与否，参与转账的两个账户金额之和在事务前后应该是保持不变的。

张三：1000   1000-500=500       1000
李四：1000  1000+500=1500         1000

(3)隔离性（Isolation）：隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不会相互干扰。也就是说，在事中务查看数据更新时，数据所处的状态要么是另一事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看到中间状态的数据。例如：在A事务中，查看另一B事务(正在修改张三的账户金额)中张三的账户金额，要查看到B事务之前的张三的账户金额，要么查看到B事务之后张三的账户金额。

事务1: 查询A、B账户金额之和（1000+1000、500+1500、1000+1000）
事务2: A转账给B 500元A - 500 = 500B + 500 = 1500

(4)持久性（Durability）：一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

开启事务---A给B转账500元
A: 1000 - 500 = 500    (成功了)   在日志中记录,事务成功,A账户金额更新为500
B: 1000 + 500 = 1500 (成功了)    在日志中记录,事务成功,B账户金额更新为1500
结束事务---回滚/提交

MySQL中的事务

在默认情况下，MySQL每执行一条SQL语句，都是一个单独的事务。因为底层在执行SQL语句之前会自动开启事务，在SQL语句执行完后，会立即结束事务！

如果需要在一个事务中包含多条SQL语句，那么需要手动开启事务和结束事务。

开启事务：start transaction；
结束事务：commit（提交事务）或 rollback（回滚事务）。

在执行SQL语句之前，先执行 strat transaction，这就开启了一个事务（事务的起点），然后可以去执行多条SQL语句，最后要结束事务，commit表示提交，即事务中的多条SQL语句所做出的影响会持久化到数据库中。或者rollback，表示回滚，即回滚到事务的起点，之前做的所有操作都被撤消了！

下面演示A账户给B账户转账的例子：

准备数据：

-- 1、创建数据库jt_db数据库(如果不存在才创建)
create database if not exists jt_db charset utf8;
use jt_db; -- 选择jt_db数据库
-- 2、在 jt_db 库中创建 acc 表(银行账户表),要求有id(主键),name(姓名),money(账户金额)
drop table if exists acc;
create table acc(id int primary key auto_increment,name varchar(50),money double
);
-- 3、往 acc 表中, 插入2条记录
insert into acc values(null,'A',1000);
insert into acc values(null,'B',1000);
-- 查询acc表中的所有记录
select * from acc;

下面分别演示事务开启及执行一系列SQL之后，回滚事务、提交事务及中断操作的效果。

– rollback（回滚事务）

-- 查询acc账户表中A和B的金额
select * from acc;
-- 开启事务
start transaction;
-- 开始转账，A账户减去100元
update acc set money=money-100 where name='A';
-- 查询acc账户表中A和B的金额
select * from acc;
-- B账户增加100元
update acc set money=money+100 where name='B';
-- 查询acc账户表中A和B的金额
select * from acc;
-- 回滚事务
rollback;
-- 再次查询acc账户表中A和B的金额
select * from acc;

– commit（提交事务）：将上面的操作再做一次，最后将rollback替换为commit，即提交事务

commit;

– 中断操作：将上面的操作再做一次，最后将rollback替换为quit，即中断操作

quit;

事务并发读问题

多个事务对相同的数据同时进行操作，这叫做事务并发。

在事务并发时，如果没有采取必要的隔离措施，可能会导致各种并发问题，破坏数据的完整性等。这些问题中，其中有三类是读问题，分别是：脏读、不可重复读、幻读。

(1)脏读（dirty read）：在一个事务中，读取到另一个事务未提交更新的数据，即读取到了脏数据；

例如：在一个事务中，A给B转账100元但未提交事务，在另一事务中查询账户金额，查询到了A未提交更新的数据，我们称之为脏读。

提示：需要将数据库的事务隔离级别设置为最低，才能够看到脏读现象
事务1：开启事务; A - 100 = 900; B + 100 = 1100; (没有提交事务)
事务2：开启事务; 查询B账户的金额 1100, 这个过程叫做脏读, 1100就是一个脏数据

(2)不可重复读（unrepeatable read）：对同一记录的两次读取结果不一致，因为在两次查询期间，有另一事务对该记录做了修改（是针对修改操作）

例如：在事务1中，前后两次查询A账户的金额，在两次查询之间，另一事物2对A账户的金额做了修改（并且也提交了事务），此种情况可能会导致事务1中，前后两次查询的结果不一致。这就是不可重复读。

事务1：开启事务---第一次读取A账户的金额：1000第二次读取A账户的金额：900
事务2：开启事务---A账户 - 100 = 900;提交事务---

(3)幻读（虚读）（phantom read）：对同一张表的两次查询结果不一致，因为在两次查询期间，有另一事务进行了插入或者是删除操作(是针对插入或删除操作)；

事务1：开启事务---select * from acc where id=3;//不存在id为3的记录insert into acc value(3,'C',2000);select * from acc where id=3;//存在id为3的记录
事务2：开启事务---insert into acc value(3,'C',2000);提交事务---

注意:mysql默认的是不允许出现脏读和不可重复读，所以在下面演示之前需要设置mysql允许出现脏读、不可重复读等。

set tx_isolation='read-uncommitted'; -- 设置mysql的事务隔离级别

1、脏读示例：

-- 在窗口1中，开启事务，执行A给B转账100元
set tx_isolation='read-uncommitted'; -- 允许脏读、不可重复读、幻读
use jt_db; -- 选择jt_db库
start transaction; -- 开启事务
update acc set money=money-100 where name='A';
update acc set money=money+100 where name='B';
-- 在窗口2中，开启事务，查询B的账户金额
set tx_isolation='read-uncommitted'; -- 允许脏读、不可重复读、幻读
use jt_db; -- 选择jt_db库
start transaction; -- 开启事务
select * from acc where name='B'; -- 出现脏数据
-- 切换到窗口1，回滚事务，撤销转账操作。
rollback; -- 回滚事务
-- 切换到窗口2，查询B的账户金额
select * from acc where name='B';

在窗口2中，B看到自己的账户增加了100元（此时的数据A操作事务并未提交），此种情况称之为"脏读"。

2、不可重复读示例：

-- 在窗口1中，开启事务，查询A账户的金额
set tx_isolation='read-uncommitted'; -- 允许脏读、不可重复读、幻读
use jt_db; -- 选择jt_db库
start transaction; -- 开启事务
select * from acc where name='A';
-- 在窗口2中，开启事务，查询A的账户金额减100
set tx_isolation='read-uncommitted'; -- 允许脏读、不可重复读、幻读
use jt_db; -- 选择jt_db库
start transaction; -- 开启事务
update acc set money=money-100 where name='A'; -- A账户减去100
select * from acc where name='A';
commit; -- 提交事务
-- 切换到窗口1，再次查询A账户的金额。
select * from acc where name='A'; -- 前后查询结果不一致

在窗口1中，前后两次对同一数据(账户A的金额)查询结果不一致，是因为在两次查询之间，另一事务对A账户的金额做了修改。此种情况就是"不可以重复读"

3、幻读示例：

-- 在窗口1中，开启事务，查询账户表中是否存在id=3的账户
set tx_isolation='read-uncommitted'; -- 允许脏读、不可重复读、幻读
use jt_db; -- 选择jt_db库
start transaction; -- 开启事务
select * from acc where id=3;
-- 在窗口2中，开启事务，往账户表中插入了一条id为3记录，并提交事务。
-- 设置mysql允许出现脏读、不可重复度、幻读
set tx_isolation='read-uncommitted';
use jt_db; -- 选择jt_db库
start transaction; -- 开启事务
insert into acc values(3, 'C', 1000);
commit; -- 提交事务
-- 切换到窗口1，由于上面窗口1中查询到没有id为3的记录，所以可以插入id为3的记录。
insert into acc values(3, 'C', 1000); -- 插入会失败!

在窗口1中，查询了不存在id为3的记录，所以接下来要执行插入id为3的记录，但是还未执行插入时，另一事务中插入了id为3的记录并提交了事务，所以接下来窗口1中执行插入操作会失败。

探究原因，发现账户表中又有了id为3的记录（感觉像是出现了幻觉）。这种情况称之为"幻读"

以上就是在事务并发时常见的三种并发读问题，那么如何防止这些问题的产生？

可以通过设置事务隔离级别进行预防。

事务隔离级别

事务隔离级别分四个等级，在相同数据环境下，对数据执行相同的操作，设置不同的隔离级别，可能导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力也是不同的。

set tx_isolation='read-uncommitted';

1、READ UNCOMMITTED（读未提交数据）

安全性最差，可能出现任何事务并发问题(比如脏读、不可以重复读、幻读等)

但性能最好（不使用!!）

2、READ COMMITTED（读已提交数据）（Oracle默认）

安全性较差

性能较好

可以防止脏读，但不能防止不可重复读，也不能防止幻读；

3、REPEATABLE READ（可重复读）（MySQL默认）

安全性较高

性能较差

可以防止脏读和不可重复读，但不能防止幻读问题；

4、SERIALIZABLE（串行化）

安全性最高，不会出现任何并发问题，因为它对同一数据的访问是串行的，非并发访问；

性能最差；(不使用!!)

MySQL的默认隔离级别为REPEATABLE READ，即可以防止脏读和不可重复读

设置隔离级别(了解)

0、MySQL查询当前的事务隔离级别

select @@tx_isolation;

1、MySQL设置事务隔离级别（了解）

(1) set tx_isolation=‘read-uncommitted’;

安全性最差，容易出现脏读、不可重复读、幻读，但性能最高

(2) set tx_isolation=‘read-committed’;

安全性一般，可防止脏读，不能防止不可重复读、幻读

(3) set tx_isolation=‘repeatable-read’;

安全性较好，可防止脏读、不可重复读，但不能防止幻读

(4) set tx_isolation=‘serialiable’;

安全性最好，可以防止一切事务并发问题，但是性能最差。

2、JDBC设置事务隔离界别

JDBC中通过Connection提供的方法设置事务隔离级别：

Connection.setTransactionIsolation(int level)

参数可选值如下：

Connection.TRANSACTION_READ_UNCOMMITTED 1（读未提交数据）
Connection.TRANSACTION_READ_COMMITTED 2（读已提交数据）
Connection.TRANSACTION_REPEATABLE_READ 4（可重复读）
Connection.TRANSACTION_SERIALIZABLE 8（串行化）
Connection.TRANSACTION_NONE 0（不使用事务）

提示：在开发中，一般情况下不需要修改事务隔离级别

3、JDBC中实现转账例子

提示：JDBC中默认是自动提交事务，所以需要关闭自动提交，改为手动提交事务

也就是说, 关闭了自动提交后, 事务就自动开启, 但是执行完后需要手动提交或者回滚!!

(1)执行下面的程序，程序执行没有异常，转账成功！A账户减去100元，B账户增加100元。

(2)将第4步、5步中间的代码放开，再次执行程序，在转账过程中抛异常，转账失败！由于事务回滚，所以A和B账户金额不变。

public static void main(String[] args) throws SQLException {Connection conn = null;Statement stat = null;ResultSet rs = null;try {//1.获取连接conn = JdbcUtil.getConn();//2.关闭JDBC自动提交事务（默认开启事务）conn.setAutoCommit(false);//3.获取传输器stat = conn.createStatement();/* ***** A给B转账100元 ***** *///4.A账户减去100元String sql = "update acc set money=money-100 where name='A'";stat.executeUpdate(sql);//int i = 1/0; // 让程序抛出异常，中断转账操作//5.B账户加上100元sql = "update acc set money=money+100 where name='B'";stat.executeUpdate(sql);//6.手动提交事务conn.commit();System.out.println("转账成功！提交事务...");} catch (Exception e) {e.printStackTrace();//一旦其中一个操作出错都将回滚，使两个操作都不成功conn.rollback();System.out.println("执行失败！回滚事务...");} finally{JdbcUtil.close(conn, stat, rs);}
}


**1、MySQL设置事务隔离级别（了解）**(1) set tx_isolation='read-uncommitted';　安全性最差，容易出现**脏读**、**不可重复读**、**幻读**，但性能最高(2) set tx_isolation='read-committed';安全性一般，可防止**脏读**，不能防止**不可重复读**、**幻读**(3) set tx_isolation='repeatable-read';安全性较好，可防止**脏读**、**不可重复读**，但不能防止**幻读**(4) set tx_isolation='serialiable';安全性最好，可以防止一切事务并发问题，但是性能最差。**2、JDBC设置事务隔离界别**JDBC中通过Connection提供的方法设置事务隔离级别：```sql
Connection.setTransactionIsolation(int level)

参数可选值如下：

Connection.TRANSACTION_READ_UNCOMMITTED 1（读未提交数据）
Connection.TRANSACTION_READ_COMMITTED 2（读已提交数据）
Connection.TRANSACTION_REPEATABLE_READ 4（可重复读）
Connection.TRANSACTION_SERIALIZABLE 8（串行化）
Connection.TRANSACTION_NONE 0（不使用事务）

提示：在开发中，一般情况下不需要修改事务隔离级别

3、JDBC中实现转账例子

提示：JDBC中默认是自动提交事务，所以需要关闭自动提交，改为手动提交事务

也就是说, 关闭了自动提交后, 事务就自动开启, 但是执行完后需要手动提交或者回滚!!

(1)执行下面的程序，程序执行没有异常，转账成功！A账户减去100元，B账户增加100元。

(2)将第4步、5步中间的代码放开，再次执行程序，在转账过程中抛异常，转账失败！由于事务回滚，所以A和B账户金额不变。

public static void main(String[] args) throws SQLException {Connection conn = null;Statement stat = null;ResultSet rs = null;try {//1.获取连接conn = JdbcUtil.getConn();//2.关闭JDBC自动提交事务（默认开启事务）conn.setAutoCommit(false);//3.获取传输器stat = conn.createStatement();/* ***** A给B转账100元 ***** *///4.A账户减去100元String sql = "update acc set money=money-100 where name='A'";stat.executeUpdate(sql);//int i = 1/0; // 让程序抛出异常，中断转账操作//5.B账户加上100元sql = "update acc set money=money+100 where name='B'";stat.executeUpdate(sql);//6.手动提交事务conn.commit();System.out.println("转账成功！提交事务...");} catch (Exception e) {e.printStackTrace();//一旦其中一个操作出错都将回滚，使两个操作都不成功conn.rollback();System.out.println("执行失败！回滚事务...");} finally{JdbcUtil.close(conn, stat, rs);}
}

JAVAWEB NOTE 3相关推荐

JAVAWEB NOTE 2
unit05-Servlet Servlet概述什么是Servlet? Servlet是由SUN公司提供的一门动态Web资源开发技术静态Web资源:不同的人,在不同的条件下访问后看到的是相同的效果 ...
JAVAWEB NOTE 1
unit01-HTML.CSS HTML: 用于开发网页的一门技术 CSS: 用于修饰.渲染网页的一门技术 HTML+CSS可以开发一个非常美观.非常漂亮的网页开发网页盖房子 HTML标签搭建网页 ...
Failed to load ‘D:\note\笔记\javaweb\webpack\webpack.config.js‘ config
配置插件html-webpack-plugin出现的问题,原因在于 plugins里面htmlplugin少打了一个n. 另外一种情况就是这种情况 const path = require('path ...
javaweb学习总结(十)——HttpServletRequest对象(一)
2019独角兽企业重金招聘Python工程师标准>>> 一.HttpServletRequest介绍 HttpServletRequest对象代表客户端的请求,当客户端通过HTTP协 ...
javaweb学习总结(十)：HttpServletRequest对象(一)
一.HttpServletRequest介绍 HttpServletRequest对象代表客户端的请求,当客户端通过HTTP协议访问服务器时,HTTP请求头中的所有信息都封装在这个对象中,通过这个对象 ...
javaweb学习总结(十)——HttpServletRequest对象(一)（转）
(每天都会更新至少一篇以上,有兴趣的可以关注)转载自孤傲苍狼一.HttpServletRequest介绍 HttpServletRequest对象代表客户端的请求,当客户端通过HTTP协议访问服务器 ...
Servlet之javaweb应用(二)
一. 使用 JavaEE 版的 Eclipse 开发动态的 WEB 工程(JavaWEB 项目) 1). 把开发选项切换到 JavaEE 2). 可以在 Window -> Show View ...
重学JavaWeb —— JSP，简单全面一发入魂
文章目录 JSP 特点由来本质使用 JSP指令 page include taglib JSP脚本 JSP内置对象 JSP作用域 EL表达式 EL内置对象 EL取值方式 JSP动作元素 JSTL ...
JavaWeb之HTML标签
JavaWeb之HTML标签常用标签 <a href="#">a 超级链接(anchor)</a><abbr title="abbrevi ...
JavaWeb+MySql+Tomcat一键部署方案
前言前段时间,公司接单子做一套JavaWeb系统.作为主要负责人,我们小组的工作一切顺利.但在交付前,客户要求该Web系统做到一键安装部署.这是因为该系统使用环境为机房局域网,每个机房需要部署一套, ...

JAVAWEB NOTE 3

unit08-JSP、EL、JSTL

JSP概述

什么是JSP

JSP执行过程

修改JSP默认编码

JSP语法

模版元素

JSP表达式

JSP脚本片段

JSP注释

JSP指令

JSP标签技术

EL表达式

JSTL标签库

JSP作业

unit09-Maven

Maven介绍

Maven是什么?

为什么要使用Maven?

Maven安装

下载、安装Maven

Maven的相关配置

配置本地仓库位置

配置远程仓库(私服)

配置JDK版本

将Maven配置到Eclipse中

Maven的项目构建

创建简单工程—Java工程

创建简单工程—Web工程

Maven的目录结构

导入已有的Maven项目

Maven的依赖管理

依赖(jar包)管理

Maven三种仓库

添加依赖:方式一

添加依赖:方式二

扩展:Maven常见问题

拷贝Maven仓库

常见环境问题

找不到jar包问题

Maven的依赖范围

maven作业

unit10-Cookie、Session

什么是会话

cookie原理及应用

cookie的工作原理

cookie的API及应用

案例:使用cookie模拟购物车

session原理及应用

session的工作原理

session是一个域对象

案例:使用session模拟购物车

总结:两者的区别

扩展内容

cookie中保存中文数据的问题

获取不到之前的session的问题

unit11-MySQL数据库事务

事务及四大特性

什么是事务

事务的四大特性

MySQL中的事务

事务并发读问题

事务并发读问题

事务隔离级别

设置隔离级别(了解)

JAVAWEB NOTE 3相关推荐

最新文章

热门文章