JavaWEB整理

JavaWEB学习笔记

回顾整个JavaWEB学习过程

---

一、环境搭建

1. HTTP协议简介

超文本传输协议（英文：HyperText Transfer Protocol，缩写：HTTP）是一种用于分布式、协作式和超媒体信息 系统的应用层协议。HTTP是万维网的数据通信的基础。 
HTTP的发展是由蒂姆·伯纳斯-李于1989年在欧洲核子研究组织（CERN）所发起。HTTP的标准制定由万维网协会（World Wide Web Consortium，W3C）和互联网工程任务组（Internet Engineering Task Force，IETF）进行协调，最终发布了一系列的RFC，其中最著名的是1999年6月公布的RFC 2616，定义了HTTP协议中现今广泛使用的一个版本——HTTP 1.1。

2. HTTP 请求/响应的步骤

2.1 客户端连接到Web服务器

一个HTTP客户端，通常是浏览器，与Web服务器的HTTP端口（默认为80）建立一个TCP套接字连接。 例如:http://www.baidu.com。

2.2 发送HTTP请求

通过TCP套接字，客户端向Web服务器发送一个文本的请求报文，一个请求报文由请求行、请求头部、空行和请求数据4部分组成。

2.3 服务器接受请求并返回HTTP响应

Web服务器解析请求，定位请求资源。服务器将资源复本写到TCP套接字，由客户端读取。一个响应由状态行、响 应头部、空行和响应数据4部分组成。

2.4 释放TCP连接

在HTTP/1.0中默认使用短连接。也就是说，客户端和服务器每进行一次HTTP操作，就建立一次连接，任务结束就 中断连接。
当客户端浏览器访问的某个HTML或其他类型的Web页中包含有其他的Web资源（如JavaScript文件、 图像文件、CSS文件等），每遇到这样一个Web资源，浏览器就会重新建立一个HTTP会话。
而从HTTP/1.1起，默认使用长连接，用以保持连接特性。使用长连接的HTTP协议，会在响应头加入这行代码：
Connection:keep-alive

在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的TCP连接不会关闭，客户端再次访问这个服务器时，会继续使用这一条已经建立的连接。Keep-Alive不会永久保持连接，它有一个保持时 间，可以在不同的服务器软件（如Apache）中设定这个时间。实现长连接需要客户端和服务端都支持长连接。
 HTTP协议的长连接和短连接，实质上是TCP协议的长连接和短连接。

2.5 客户端浏览器解析HTML内容

客户端浏览器首先解析状态行，查看表明请求是否成功的状态代码。然后解析每一个响应头，响应头告知以下为若干字节的HTML文档和文档的字符集。客户端浏览器读取响应数据HTML，根据HTML的语法对其进行格式化，并在浏览器窗口中显示。 
例如：在浏览器地址栏键入URL，按下回车之后会经历以下流程：
    1. 浏览器向 DNS 服务器请求解析该 URL 中的域名所对应的 IP 地址; 
    2. 解析出 IP 地址后，根据该 IP 地址和默认端口 80，和服务器建立TCP连接; 
    3. 浏览器发出读取文件(URL 中域名后面部分对应的文件)的HTTP 请求，该请求报文作为 TCP 三次握手的第三个 报文的数据发送给服务器; 
    4. 服务器对浏览器请求作出响应，并把对应的 html 文本发送给浏览器; 
    5. 浏览器将该 html 文本并显示内容;

3. HTTP请求方法

HTTP/1.1协议中共定义了八种方法（也叫“动作”）来以不同方式操作指定的资源：

GET

向指定的资源发出“显示”请求。使用GET方法应该只用在读取数据，而不应当被用于产生“副作用”的操作中，例如在 Web Application中。其中一个原因是GET可能会被网络蜘蛛等随意访问。 

HEAD

与GET方法一样，都是向服务器发出指定资源的请求。只不过服务器将不传回资源的本文部分。它的好处在于，使用这个方法可以在不必传输全部内容的情况下，就可以获取其中“关于该资源的信息”（元信息或称元数据）。

POST

向指定资源提交数据，请求服务器进行处理（例如提交表单或者上传文件）。数据被包含在请求本文中。这个请求可能会创建新的资源或修改现有资源，或二者皆有。

PUT

向指定资源位置上传其最新内容。 

DELETE

请求服务器删除Request-URI所标识的资源。 

TRACE

回显服务器收到的请求，主要用于测试或诊断。

OPTIONS

这个方法可使服务器传回该资源所支持的所有HTTP请求方法。用'*'来代替资源名称，向Web服务器发送OPTIONS 请求，可以测试服务器功能是否正常运作。

CONNECT

4. 两种开发模型

C/S又称Client/Server或客户/服务器模式。
服务器通常采用高性能的PC、工作站或小型机，客户端需要安装专用的客户端软件。如QQ,微信等软件
B/S是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser）。Browser/Server是建立在广域网的基础上的.
CS和BS结构各自的优、缺点

C/S的优点是能充分发挥客户端PC的处理能力，很多工作可以在客户端处理后再提交给服务器。对应的优点就是 客户端响应速度快。 

缺点主要有以下几个

1) 客户端需要安装专用的客户端软件。首先涉及到安装的工作量，其次任何一台电脑出问题，如病毒、硬件损坏， 都需要进行安装或维护。特别是有很多分部或专卖店的情况，不是工作量的问题，而是路程的问题。还有，系统软 件升级时，每一台客户机需要重新安装，其维护和升级成本非常高。
2) B/S最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件。只要有一台能上网的电脑就能使用， 客户端零维护。系统的扩展非常容易，只要能上网，就可以使用了。甚至可以在线申请，通过公司内部的安全认证 （如CA证书）后，不需要人的参与，系统可以自动分配给用户一个账号进入系统。

5. Web服务器的分类

Web服务器是运行及发布Web应用的容器，只有将开发的Web项目放置到该容器中，才能使网络中的所有用户通过 浏览器进行访问。开发Java Web应用所采用的服务器主要是与JSP/Servlet兼容的Web服务器，比较常用的有 Tomcat、Resin、JBoss、WebSphere 和 WebLogic 等 

Tomcat 服务器

目前最为流行的Tomcat服务器是Apache-Jarkarta开源项目中的一个子项目，是一个小型、轻量级的支持JSP和 Servlet 技术的Web服务器，也是初学者学习开发JSP应用的首选 

Resin 服务器

Resin是Caucho公司的产品，是一个非常流行的支持Servlet和JSP的服务器，速度非常快。Resin本身包含了一 个支持HTML的Web服务器，这使它不仅可以显示动态内容，而且显示静态内容的能力也毫不逊色，因此许多网站 都是使用Resin服务器构建 

JBoss服务器

JBoss是一个种遵从JavaEE规范的、开放源代码的、纯Java的EJB服务器，对于J2EE有很好的支持。JBoss采用 JML API实现软件模块的集成与管理，其核心服务又是提供EJB服务器，不包含Servlet和JSP的Web容器，不过它可以和Tomcat完美结合 

WebSphere 服务器

WebSphere是IBM公司的产品，可进一步细分为 WebSphere Performance Pack、Cache Manager 和 WebSphere Application Server等系列，其中WebSphere Application Server 是基于Java 的应用环境，可以运行于 Sun Solaris、Windows NT 等多种操作系统平台，用于建立、部署和管理Internet和Intranet Web应用程序。 

WebLogic 服务器

WebLogic 是BEA公司的产品（现在已经被Oracle收购），可进一步细分为 WebLogic Server、WebLogic Enterprise 和 WebLogic Portal 等系列，其中 WebLogic Server 的功能特别强大。WebLogic 支持企业级的、多层 次的和完全分布式的Web应用，并且服务器的配置简单、界面友好。对于那些正在寻求能够提供Java平台所拥有的 一切应用服务器的用户来说，WebLogic是一个十分理想的选择

6. Tomcat

6.1 Tomcat下载与安装

开源小型web服务器 ，完全免费，主要用于中小型web项目，只支持Servlet和JSP 等少量javaee规范（就是 JavaWeb编程接口）

https://tomcat.apache.org/

下载好之后，安装到任意目录
安装步骤:

1. 下载Tomcat
2. 解压到一个没有特殊符号的目录中（一般纯英文即可）
3. 进入到解压的目录下找到bin\startup.bat双击启动即可

注意:不建议将服务器软件放在磁盘层次很多的文件夹中!

不建议放在中文路径下!

tomcat安装需要配置JAVA_HOME环境变量

6.2 Tomcat的目录

1、bin：该目录下存放的是二进制可执行文件，如果是安装版，那么这个目录下会有两个exe文件： tomcat9.exe、tomcat9w.exe，前者是在控制台下启动Tomcat，后者是弹出UGI窗口启动Tomcat；如果是解压 版，那么会有startup.bat和shutdown.bat文件，startup.bat用来启动Tomcat，但需要JDK的配置，shutdown.bat 用来停止Tomcat；
2、conf：这是一个非常非常重要的目录，这个目录下有四个最为重要的文件： server.xml：配置整个服务器信息。例如修改端口号，添加虚拟主机等； tomcat-users.xml：存储tomcat用户的文件，这里保存的是tomcat的用户名及密码，以及用户的角色信息。可以 按着该文件中的注释信息添加tomcat用户，然后就可以在Tomcat主页中进入Tomcat Manager页面了； web.xml：部署描述符文件，这个文件中注册了很多MIME类型，即文档类型。这些MIME类型是客户端与服务器之 间说明文档类型的，如用户请求一个html网页，那么服务器还会告诉客户端浏览器响应的文档是text/html类型 的，这就是一个MIME类型。客户端浏览器通过这个MIME类型就知道如何处理它了。当然是在浏览器中显示这个 html文件了。但如果服务器响应的是一个exe文件，那么浏览器就不可能显示它，而是应该弹出下载窗口才对。 MIME就是用来说明文档的内容是什么类型的！ context.xml：对所有应用的统一配置，通常我们不会去配置它。
3、lib：Tomcat的类库，里面是一大堆jar文件。如果需要添加Tomcat依赖的jar文件，可以把它放到这个目录中， 当然也可以把应用依赖的jar文件放到这个目录中，这个目录中的jar所有项目都可以共享之，但这样你的应用放到 其他Tomcat下时就不能再共享这个目录下的Jar包了，所以建议只把Tomcat需要的Jar包放到这个目录下；
4、logs：这个目录中都是日志文件，记录了Tomcat启动和关闭的信息，如果启动Tomcat时有错误，那么异常也会 记录在日志文件中。
5、temp：存放Tomcat的临时文件，这个目录下的东西可以在停止Tomcat后删除！
6、webapps：存放web项目的目录，其中每个文件夹都是一个项目；如果这个目录下已经存在了目录，那么都是 tomcat自带的项目。其中ROOT是一个特殊的项目，在地址栏中没有给出项目目录时，对应的就是ROOT项目。 http://localhost:8080/examples，进入示例项目。其中examples就是项目名，即文件夹的名字。
7、work：运行时生成的文件，最终运行的文件都在这里。通过webapps中的项目生成的！可以把这个目录下的内 容删除，再次运行时会生再次生成work目录。当客户端用户访问一个JSP文件时，Tomcat会通过JSP生成Java文 件，然后再编译Java文件生成class文件，生成的java和class文件都会存放到这个目录下。
8、LICENSE：许可证。
9、NOTICE：说明文件。

通过url访问服务器: 
   url:http://服务器的ip地址:端口号/项目名/被访问的页面 
   示例:http://localhost:8080/test0918
    注: (1)启动tomcat后,tomcat会加载部署在服务器端的所有项目 (2) 浏览器访问的页面是服务器端的页面,基本上服务器的项目和工作空间的项目要保持一致

6.3 IntelliJ IDEA配置Tomcat

6.3.1 点击Run—EDit Configurations

6.3.2 点击左侧“+”号，找到Tomcat Server—Local（若是没有找到Tomcat Server 可以点击最后一行 34 items more）

6.3.3 在Tomcat Server -> local-> Server -> Application server项目下，点击 Configuration ，找到本地 Tomcat 服务 器，再点击 OK按钮。

至此，IntelliJ IDEA配置Tomcat完成。

7. 创建JavaWeb项目

7.1 点击左上角的File–>New–>Project

7.2 找到Java Enterprise之后，在Application Sever中找到自己的Tomcat，同时勾选中Web Application

7.3 第一项是你的工程名字，第二个是你的工程路径，选择好之后点击finish

7.4 创建classes和lib文件夹，名字不可改

7.5 配置jar包和classes包：

7.5.1 在File中找到Project Structure

7.5.2 点击Modules ,选择Paths,选中Use module compile output path ,把路径改成刚刚创建的classes文件夹

7.5.3 ok后再点旁边的Dependencies,点击"+"号，选择1 JARs or directories

7.5.4 选择你刚刚创建的lib文件夹，OK

7.5.5 选中jar Directory

7.6 部署项目:将本地项目安装到服务器中

7.6.1 回到主界面后，点击Run ，选择Edit Configurations

7.6.2 看tomcat已经有啦，这是java Enterprise的好处啦，点击Deployment

7.6.3 点击右上角的三角形

7.6.4 运行成功

至此，intellij idea创建并设置javaweb工程全部完成

8. 修改端口号

修改配置文件:/conf/server.xml

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

如果将端口号改成80,则访问项目时的请求路径就可以省略端口号。

9. tomcat如何管理项目

给tomcat增加管理员信息:
配置conf/tomcat-users.xml

<tomcat-users> <role rolename="manager-gui"/> <user username="tomcat" password="tomcat" roles="manager-gui"/> </tomcat-users>

注意:tomcat启动的时候会加载webapps下的所有项目

二、Servlet

1. 什么是Servlet

1. Servlet（Server Applet），全称Java Servlet。是用Java编写的服务器端程序，其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。
2. Servlet运行于支持Java的应用服务器中。从实现上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。
3. Servlet工作模式：
   ① 客户端发送请求至服务器
   ② 服务器启动并调用Servlet，Servlet根据客户端请求生成响应内容并将其传给服务器
   ③ 服务器将响应返回客户端

2. Servlet API

3. 第一个Servlet

3.1 创建一个类实现Servlet接口,重写方法。或继承HttpServlet亦可

public class LoginServlet implements Servlet { 
	@Override 
	public void init(ServletConfig servletConfig) throws ServletException { 
		//初始化方法 
	}

	@Override 
	public ServletConfig getServletConfig() { 
		return null; 
	}
	
	@Override 
	public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { 
		//处理get/post请求的方法 
	}
	
	@Override 
	public String getServletInfo() { 
		return null; 
		}
		
	@Override 
	public void destroy() { 
		//销毁的方法 
	} 
}

3.2 在web.xml文档中配置映射关系

XML中配置好这个Servlet的映射关系：

<servlet> 
	<servlet-name>自定义名称</servlet-name> 
	<servlet-class>处理请求的类的完整路径</servlet-class> 
</servlet> 
<servlet-mapping><!-- mapping 表示映射 --> 
	<servlet-name>自定义名称</servlet-name> 
	<url-pattern>请求名</url-pattern> 
</servlet-mapping>

标签的执行顺序：
请求过来以后->web.xml->servlet-mapping标签中的url-pattern标签中的内容和请求名 进行匹配->匹配成功后找对应的servlet-mapping标签中的servlet-name-> 去servlet标签中找和上一个servlet-name相同的name值->去找servlet标签中的servlet-class中处理类的完整路径

3.3 启动tomcat

在浏览器输入http://localhost:8080/工程名/访问服务器的路径

4. Servlet工作原理

1. Servlet接口定义了Servlet与servlet容器之间的契约。这个契约是：Servlet容器将Servlet类载入内存，并产生Servlet实例和调用它具体的方法。但是要注意的是，在一个应用程序中，每种Servlet类型只能有一个实例。
2. 用户请求致使Servlet容器调用Servlet的Service（）方法，并传入一个ServletRequest对象和一个ServletResponse对象。ServletRequest对象和ServletResponse对象都是由Servlet容器（例如TomCat）封装好的，并不需要程序员去实现，程序员可以直接使用这两个对象。
3. ServletRequest中封装了当前的Http请求，因此，开发人员不必解析和操作原始的Http数据。ServletResponse表示当前用户的Http响应，程序员只需直接操作ServletResponse对象就能把响应轻松的发回给用户。
4. 对于每一个应用程序，Servlet容器还会创建一个ServletContext对象。这个对象中封装了上下文（应用程序的环境详情。每个应用程序只有一个ServletContext。每个Servlet对象也都有一个封装Servlet配置的ServletConfig对象。

5. Servlet的生命周期

当客户端首次发送第一次请求后，由容器(web服务器(tomcat))去解析请求, 根据请求找到对应的servlet,判断该类 的对象是否存在，不存在则创建servlet实例，调取init()方法 进行初始化操作,初始化完成后调取service()方法,由 service()判断客户端的请求方式，如果是get，则执行doGet(),如果是post则执行doPost().处理方法完成后,作出相 应结果给客户端.单次请求处理完毕。
当用户发送第二次以后的请求时,会判断对象是否存在,但是不再执行init()，而直接执行service方法,调取 doGet()/doPost()方法。
当服务器关闭时调取destroy()方法进行销毁。

四个过程:
	(1)实例化 --先创建servlet实例
	(2)初始化 --init() 
	(3)处理请求 ---service()
	(4)服务终止 --destory()

6. 请求

HttpServletRequest表示Http环境中的Servlet请求。它扩展于javax.servlet.ServletRequest接口)

常用方法: 
	1)String getParameter(String name) 根据表单组件名称获取提交数据，返回值是String 注：服务器在接收数据时使用字符串统一接收 
	2)String[ ] getParameterValues(String name) 获取表单组件对应多个值时的请求数据 
	3)void setCharacterEncoding(String charset) 指定每个请求的编码(针对post请求才起作用) 
	4)RequestDispatcher getRequestDispatcher(String path) --跳转页面 返回一个
		RequestDispatcher对象，该对象的forward( )方法用于转发请求 
		示例:
		request.getRequestDispatcher("../success.jsp").forward(request,response);
	5)存值 request.setAttribute("key",value); 
	6)取值 request.getAttribute("key");//取值后需要向下转型 
		示例: String a1=(String)request.getAttribute("uname");

7. 响应

在Service API中，定义了一个HttpServletResponse接口，它继承自ServletResponse接口，专门用来封装HTTP响 应消息。 在HttpServletResponse接口中定义了向客户端发送响应状态码，响应消息头，响应消息体的方法。

常用方法: 
void addCookie(Cookie var1);//给这个响应添加一个cookie 
void sendRedirect(String var1) ;//发送一条响应码，将浏览器跳转到指定的位置 
PrintWriter getWriter() 获得字符流，通过字符流的write(String s)方法可以将字符串设置到response 缓冲区中， 随后Tomcat会将response缓冲区中的内容组装成Http响应返回给浏览器端。 

setContentType() 设置响应内容的类型

重定向和转发的对比

重定向:response.sendRedirect()
转发:request.getRequestDispatcher("../success.jsp").forward(request,response); 
相同点:都用来跳转页面 
不同点: 
	a.重定向时地址栏会改变,request中存储的数据会丢失.转发时地址栏显示的是请求页面的地址,request数据可以保 存。
	b.转发属于一次请求一次响应,重定向属于两次请求(地址栏修改了两次)两次响应。 
补充:使用out对象往页面中输出js或html,css

out.print("<script type='text/javascript'>alert('登录失败');location='../login.jsp'</script>");

注:使用js跳转页面，也会丢失request中的数据

8. 会话

request存的值只能在单次请求中保存，保存的数据不能跨页面,当重定向时,request存的值会丢失 
session的数据可以在多个页面中共享,即使重定向页面,数据不会丢失
session中可以包含n个request。 
会话的概念:从打开浏览器到关闭浏览器,期间访问服务器就称为一次会话 
常用方法: 
	void setAttribute(String key,Object value) 以key/value的形式保存对象值,将数据存储在服务器端 
	Object getAttribute(String key) 通过key获取对象值 
	void invalidate() 设置session对象失效 
	String getId() 获取sessionid,当第一次登录成功后，session会产生一个唯一的id，浏览器之后访问时如果发现id值 还是之前id，那么说明 当前访问的属于同一个会话 
	void setMaxInactiveInterval(int interval) 设定session的非活动时间 

示例:
方式1: session.setMaxInactiveInterval(10*60);//设置有效时间为10分钟
方式2:修改web.xml

<session-config> 
	<session-timeout>10</session-timeout>//单位:分钟 
</session-config>

int getMaxInactiveInterval() 获取session的有效非活动时间(以秒为单位)，默认的有效时间:30分钟
void removeAttribute(String key) 从session中删除指定名称(key)所对应的对象

小结 :

让session失效的方式 
	（1）invalidate() 
	（2）removeAttribute("key") 
	（3）直接关闭浏览器。
	
 示例:使用session验证用户是否登录 
 补充: 自动刷新到某页面: 
 注:在head标签中添加该标签，单位:秒

9.获得初始化参数

request.setCharacterEncoding(“utf-8”);代码的耦合度太高，不便于后期维护修改。可以通过初始化参数实现实现方式:
（1）web.xml中先定义初始化参数

<servlet> 
	<servlet-name></servlet-name> 
	<servlet-class></servlet-class> 
	<init-param> 
		<param-name>encoding</param-name> 
		<param-value>utf-8</param-value> 
	</init-param> 
</servlet>

（2）servlet中获得初始化参数，重写init()方法

public void init(ServletConfig config) throws ServletException { 
		encoding= config.getInitParameter("encoding"); 
}

注意:这种方式的初始化参数仅限于当前servlet中使用。

2.全局初始化参数
(1) 定义，context-param是和servlet标签同级别

<context-param> 
	<param-name>bianma</param-name> 
	<param-value>utf-8</param-value> 
</context-param>

(2) 获得数据

@Override // 请求->init()->service()->doget/dopost->destory();
public void init(ServletConfig config) throws ServletException {
 	bianhao=config.getServletContext().getInitParameter("bianma"); 
}

10.servlet3.0

注解(提供给程序读取的信息) – 注释(提供给程序员看的信息)
注解的格式：@开头的 如:@Override
@WebServlet注解配置Servlet
从Servlet3.0开始，配置Servlet支持注解方式，但还是保留了配置web.xml方式，所有使用Servlet有两种方式：
（1）Servlet类上使用@WebServlet注解进行配置
（2）web.xml文件中配置 @WebServlet常用属性

<servlet> 
	<servlet-name>a</servlet-name> 
	<servlet-class> 
		<!-- 处理类的完整路径 --> 
		com.yhp.web.SelectServlet 
	</servlet-class> 
	<load-on-startup>1</load-on-startup> 
</servlet>

三、JSP

1.什么是JSP

JSP全名为Java Server Pages，中文名叫java服务器页面，其根本是一个简化的Servlet设计，它是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。
JSP技术有点类似ASP技术，它是在传统的网页HTML文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件，后缀名为(*.jsp)。 
用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。
JSP将网页逻辑与网页设计的显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。
*.html 静态页面(包含固定的页面内容)
*.jsp 动态页面(页面数据可以动态更新,支持嵌套java代码和html代码)

2.JSP中如何嵌套java代码

答案:小脚本(<% java代码%>)

声明标签 <%!变量或者方法声明%>
表达式标签 <%= 表达式%> 在页面上显示的效果
程序代码标签 <%java代码%> 页面上动态展示内容

page指令:
<%@ page language=“java” import=“java.util.*” pageEncoding=“UTF-8”%>

<body>
	<%! int i=10;%><!--成员变量-->
	<%! public void show(){}%> <!--成员方法-->
	<%=i%> <!--输出变量值-->
</body>

如果把一个数据存在request域中，取值操作如下：

3. JSP为什么会出现

jsp中的注释

<!-- html注释内容,查看源码时能看到 -->
<%-- jsp注释,查看页面源码时看不到 --%>

4. JSP的原理

当浏览器访问http://localhost:8080/day9_1/index.jsp。服务器发现后缀为.jsp，它会根据路径找到index.jsp文件，会将index.jsp翻译成index_jsp.java文件，对这个java文件进行编译，产生一个index_jsp.class文件，将class文件加载运行。将JSP翻译成java文件，它是将JSP中的所有的HTML代码通过流进行输出，也就是说最终翻译成class，被虚拟机加载，它本质是servlet，它就会往回响应，响应回去就是把JSP中的HTML代码以流的方式写回浏览器。所以在JSP中展示出了HTML代码

5. JSP的内置对象

JSP中一共预先定义了9个这样的对象，分别为：request、response、session、application、out、pagecontext、config、page、exception

5.1 request对象

request 对象是 javax.servlet.httpServletRequest类型的对象。 
该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数据。（包括头信息、系统信息、请求方式以及请求参数等）。request对象的作用域为一次请求。

5.2 response对象

response 代表的是对客户端的响应，主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域，它只在JSP页面内有效。所属类型:HttpServletResponse

5.3 session对象

session 对象是由服务器自动创建的与用户请求相关的对象。
服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。
session对象内部使用Map类来保存数据，因此保存数据的格式为“Key/value”。 
session对象的value可以使复杂的对象类型，而不仅仅局限于字符串类型。HttpSession

5.4 application对象

application 对象可将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。与session对象相比，application对象生命周期更长，类似于系统的“全局变量” ServletContext
	区别：
		request:单次请求
		session:浏览器访问期间(会话期间)
		application:服务器启动期间,所存的数据可以跨浏览器

5.5 out 对象

out 对象用于在Web浏览器内输出信息，并且管理应用服务器上的输出缓冲区。
在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。
待数据输出完毕后，要及时关闭输出流。

示例:

out.print("<script type='text/javascript'>alert('用户名不存
在');location.href='index.jsp'</script>");

5.6 pageContext 对象

pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。
pageContext对象的创建和初始化都是由容器来完成的，在JSP页面中可以直接使用pageContext对象。

5.7 config 对象

config 对象的主要作用是取得服务器的配置信息。
通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。
当一个Servlet 初始化时，容器把某些信息通过config对象传递给这个 Servlet。
开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。

//将image路径转换成服务器端的路径
String url= config.getServletContext().getRealPath("/image");
<h1>url=<%=url %></h1>

5.8 page 对象

page 对象代表JSP本身，只有在JSP页面内才是合法的。 
page隐含对象本质上包含当前 Servlet接口引用的变量，类似于Java编程中的 this 指针。

5.9 exception 对象

exception 对象的作用是显示异常信息，只有在包含 isErrorPage="true" 的页面中才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。
excepation对象和Java的所有对象一样，都具有系统提供的继承结构。
exception 对象几乎定义了所有异常情况。
在Java程序中，可以使用try/catch关键字来处理异常情况； 
如果在JSP页面中出现没有捕获到的异常，就会生成 exception 对象，并把 exception 对象传送到在page指令中设定的错误页面中，然后在错误页面中处理相应的 exception 对象。

5.9.1 先在可能发生错误的页面中添加errorPage属性:

<%@ page pageEncoding="utf-8" errorPage="error.jsp" contentType="text/html;charset=UTF-8" language="java" %>

5.9.2 在error.jsp页面中设置isErrorPage=“true” 的属性

(使用exception对象之前，需要先将当前页面设置成错误页面

<%@ page language="java" isErrorPage="true" import="java.util.*" pageEncoding="UTF-8"%>

jsp的作用域:
pageContext -> request -> session -> application
当前页面 单次请求有效 当前会话期间 服务器运行期间有效

6. JSP的指令

JSP指令用来设置整个JSP页面相关的属性，如网页的编码方式和脚本语言。

语法格式如下：

<%@ directive attribute="value" %>
directive：指令名称 attribute 属性名 value:属性值

6.1 Page指令

Page指令为容器提供当前页面的使用说明一个JSP页面可以包含多个page指令
Page指令的语法格式：
<%@ page attribute="value" %>

6.2 Include指令

JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。
Include指令的语法格式如下:

<%@ include file="文件相对 url 地址" %>

include 指令中的文件名实际上是一个相对的 URL 地址。
如果您没有给文件关联一个路径，JSP编译器默认在当前路径下寻找。

6.2 Taglib指令

JSP API允许用户自定义标签，一个自定义标签库就是自定义标签的集合。
Taglib指令引入一个自定义标签集合的定义，包括库路径、自定义标签

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

uri属性确定标签库的位置，prefix属性指定标签库的前缀(可自定义)。

7. JSP出现的状态码

8. EL表达式

8.1 什么Expression Language 表达式语言

最初定义于JSTL1.0部分
在JSP2.0中，EL从JSTL中剥离出来，放置在JSP规范中，称为JSP2.0规范的一部分
在JSP中使用EL表达式，可以简化对象和变量的访问是EL表达式

8.2 EL表达式语法

语法格式：${需要展示信息的名字}
注意：
当表达式没有指定变量或者对象的范围时，
那么容器会依次从pageContext—>request—>session—>application中查找该变量或对象,我们可以通过隐含对象获得指定作用域的值:
pageScope对象，用于获取当前页面的属性值
requestScope对象，用于获取请求范围的属性值
sessionScope对象，用于获取会话范围的属性值
applicationScope对象，用于获取程序范围的属性值
语法:
${requestScope.key}

8.3 EL中基础操作符

示例:

单个变量：${a+10}<br>
单个变量：${s}<br>
单个对象：${key.属性名}
	//对象类型
		Users u=new Users();
		u.setName("王老五");
		u.setPass("abc");
		pageContext.setAttribute("u1",u);
		user.name=${u1.name}
		user.pass=${u1.pass}
	// list集合对象:
		List list=new ArrayList();
		list.add("刘能");
		list.add(30);
		list.add(u);
		pageContext.setAttribute("list2",list);
		list1=${list2[0]}<br/>
		list2=${list2[1]}<br/>
		list3=${list2[2].pass}<br/>
	// map集合:
		k1=${map1.k1}<br>
		k2=${map1.k2.username}--- ${map1.k2.password}
	判断变量是否有值或是否存在:${empty key值}
		List list2=new ArrayList();
		list2.add("aa");
		request.setAttribute("list222",list2);
		
判断list中是否有数据:${empty list222}

9. JSTL

9.1 什么是JSTL

JSP标准标签库（JSTL）是一个JSP标签集合，它封装了JSP应用的通用核心功能。
JSTL支持通用的、结构化的任务，比如迭代，条件判断，XML文档操作，国际化标签，SQL标签。 除了这些，它还提供了一个框架来使用集成JSTL的自定义标签。
根据JSTL标签所提供的功能，可以将其分为5个类别。核心标签 格式化标签 sql标签 xml标签 jstl函数（后面详细解释）

9.2 JSTL的作用和语法格式

作用：简化jsp页面编写代码
语法格式：
1. 下载 jakarta-taglibs-standard-1.1.2.zip 包并解压，将 jakarta-taglibs-standard-1.1.2/lib/ 下的两个 jar 文件：standard.jar 和 jstl.jar 文件拷贝到 /WEB-INF/lib/ 下。
2. 在JSP页面中引入<%@ taglib prefix=”页面使用的名称” uri=”功能范围的路径”%>

9.3 核心标签

①核心标签是最常用的 JSTL标签。引用核心标签库的语法如下：

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

② 核心标签的分类

表达式操作 out、set、remove、catch
流程控制 if、choose、when、otherwise
迭代操作 forEach、forTokens
URL操作 import、param、url、redirect

Set标签

＜c:set> 主要用来将变量存储至JSP范围中 或是JavaBean的属性或Map对象中

＜c:out>主要用来显示数据的内容

＜c:remove> 主要负责移除变量

＜c:if> 主要用于进行if判断,如果为true,则输出标签体中的内容

＜c:choose>,＜c:when>,＜c:otherwise> 作用相当于if-else

＜c:forEach> 循环控制，它可以将数组,集合(Collection)中的成员循序浏览一遍。

9.4 格式化标签

9.4.1 fmt:formatDate 作用：将日期类型格式化为指定模式的字符串

属性
value:将要被格式化的数据
pattern：格式化的模式，与SimpleDateFormat的参数设置一样
var:格式化后的字符串所要存放的变量，若不指定var，则会将格式化的结果直接显示在页面
scope：变量存放的域属性空间，默认page
type：其取值为date、time、both，表示给出的value是日期、时间、还是两者都包含，默认是date

9.4.2 fmt:parseDate 作用：用于将指定字符串转化为日期类型

Value服务器获取的时间
Pattern:转换的格式
Var:页面显示的变量

9.4.3 fmt:formatNumber 按照指定格式对数字进行格式化

属性
maxIntegerDigits：整数部分最多的位数
minIntegerDigits：整数部分最少的位数
maxFrctionDigits：小数部分最多的位数
minFrctionDigits：小数部分最少的位数
var：存储格式化结果的变量
scope：var属性的作用域
integerOnly：是否只解析整型数true或者浮点数false

四、Filter和Listener

1. Session和Cookie

1.1 什么是会话跟踪技术

会话跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。保持对用户会话期间的数据管理。常用的会话跟踪技术是Cookie与Session。
Cookie通过在客户端记录信息确定用户身份
Session通过在服务器端记录信息确定用户身份。

1.2 Cookie

1.2.1 什么是cookie

Cookie是客户端(一般指浏览器)请求服务器后,服务器发给客户端的一个辨认标识，保存在客户端，当客户端再次向服务器发送请求时，会携带着这个辨认标识，服务器就可以通过这个标识来识别客户端的身份或状态等。
Cookie的作用：跟踪会话，记录一次会话中(即Session，一次会话可能会有多次请求，当然也可以有多个Cookie来跟踪不同的信息)的信息，这样服务器就会知道用户的状态，比如有没有登录成功，付款时购物车中的东西等，就相当于贴在客户端脑门上的纸条，浏览器看不到，但服务器看得到。

1.2.2 Cookie的应用

1.2.2.1 保持用户登录状态

将用户的信息保存到Cookie中，并发送给浏览器，并且将有效时间设置为一个较长的时间，这样浏览器在以后访问网站时，都会带着该Cookie，服务器以此来辨识用户，用户就不再需要输入用户名和密码等信息。

1.2.2.2 记录用户名

一旦用户登录成功以后，下次再登录时，直接将Cookie中的用户名读取并显示出来，这样用户就不需要再次输入用户名，只输入密码即可。

1.2.3 Cookie的设置和获取

1.2.3.1 通过HttpServletResponse.addCookie的方式设置Cookie

注意:new Cookie()时两个参数都是字符串

Cookie cookie = new Cookie("jieguo","true"); 
response.addCookie(cookie);

1.2.3.2 浏览器中查看cookie的内容

1.2.3.3 服务端获取客户端携带的cookie：通过HttpServletRequest获取

<% 
	Cookie[] cookies = request.getCookies(); 
		if(cookies != null) 
			for(Cookie c : cookies){ 	
				String name = c.getName();//获取Cookie名称 
				if("jieguo".equals(name)){ 
					String value = c.getValue();//获取Cookie的值 
					bool = Boolean.valueOf(value);//将值转为Boolean类型 
				} 
			} 
%>

1.2.4 删除Cookie

通过设置同名Cookie的最大存活时间为0，删除Cookie是指使浏览器不再保存Cookie，使Cookie立即失效 
举例：使name为username的Cookie立即失效

//1.创建一个name为username的Cookie 
Cookie cookie = new Cookie("username", "aaa"); 
//2.设置Cookie的有效时间为0 
cookie.setMaxAge(0);//删除cookie的关键 
//3.将cookie发送给浏览器，来替换同名Cookie 
response.addCookie(cookie);

Cookie的有效时间
Cookie发送给浏览器以后，浏览器并不会永久保存，也就是到了一定的时间以后浏览器会自动销毁Cookie。 Cookie的默认有效时间为一次会话(一次打开关闭浏览器的过程)，我们也可以手动指定Cookie的有效时间

//setMaxAge用来设置Cookie的最大有效时间，需要int型的参数，代表有效的秒数 
cookie.setMaxAge(秒数)； 
//当参数大于0时，会设置为指定的秒数 
cookie.setMaxAge(30); 
//当参数等于0时,浏览器不会保存Cookie,Cookie立即失效 
cookie.setMaxAge(0); 
//当参数小于0时，和不设置是一样，当前会话有效 
cookie.setMaxAge(-100); 
//设置一个永久有效的Cookie，并非永久，只是使Cookie的生命很长而已 
cookie.setMaxAge(60*60*24*365*10);

1.3 Session

1.3.1 什么是Session

Session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而Session保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。客户端浏览器再次访问时只需要从该Session中查找该客户的状态就可以了。
如果说Cookie机制是通过检查客户身上的“通行证”来确定客户身份的话，那么Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案，客户来访的时候只需要查询客户档案表就可以了。

1.3.2 创建Session的格式

Session对应的类为javax.servlet.http.HttpSession类。每个来访者对应一个Session对象，所有该客户的状态信息 都保存在这个Session对象里。Session对象是在客户端第一次请求服务器的时候创建的。 
Session也是一种key-value的属性对，通过getAttribute(Stringkey)和setAttribute(String key，Objectvalue)方法读写客户状态信息。Servlet里通过request.getSession()方法获取该客户的Session 

例如：

HttpSession session = request.getSession(); // 获取Session对象
session.setAttribute("loginTime", new Date()); // 设置Session中的属性 
out.println("登录时间为：" +(Date)session.getAttribute("loginTime")); // 获取Session属性

1.3.3 Session的生命周期

Session保存在服务器端。为了获得更高的存取速度，服务器一般把Session放在内存里。每个用户都会有一个独立 的Session。如果Session内容过于复杂，当大量客户访问服务器时可能会导致内存溢出。因此，Session里的信息应该尽量精简。

Session在用户第一次访问服务器的时候自动创建。需要注意只有访问JSP、Servlet等程序时才会创建Session，只访问HTML、IMAGE等静态资源并不会创建Session。如果尚未生成Session，也可以使request.getSession(true)强制生成Session。

Session生成后，只要用户继续访问，服务器就会更新Session的最后访问时间，并维护该Session。用户每访问服务器一次，无论是否读写Session，服务器都认为该用户的Session“活跃（active）”了一次。

由于会有越来越多的用户访问服务器，因此Session也会越来越多。为防止内存溢出，服务器会把长时间内没有活 跃的Session从内存删除。这个时间就是Session的超时时间。如果超过了超时时间没访问过服务器，Session就自动失效了。

Session的超时时间为maxInactiveInterval属性，可以通过对应的getMaxInactiveInterval()获取，通过setMaxInactiveInterval(longinterval)修改。

Session的超时时间也可以在web.xml中修改。另外，通过调用Session的invalidate()方法可以使Session失效。

<session-config> 
	<session-timeout>30</session-timeout> 
</session-config>

1.3.4 Session常用的方法

1.3.5 Session的应用场景

代码演示：1.登录 2.退出(创建Session和消除Session)

1.3.6 Session和Cookie的区别

1. Cookie数据保存在客户端，Session数据保存在服务器端。
2. Session是由应用服务器维持的一个服务器端的存储空间，用户在连接服务器时，会由服务器生成一个唯一的SessionID,用该SessionID 为标识符来存取服务器端的Session存储空间。而SessionID这一数据则是保存到客户端，用Cookie保存的，用户提交页面时，会将这一SessionID提交到服务器端，来存取Session数据。这一过程，是不用开发人员干预的。所以一旦客户端禁用Cookie，那么Session也会失效。
3. Cookies是属于Session对象的一种。但有不同，Cookies不会占服务器资源，是存在客服端内存或者一个Cookie的文本文件中；而Session则会占用服务器资源。所以，尽量不要使用Session，而使用Cookies。但是我们一般认为Cookie是不可靠的，Cookies是保存在本机上的，但是其信息的完全可见性且易于本地编辑性，往往可以引起很多的安全问题Session是可靠地。但是目前很多著名的站点也都用Cookie。

2. 过滤器(Filter)

2.1 什么是过滤器

过滤器实际上就是对web资源进行拦截，做一些处理后再交给下一个过滤器或servlet处理，通常都是用来拦截request进行处理的，也可以对返回的response进行拦截处理

2.2 过滤器的语法格式

2.2.1 创建一个类实现Filter接口

public class CharSetFilter implements Filter{}

2.2.2 重写接口中的方法

public void destroy() { //销毁的方法} 
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException { 
		//过滤方法 主要是对request和response进行一些处理，然后交给下一个过滤器或Servlet处理 
		chain.doFilter(req, resp); 
	}
	public void init(FilterConfig config) throws ServletException { 
		/*初始化方法 接收一个FilterConfig类型的参数 该参数是对Filter的一些配置*/
	}

2.2.3 在web.xml文件中配置

<filter>
	<filter-name>过滤器名称</filter-name> 
	<filter-class>过滤器所在的路径</filter-class> 
</filter> 
<filter-mapping> 
	<filter-name>过滤器名称</filter-name> 
	<url-pattern>需要过滤的资源</url-pattern> 
</filter-mapping>

2.3 使用场景

2.3.1 如何防止用户未登录就执行后续操作

String name=(String)session.getAttribute("key"); 
if(name==null){ //跳转到登录页面 }

2.3.2 设置编码方式–统一设置编码

2.3.3 加密解密(密码的加密和解密)

2.3.4 非法文字筛选

2.3.5 下载资源的限制

过滤器的特点:在servlet之前和之后都会被执行

3. 监听器(Listener)

3.1 什么是监听器

监听器就是监听某个域对象的的状态变化的组件监听器的相关概念： 
事件源：被监听的对象(三个域对象 request、session、servletContext) 
监听器：监听事件源对象事件源对象的状态的变化都会触发监听器
注册监听器：将监听器与事件源进行绑定
响应行为：监听器监听到事件源的状态变化时所涉及的功能代码（程序员编写代码）

3.2 监听器分类

第一维度按照被监听的对象划分：ServletRequest域、HttpSession域、ServletContext域 
第二维度按照监听的内容分：监听域对象的创建与销毁的、监听域对象的属性变化的

3.3 监听三大域对象的创建与销毁的监听器

监听器的编写步骤（重点）：

编写一个监听器类去实现监听器接口覆盖监听器的方法 
需要在web.xml中进行配置—注册

<listener> 
	<listener-class>监听器所在的路径</listener-class>
</listener>

3.3.1 ServletContextListener

监听ServletContext域的创建与销毁的监听器

3.3.2 Servlet域的生命周期

何时创建：服务器启动创建 
何时销毁：服务器关闭销毁

3.3.3 ServletContextListener监听器的主要作用

初始化的工作：初始化对象、初始化数据（加载数据库驱动、连接池的初始化） 
加载一些初始化的配置文件 (spring的配置文件） 
任务调度(定时器—Timer/TimerTask）

3.3.4 HttpSessionListener

监听Httpsession域的创建和销毁的监听器

3.3.5 HttpSession对象的生命周期

何时创建：第一次调用request.getSession时创建 
何时销毁：服务器关闭销毁、session过期（默认30分钟，修改默认的30分钟是在Tomcat的web.xml，修改当前项目的过期时间是在自己项目的web.xml中）、手动销毁

3.3.6 HttpSessionListener监听器的主要作用：

由于每次访问网站都会默认创建session对象（jsp页面中page指令中的session属性默认为true，即被访问时创建session），可以用于计数网站访问过的人

3.3.7 ServletRequestListener

监听ServletRequest域创建与销毁的监听器

3.3.8 ServletRequest的生命周期

创建：每一次请求都会创建request 
销毁：请求结束 
用法同上，用处不是很大，此处省略。

五、MVC

1. MVC设计模式

Web MVC中的M(模型)-V(视图)-C(控制器)概念和标准MVC概念一样，我们再看一下Web MVC标准架构，如下图所示：

在Web MVC模式下，模型无法主动推数据给视图，如果用户想要视图更新，需要再发送一次请求（即请求-响应模型）。 
M：(Model) 模型 : 应用程序的核心功能，管理这个模块中用的数据和值（bean,dao）；

JavaBeans :是Java中一种特殊的类（换言之：JavaBean就是一个Java类）.
一个Java类 ，满足以下要求，则可称为一个JavaBean 
	a. public修饰的类，提供public 无参构造方法 
	b. 所有属性都是private 
	c. 提供getter和setter方法 

从使用层面来看，JavaBean分为2大类： 
	a. 封装业务逻辑的JavaBean(eg:LoginDao.java 封装了登录逻辑) 
	b. 封装数据的JavaBean(实体类：eg：Student.java Vadio.java 。往往对应于数据库中的一张表，即数据库中有个Student表，项目中就有个Student.java类)通常:表名=类名，列名=属性名 

JavaBean是一个可以重复使用的组件，通过编写一个组件来实现某种通用功能，“一次编写、任何地方执行、任何地方重用”。

V(View )视图: 视图提供模型的展示，管理模型如何显示给用户，它是应用程序的外观；（jsp/html） 
C(Controller)控制器: 对用户的输入做出反应，管理用户和视图的交互，是连接模型和视图的枢纽。 （servlet/service） 
MVC用于将web（UI）层进行职责解耦 

说明:mvc设计模式(不属于23种设计模式)

2. 三层架构

三层架构 通常意义上的三层架构就是将整个业务应用划分为：表现层（UI）、业务逻辑层（BLL）、数据访问层 （DAL）。区分层次的目的即为了“高内聚，低耦合”的思想。 
1、表现层（UI）：通俗讲就是展现给用户的界面，即用户在使用一个系统的时候他的所见所得。 jsp/html 
2、业务逻辑层（BLL）：针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。 servlet,service 
3、数据访问层（DAL）：该层所做事务直接操作数据库，针对数据的增添、删除、修改、更新、查找等。dao 表现层实现的代表作品是Struts,springmvc框架， 业务层实现的代表作品是Spring， 持久层实现的代表作品是Hibernate,mybatis。 
层就相当于一个黑盒子，我们不用知道它内部怎么实现，只需要知道如何去调用它就行了。每层只与上下相邻的两层打交道。当一层内部由于技术变迁发生变化时，只要接口不变，其他层不用做任何改变。分层之后灵活性提高， 也便于团队分工开发。

3. 三层架构和MVC的区别与联系

MVC是 Model-View-Controller，严格说这三个加起来以后才是三层架构中的UI层，也就是说，MVC把三层架构中的UI层再度进行了分化，分成了控制器、视图、实体三个部分，控制器完成页面逻辑，通过实体来与界面层完成通话；而C层直接与三层中的BLL进行对话。 
MVC可以是三层中的一个表现层框架，属于表现层。三层和mvc可以共存。 
三层是基于业务逻辑来分的，而MVC是基于页面来分的。 
MVC主要用于表现层，3层主要用于体系架构，3层一般是表现层、中间层、数据层，其中表现层又可以分成M、 V、C，(Model View Controller)模型－视图－控制器
MVC是表现模式（Presentation Pattern） 
三层架构是典型的架构模式（Architecture Pattern） 
三层架构的分层模式是典型的上下关系，上层依赖于下层。但MVC作为表现模式是不存在上下关系的，而是相互协作关系。即使将MVC当作架构模式，也不是分层模式。MVC和三层架构基本没有可比性，是应用于不同领域的技术。

六、AJAX

1. Ajax技术与原理

1.1 Ajax简介

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。 
AJAX 不是新的编程语言，而是一种使用现有标准的新方法。 
AJAX 是与服务器交换数据并更新部分网页的艺术，在不重新加载整个页面的情况下。

1.2 Ajax所包含的技术

大家都知道ajax并非一种新的技术，而是几种原有技术的结合体。它由下列技术组合而成。
1.使用CSS和XHTML来表示。 
2.使用DOM模型来交互和动态显示。 
3.使用XMLHttpRequest来和服务器进行异步通信。 
4.使用javascript来绑定和调用。

AJAX 的核心是 XMLHttpRequest 对象。 
不同的浏览器创建 XMLHttpRequest 对象的方法是有差异的。 
IE 浏览器使用 ActiveXObject，而其他的浏览器使用名为 XMLHttpRequest 的 JavaScript 内建对象

1.3 Ajax的工作原理

Ajax的工作原理相当于在用户和服务器之间加了—个中间层(AJAX引擎)，使用户操作与服务器响应异步化。并不是所有的用户请求都提交给服务器。像—些数据验证和数据处理等都交给Ajax引擎自己来做，只有确定需要从服务器 读取新数据时再由Ajax引擎代为向服务器提交请求。 

来看看和传统方式的区别

再来看看它们各自的交互 
浏览器的普通交互方式

浏览器的Ajax交互方式

在创建Web站点时，在客户端执行屏幕更新为用户提供了很大的灵活性。下面是使用Ajax可以完成的功能： 动态更新购物车的物品总数，无需用户单击Update并等待服务器重新发送整个页面。 提升站点的性能，这是通过减少从服务器下载的数据量而实现的。例如，在Amazon的购物车页面，当更新篮子中的一项物品的数量时，会重新载入整个页面，这必须下载32K的数据。如果使用Ajax计算新的总量，服务器只会返回新的总量值，因此所需的带宽仅为原来的百分之一。 消除了每次用户输入时的页面刷新。例如，在Ajax中，如果用户在分页列表上单击Next， 则服务器数据只刷新列表而不是整个页面。 直接编辑表格数据，而不是要求用户导航到新的页面来编辑数据。对于 Ajax，当用户单击Edit时，可以将静态表格刷新为内容可编辑的表格。用户单击Done之后，就可以发出一个Ajax请求来更新服务器，并刷新表格，使其包含静态、只读的数据。

1.4 XMLHttpRequest常用属性

1.4.1 onreadystatechange 属性

onreadystatechange 属性存有处理服务器响应的函数。 
下面的代码定义一个空的函数，可同时对 onreadystatechange 属性进行设置：

xmlHttp.onreadystatechange = function() { //我们需要在这写一些代码}

1.4.2 readyState 属性

readyState 属性存有服务器响应的状态信息。每当 readyState 改变时，onreadystatechange 函数就会被执行。 
readyState 属性可能的值：

我们要向这个 onreadystatechange 函数添加一条 If 语句，来测试我们的响应是否已完成(意味着可获得数据)：

xmlHttp.onreadystatechange = function() {
 	if (xmlHttp.readyState == 4) {
 	 	//从服务器的response获得数据 
 	 } 
 }

1.4.3 responseText 属性

可以通过 responseText 属性来取回由服务器返回的数据。 
在我们的代码中，我们将把时间文本框的值设置为等于 responseText：

xmlHttp.onreadystatechange = function() {
 	if (xmlHttp.readyState == 4) {
 	 	document.myForm.time.value = xmlHttp.responseText;
 	 } 
 }

其它属性如下：

1.5 XMLHttpRequest方法

1.5.1 open() 方法

open() 有三个参数。
第一个参数定义发送请求所使用的方法，第二个参数规定服务器端脚本的URL，第三个参数规定应当对请求进行异步地处理。

xmlHttp.open("GET","test.php",true);

1.5.2 send() 方法

send() 方法将请求送往服务器。如果我们假设 HTML 文件和 PHP 文件位于相同的目录，那么代码是这样的：

xmlHttp.send(null);

其它方法如下：

2. Ajax编程步骤

为了方便理解，我给AJAX统一了一个流程，要想实现AJAX，就要按照以后步骤走： 
1. 创建XMLHttpRequest对象。 
2. 设置请求方式。
3. 调用回调函数。 
4. 发送请求。

下面来看下具体步骤：

2.1 创建XMLHttpRequest对象

创建XMLHttp对象的语法是：

var xmlHttp=new XMLHttpRequest();

如果是IE5或者IE6浏览器，则使用ActiveX对象，创建方法是：

var xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");

一般我们手写AJAX的时候，首先要判断该浏览器是否支持XMLHttpRequest对象，如果支持则创建该对象，如果不支持则创建ActiveX对象。JS代码如下：

//第一步：创建XMLHttpRequest对象 
var xmlHttp; 
if (window.XMLHttpRequest) {
	//非IE 
	xmlHttp = new XMLHttpRequest(); 
} else if (window.ActiveXObject) {
	//IE 
	xmlHttp = new ActiveXObject("Microsoft.XMLHTTP")
}

2.2 设置请求方式

在WEB开发中，请求有两种形式，一个是get，一个是post，所以在这里需要设置一下具体使用哪个请求， XMLHttpRequest对象的open()方法就是来设置请求方式的。 open()方法

如下：

//第二步：设置和服务器端交互的相应参数，向路径http://localhost:8080/JsLearning3/getAjax准备发送数据 
var url = "http://localhost:8080/JsLearning3/getAjax"; 
xmlHttp.open("POST", url, true);

open方法如下：

GET 还是 POST? 与 POST 相比，GET 更简单也更快，并且在大部分情况下都能用。然而，在以下情况中，请使用 POST 请求：

无法使用缓存文件（更新服务器上的文件或数据库） 向服务器发送大量数据（POST 没有数据量限制） 发送 包含未知字符的用户输入时，POST 比 GET 更稳定也更可靠 

异步 - True 或 False？ AJAX 指的是异步 JavaScript 和 XML（Asynchronous JavaScript and XML）。
XMLHttpRequest 对象如果要用于 AJAX 的话，其 open() 方法的 async 参数必须设置为 true：对于 web 开发人员 来说，发送异步请求是一个巨大的进步。很多在服务器执行的任务都相当费时。AJAX 出现之前，这可能会引起应用程序挂起或停止。 通过 AJAX，JavaScript 无需等待服务器的响应，而是： 在等待服务器响应时执行其他脚本当响应就绪后对响应进行处理

2.3 调用回调函数

如果在上一步中open方法的第三个参数选择的是true，那么当前就是异步请求，这个时候需要写一个回调函数， XMLHttpRequest对象有一个onreadystatechange属性，这个属性返回的是一个匿名的方法，所以回调函数就在这里写xmlHttp.onreadystatechange=function{},function{}内部就是回调函数的内容。所谓回调函数，就是请求在后台处理完，再返回到前台所实现的功能。在这个例子里，我们的回调函数要实现的功能就是接收后台处理后反馈给前台的数据，然后将这个数据显示到指定的div上。因为从后台返回的数据可能是错误的，所以在回调函数中首先要判断后台返回的信息是否正确，如果正确才可以继续执行。
代码如下：

//第三步：注册回调函数 
xmlHttp.onreadystatechange = function() { 
	if (xmlHttp.readyState == 4) {
		if (xmlHttp.status == 200) { 
			var obj = document.getElementById(id); 
			obj.innerHTML = xmlHttp.responseText; 
		} else { 
			alert("AJAX服务器返回错误！"); 
		} 
	} 
}

在上面代码中，xmlHttp.readyState是存有XMLHttpRequest 的状态。
从 0 到 4 发生变化。
0: 请求未初始化。
1: 服务器连接已建立。
2: 请求已接收。
3: 请求处理中。
4: 请求已完成，且响应已就绪。

所以这里我们判断只有当 xmlHttp.readyState为4的时候才可以继续执行。 
xmlHttp.status是服务器返回的结果，其中200代表正确。404代表未找到页面，所以这里我们判断只有当 xmlHttp.status等于200的时候才可以继续执行。

var obj = document.getElementById(id);obj.innerHTML = xmlHttp.responseText;

这段代码就是回调函数的核心内容，就是获取后台返回的数据，然后将这个数据赋值给id为testid的div。xmlHttp 对象有两个属性都可以获取后台返回的数据，分别是：responseText和responseXML，其中responseText是用来获得字符串形式的响应数据，responseXML是用来获得XML形式的响应数据。至于选择哪一个是取决于后台给返回的数据的，这个例子里我们只是显示一条字符串数据所以选择的是responseText。responseXML将会在以后的例子中介绍。

AJAX状态值与状态码区别 AJAX状态值是指，运行AJAX所经历过的几种状态，无论访问是否成功都将响应的步骤，可以理解成为AJAX运行步骤。如：正在发送，正在响应等，由AJAX对象与服务器交互时所得；使用“ajax.readyState”获得。（由数字1~4单位数字组成）AJAX状态码是指，无论AJAX访问是否成功，由HTTP协议 根据所提交的信息，服务器所返回的HTTP头信息代码，该信息使用“ajax.status”所获得；（由数字1XX,2XX三位数字组成，详细查看RFC）这就是我们在使用AJAX时为什么采用下面的方式判断所获得的信息是否正确的原因。

if(ajax.readyState == 4 && ajax.status == 200) {。。。。);}

AJAX运行步骤与状态值说明 在AJAX实际运行当中，对于访问XMLHttpRequest（XHR）时并不是一次完成的，而 是分别经历了多种状态后取得的结果，对于这种状态在AJAX中共有5种，分别是： 0 - (未初始化)还没有调用send() 方法 1 - (载入)已调用send()方法，正在发送请求 2 - (载入完成)send()方法执行完成， 3 - (交互)正在解析响应内容 4 - (完成)响应内容解析完成，可以在客户端调用了 对于上面的状态，其中“0”状态是在定义后自动具有的状态值， 而对于成功访问的状态（得到信息）我们大多数采用“4”进行判断。
AJAX状态码说明 1：请求收到，继续处理 2：操作成功收到，分析、接受 3：完成此请求必须进一步处理 4：请求 包含一个错误语法或不能完成 5：服务器执行一个完全有效请求失败
再具体就如下：

100——客户必须继续发出请求 101——客户要求服务器根据请求转换HTTP协议版本 200——交易成功 201——提示知道新文件的URL 202——接受和处理、但处理未完成 203——返回信息不确定或不完整 204——请求收到，但返回信息为空 205——服务器完成了请求，用户代理必须复位当前已经浏览过的文件 206——服务器已经完成了部 分用户的GET请求 300——请求的资源可在多处得到 301——删除请求数据 302——在其他地址发现了请求数据 303——建议客户访问其他URL或访问方式 304——客户端已经执行了GET，但文件未变化 305——请求的资源必须从服务器指定的地址得到 306——前一版本HTTP中使用的代码，现行版本中不再使用 307——申明请求的资源临时性删除 400——错误请求，如语法错误 401——请求授权失败 402——保留有效ChargeTo头响应 403——请 求不允许 404——没有发现文件、查询或URl 405——用户在Request-Line字段定义的方法不允许 406——根据用 户发送的Accept拖，请求资源不可访问 407——类似401，用户必须首先在代理服务器上得到授权 408——客户端没有在用户指定的饿时间内完成请求 409——对当前资源状态，请求不能完成 410——服务器上不再有此资源且无进一步的参考地址 411——服务器拒绝用户定义的Content-Length属性请求 412——一个或多个请求头字段在当前请求中错误 413——请求的资源大于服务器允许的大小 414——请求的资源URL长于服务器允许的长度 415——请 求资源不支持请求项目格式 416——请求中包含Range请求头字段，在当前请求资源范围内没有range指示值，请求也不包含If-Range请求头字段 417——服务器不满足请求Expect头字段指定的期望值，如果是代理服务器，可能是下一级服务器不能满足请求 500——服务器产生内部错误 501——服务器不支持请求的函数 502——服务器暂时不可用，有时是为了防止发生系统过载 503——服务器过载或暂停维修 504——关口过载，服务器使用另一个关口或服务来响应用户，等待时间设定值较长 505——服务器不支持或拒绝支请求头中指定的HTTP版本

2.4 发送请求

//第四步：设置发送请求的内容和发送报送。然后发送请求 
var uname= document.getElementsByName("userName")[0].value; 
var upass= document.getElementsByName("userPass")[0].value ; 
var params = "userName=" + uname+ "&userPass=" +upass+ "&time=" + Math.random(); 
// 增加time随机参数，防止读取缓存 
xmlHttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded;charset=UTF-8"); 
// 向请求添加 HTTP 头，POST如果有数据一定加加！！！！ 
xmlHttp.send(params);

如果需要像 HTML 表单那样 POST 数据，请使用 setRequestHeader() 来添加 HTTP 头。然后在 send() 方法中规定您希望发送的数据。

3. jquery的ajax操作

3.1 传统方式实现Ajax的不足

步骤繁琐 
方法、属性、常用值较多不好记忆

3.2 ajax()方法

可以通过发送 HTTP请求加载远程数据，是 jQuery 最底层的 Ajax 实现，具有较高灵活性。 
.ajax([settings]);//参数settings是.jax()方法的参数列表，用于配置 Ajax 请求的键值对集合;

$.ajax({ 
	url:请求地址 
	type:"get | post | put | delete " 默认是get, 
	data:请求参数 {"id":"123","pwd":"123456"}, 
	dataType:请求数据类型"html | text | json | xml | script | jsonp ", 
	success:function(data,dataTextStatus,jqxhr){ },//请求成功时 
error:function(jqxhr,textStatus,error)//请求失败时 
})

3.3 get() 方法通过远程 HTTP GET 请求载入信息

这是一个简单的 GET 请求功能以取代复杂 $.ajax 。

$.get(url,data,function(result) { 
	//省略将服务器返回的数据显示到页面的代码 
});

url:请求的路径 
data:发送的数据 
success:成功函数 
datatype 返回的数据

3.4 post() 方法通过远程 HTTP GET 请求载入信息

$.post(url,data,function(result) {
	 //省略将服务器返回的数据显示到页面的代码 
});

url:请求的路径 
data:发送的数据 
success:成功函数 
datatype 返回的数据

4. JSON

4.1 什么是JSON

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子 集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。 这些特性使JSON成为理想的数据交换语言。

4.2 JSON对象定义和基本使用

在标准的json格式中，json对象由在括号括起来，对象中的属性也就是json的key是一个字符串，所以一定要使用双引号引起来。每组key之间使用逗号进行分隔。

4.2.1 JSON的定义

Json定义格式：

var 变量名 = { 
“key” : value , // Number类型 
“key2” : “value” , // 字符串类型 
“key3” : [] , // 数组类型 
“key4” : {}, // json 对象类型 
“key5” : [{},{}] // json 数组 
};

4.2.2 JSON对象的访问

json对象，顾名思义，就知道它是一个对象。里面的key就是对象的属性。我们要访问一个对象的属性，只需要使用【对象名.属性名】的方式访问即可。

<script type="text/javascript"> 
	// json的定义 
	var jsons = { 
		"key1":"abc", // 字符串类型 
		"key2":1234, // Number 
		"key3":[1234,"21341","53"], // 数组 
		"key4":{ // json类型 
			"key4_1" : 12, 
			"key4_2" : "kkk" 
		},
		"key5":[{ // json数组 
			"key5_1_1" : 12, 
			"key5_1_2" : "abc" 
		},{ 
			"key5_2_1" : 41,
			"key5_2_2" : "bbj" 
		}] 
	};
	// 访问json的属性 
	alert(jsons.key1); // "abc" 
	// 访问json的数组属性 
	alert(jsons.key3[1]); // "21341" 
	// 访问json的json属性 
	alert(jsons.key4.key4_1);//12 
	// 访问json的json数组 
	alert(jsons.key5[0].key5_1_2);//"abc" 
</script>

4.3 JSON在java中的使用(重要)

我们要使用json和java中使用，我们需要使用到一个第三方的包。它就是

java对象和json之间的转换
《1》单个对象或map集合
java->json：

Users user2=new Users(); 
user2.setUsername("李四"); 
user2.setPassword("abc"); 
user2.setAge(20); 
JSONObject obj=JSONObject.fromObject(user);//obj就是json格式的

json->java：

String str="{'username':'李四','password':'admin','age':19}"; 
JSONObject json=JSONObject.fromObject(str); 
Users user=(Users)JSONObject.toBean(json,Users.class);

《2》对象集合和json的转换
java集合->json数组:

List list=new ArrayList(); 
list.add("dd"); 
list.add("aa"); 
JSONArray obj=JSONArray.fromObject(list);//set也是这么转

json数组->java集合:
方式1:

String str2="[{'age':20,'password':'abc','username':'李四'}, {'age':10,'password':'adb','username':'张三'}]"; 
JSONArray json2=JSONArray.fromObject(str2); 
Object[] obj=(Object[])JSONArray.toArray(json2,Users.class);

方式2:

String str3="[{'age':20,'password':'abc','username':'李四'}, {'age':10,'password':'adb','username':'展示干'}]"; 
JSONArray json3=JSONArray.fromObject(str3); 
//默认转换成ArrayList List<Users>
list=(List<Users>) JSONArray.toCollection(json3,Users.class);

ajax实例2-实现数据的自动填充：
页面:

<script type="text/javascript" src="js/jquery-1.8.3.min.js"></script> 
	<script> 
		$(function(){ 
			$("[name='uid']").blur(function(){ 
				var uid=$(this).val(); 
				$.ajax({ 
					url:"getuser", 
					data:"userid="+uid, 
					type:"post", 
					dataType:"JSON",//设置服务器端响应回来的格式 
					success:function(rs){ 
						//alert(rs.username); 
						$("[name='uname']").val(rs.username); 
						$("[name='address']").val(rs.address); 
						if(rs.sex=='男'){ 
							$("#boy")[0].checked=true; 
						}else{
							$("#girl")[0].checked=true; 
						} 
					} 
				}); 
			});
		}) 
	</script> 
	</head> 
	<body> 
	userid:<input type="text" name="uid"><br> 
	username <input type="text" id="uname" name="uname"><br> 
	address <input type="text" id="address" name="address"><br> 
	sex:<input type="radio" name="sex" id="boy">男 <input type="radio" name="sex" id="girl">女 
	</body>

后台:
实体类

public class Users { 
	private String username; 
	private String password; 
	private String address; 
	private String sex; 
}

处理类:

protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
	String userid=req.getParameter("userid"); 
	
	Users users=new Users(); 
	switch (Integer.parseInt(userid)){ 
		case 1: 
			users.setUsername("张安"); 
			users.setAddress("北京"); 
			users.setSex("男"); 
			break; 
		case 2: 
			users.setUsername("张安1"); 
			users.setAddress("北京2"); 
			users.setSex("女"); 
			break; 
		case 3: 
			users.setUsername("张安3"); 
			users.setAddress("北京3"); 
			users.setSex("男"); 
			break; 
		default: 
			users.setUsername(""); 
			users.setAddress(""); 
			users.setSex(""); 
	}
	//将users对象响应给客户端，使用PrintWriter来实现
	resp.setContentType("text/html;charset=utf-8"); 
	PrintWriter writer = resp.getWriter(); 
	
	//将对象转换成json格式 
	JSONObject jsonObject = JSONObject.fromObject(users); 
	writer.print(jsonObject); 
}

七、使用smartupload.jar实现文件上传

1. 将jar包添加到项目中:smartupload.jar

2. 准备上传的页面

<form action="toUpload" method="post" enctype="multipart/form-data" > 
	书名:<input type="text" name="bookName"/><br> 
	图片:<input type="file" name="自定义名称"/><br> 
	<input type="submit" value="提交"/> 
</form>

注:
(1)form标签中要添加enctype属性 
(2)提交方式必须是post

3. 开始获取数据,保存文件

实例代码：

public void upload(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
	try {
		//上传文件 
		SmartUpload su=new SmartUpload(); 
		//获得pageContext对象 
		JspFactory factory=JspFactory.getDefaultFactory(); 
		PageContext pagecontext= factory. getPageContext(this, request,response, null,false,1024,true); 
		su.initialize(pagecontext); 
		su.setCharset("utf-8"); 
		//实现文件数据的上传 
		su.upload(); 
		File file = su.getFiles().getFile(0); 
		//得到文件的基本信息 
		String filename=file.getFileName(); 
		String type=file.getContentType(); 
		System.out.println("type="+type); 
		String url="uploadfile/"+filename; 
		//将上传文件保存到指定目录 
		file.saveAs(url, SmartUpload.SAVE_VIRTUAL); 
		request.setAttribute("filename",filename); 
		
		String uname=su.getRequest().getParameter("uname"); 
		System.out.println("uname="+uname); 
		request.getRequestDispatcher("success.jsp").forward(request, response);
	} catch (SmartUploadException e) { 
		// TODO Auto-generated catch block 
		e.printStackTrace(); 
	} 
}

注：
(1)此时如果表单中有其他数据时，不能通过request直接获取，需要通过SmartUpload对象获取 
String name=su.getRequest().getParameter("bookName"); 
并且该代码要在SmartUpload操作完成后添加 

(2)解决乱码: 
new String(name.getBytes("GBK"),"utf-8") 
注:斜杠方向:/

注意:

smartupload常用方法