一. JavaWeb概述

JavaWeb：使用 Java 语言开发基于互联网的项目

软件架构：

C/S: Client/Server 客户端/服务器端
- 在用户本地有一个客户端程序，在远程有一个服务器端程序
- 如：QQ，迅雷…
- 优点：用户体验好
- 缺点：开发、安装，部署，维护麻烦
B/S: Browser/Server 浏览器/服务器端
- 只需要一个浏览器，用户通过不同的网址(URL)，客户访问不同的服务器端程序
- 优点：开发、安装，部署，维护简单
- 缺点：如果应用过大，用户的体验可能会受到影响、对硬件要求过高

B/S 架构资源分类

静态资源（使用静态网页开发技术发布的资源。）
- 所有用户访问，得到的结果是一样的。
- 如：文本，图片，音频、视频、HTML、CSS、JavaScript
- 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器。浏览器中内置了静态资源的解析引擎，可以展示静态资源.
- HTML：用于搭建基础网页，展示页面的内容（结构标准：结构用于对网页元素进行整理和分类）
- CSS：用于美化页面，布局页面（表现标准：表现用于设置网页元素的版式、颜色、大小等外观样式）
- JavaScript：控制页面的元素，让页面有一些动态的效果（行为标准：行为是指网页模型的定义及交互的编）

动态资源（使用动态网页及时发布的资源。）
- 不同用户访问，得到的结果可能不一样。
- 如：jsp/servlet、php、asp…
- 如果用户请求的是动态资源，那么服务器会执行动态资源，将其转换为静态资源，再发送给浏览器。

一. XML

1. 名词解释

XML 全称：Extensible Markup Language 可扩展标记语言

XML 作用：

用来传输和存储数据。

作为配置文件

XML 与 HTML 的区别：

xml 标签都是自定义的，html 标签是预定义。
xml 的语法严格，html 语法松散
xml 用于存储和传输数据的，其焦点是数据的内容。html 用于显示数据，其焦点是数据的外观。

2. 语法

（1）规范

xml 文档的后缀名 .xml
xml 第一行必须定义为文档声明
xml 文档中有且仅有一个根标签
属性值必须使用引号(单双都可)引起来
标签必须正确关闭
大小写敏感
注释不能嵌套

（2）文档声明

格式：<?xml version=”1.0” encoding=”UTF-8”?>

version：版本号
encoding：编码方式。告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1
standalone（可以省略）：是否独立，取值为yes，表示不依赖其他文件，取值为no（默认值），表示依赖其他文件

（3）标签（元素）

在XML中，元素就是标签的意思。

规则：

名称可以包含字母、数字以及其他的字符
名称不能以数字或者标点符号开始
名称不能以字母 xml（或者 XML、Xml 等等）开始
名称不能包含空格
XML元素中出现的空格和换行都会被当做元素内容进行处理。
xml 也中的元素（标签）可成分成单标签和双标签：
单标签： <标签名属性=”值” 属性=”值” …… />
双标签：< 标签名属性=”值” 属性=”值” ……>文本数据或子标签</标签名>**

（4）特殊字符

特殊字符	替代符号
`<`	`<`
`>`	`>`
`'`	`'`
`"`	`"`
`&`	`&`

（5）CDATA 区

CDATA 是 Character Dat a的缩写，作用：在该区域中的数据会被原样展示。

格式：  <![CDATA[ 内容 ]]>

3. XML 解析

解析：操作 xml 文档，将文档中的数据读取到内存中

操作 xml 文档

解析(读取)：将文档中的数据读取到内存中
写入：将内存中的数据保存到xml文档中。持久化的存储

解析 xml 的方式：

JDK 提供
- DOM：将标记语言文档一次性加载进内存，在内存中形成一颗dom树
  
  优点：操作方便，可以对文档进行CRUD的所有操作
  
  缺点：占内存
- SAX（ Simple API for XML ）：逐行读取，基于事件驱动的。
  
  优点：不占内存。
  
  缺点：只能读取，不能增删改

第三方解析器
- jdom 在 dom 基础上进行了封装
- dom4j 又对 jdom 进行了封装。

4. dom4j 解析技术

dom4j 解析集 DOM 和 SAX 技术优点于一身，是目前最常用的解析 XML 的方法，

使用：

（1）导如 jar 包

创建一个 lib 目录，导入dom4j 的 jar 包。并添加到类路径。

（2）CRUD

① 读取 XML 文件，获得 Document 对象

② 调用 Document 对象的 getRootElement() 方法得到根标签，返回的是 Element 对象

③ 使用 ELement对象.方法名(参数)进行操作

返回值类型	方法名（参数）	说明
Element	element(“标签名”)	获取指定名称的子元素，如果有多个该名称的子元素，则返回第一个
List	elements()	获取所有子元素，并用一个list返回
List	elements(“标签名”)	获得所有的该标签的子元素
String	getText()	获得元素文本值
String	elementText(“标签名”)	获得指定名称子元素的文本值
void	setText(“文本值”)	设置元素文本值
Element	getparent()	获取父节点，如果是根元素调用则返回null
List	attributes()	获取该元素的所有属性，以一个list返回
String	attributeValue(“属性名”)	获取指定名称属性的值，如果不存在该属性返回null
Attribute	attribute(”属性名“)	获取指定名称的属性
Element	addAttribute(“标签名”,”标签值”)	为元素增加属性
void	setAttributes(List attributes)	将list中的所有属性设置到该元素上
boolean	remove(Attribute attribute)	移除元素上的属性
Iterator	attributeIterator()	获取属性迭代器
Iterator	elementIterator()	获取子元素迭代器
Iterator	elementIterator(QName qName)	获取指定名称的子元素的迭代器

注意：读取 XML 文档的数据，都是通过 Document 获取根元素，再通过根元素获取得到其他节点从而进行操作。

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

public class XMLTest {
    @Test
    public void test() throws Exception {
        //1.创建一个 SAXReader 对象
        SAXReader saxReader = new SAXReader();

        //2.使用SAXReader对象读取XML文件，获取Document对象
        InputStream inputStream = new FileInputStream(new File("books.xml"));
        Document document = saxReader.read(inputStream);

        //3.使用Document对象获取根元素
        Element root = document.getRootElement();

        //3.获取所有标签
        List<Element> elements = root.elements("book");

        //4.遍历每一个标签，获取标签的每一个元素(.element)，再获取标签内容(.getText)
        //获取标签元素，再获取标签内容，可以合并为一步，使用.elementText
        for (Element element : elements) {
            //获取属性值
            String cn = element.attributeValue("cn");
            //获取元素值
            String name = element.elementText("name");
            String price = element.elementText("price");
            String author = element.elementText("author");
            //将信息封装到一个对象中
            System.out.println(new Book(cn,name,Double.parseDouble(price),author));
        }
    }
}

二. Tomcat

1. 名词解释

Java web，是用 java 技术来解决相关 web 互联网领域技术的总称。web 包括：web 服务器和 web 客户端两部分。

javaweb 是基于请求和响应来开发的。

请求：浏览器（客户端）向服务器发送信息
响应：服务器向（客户端）浏览器回送信息

Tomcat：由 Apache 组织提供的一种 Web 服务器，提供对 jsp 和 Servlet 的支持。它是一种轻量级的 javaWeb 容器（服务器），也是当前应用最广的 JavaWeb 服务器（免费）。

2. 基本使用

（1）安装

下载 Tomcat：http://tomcat.apache.org/whichversion.html
安装 Tomcat：Tomcat 有安装版和解压版（绿色版)。

安装版以.exe 形式的安装包，双击安装到我们的电脑上，用的比较少，解压版，即绿色版，解压压缩包后即可，用的比较多。
Tomcat 版本

Apache Tomcat® 是 Jakarta EE (正式的 Java EE )技术的一个子集的开源软件实现。对于不同版本的规范，可以使用不同版本的 Apache Tomcat。规范和各自的 Apache Tomcat 版本之间的映射如下图：
卸载 Tomcat：删除目录就行了
安装目录介绍：
- bin：存放可执行文件。
  
  在 window 下使用 startup.bat 和 shutdown.bat (linux，使用 startup.sh 和 shutdown.sh )来开启和关闭。最核心的脚本是 catalina.bat/catalina.sh，startup 和 shutdown 脚本都会调用 catalina 脚本，catalina 脚本启动或者停止 tomcat 服务器。
- conf：配置文件目录。
  - server.xml（核心配置文件）：配置整个 web 服务器信息。例如修改端口号，添加虚拟主机等.
  - tomcat-users.xml（用户权限配置文件）：存储 tomcat 用户的文件，这里保存的是 tomcat 的用户名及密码，以及用户的角色信息。
  - web.xml（所有 web 项目默认配置文件）：部署描述符文件，这个文件中注册了很多 MIME 类型，即文档类型。
  - context.xml：对所有应用的统一配置，通常我们不会去配置它。
- lib：依赖库，tomcat 和 web 项目中需要使用的 jar 包
- logs：日志文件.
  
  记录了 tomcat 启动和关闭的信息，如果启动 tomcat 时有错误，那么异常也会记录在日志文件中。
  
  localhost_access_log.*.txttomcat 记录用户访问信息，星号表示时间。
  例如：localhost_access_log.2016-02-28.txt
- temp：临时文件目录，文件夹内内容可以任意删除。
- webapps：存放web项目的目录，其中每个文件夹都是一个项目；如果这个目录下已经存在了目录，那么都是 tomcat 自带项目。其中 ROOT 是一个特殊的项目，在地址栏中没有给出项目目录时，对应的就是ROOT 项目。http://localhost:8080/examples，进入示例项目。其中 examples 就是项目名，即文件夹的名字。
- work：运行时生成的文件，最终运行的文件都在这里。通过 webapps 中的项目生成的，可以把这个目录下的内容删除，再次运行时会生再次生成 work 目录。当客户端用户访问一个JSP文件时，tomcat 会通过JSP 生成 Java 文件，然后再编译 Java 文件生成 class 文件，生成的 java 和 class 文件都会存放到这个目录下。

（2）启动

① 启动

bin/startup.bat ,双击运行该文件即可（bin目录下）

可能遇到的问题：
1. 黑窗口一闪而过：
  - 原因：没有正确配置JAVA_HOME环境变量
  - 解决方案：正确配置JAVA_HOME环境变量
2. 启动报错：
  - 原因：端口号冲突
  - 解决方案：
    
    方法一：找到占用的端口号，并且找到对应的进程，杀死该进程。
    
    运行 cmd，输入netstat -ano|findstr 8080，会显示正在使用8080 端口的进程的id。
    
    再输入taskkill /pid 进程的id /f，即可将其关闭。
    
    方法二：修改端口号，找到 Tomcat 目录下的 conf 目录，找到 server.xml 配置文件，修改Connector标签下的port。
    1
    2
    <Connector port="要修改的端口号(0~65535)" protocol="HTTP/1.1"
    connectionTimeout="20000" redirectPort="8445" />

② 访问：浏览器输入：http://localhost:8080 / http://172.0.0.1:8080 / http://真实ip地址:8080

③ 关闭：

bin/shutdown.bat，双击此文件即可（bin目录下）
Tomcat 服务器窗口下，使用ctrl+c
点击启动窗口的× 关闭

（3）部署

部署 web 项目的方式：

直接将项目放到 webapps 目录下即可。
- 访问资源路径：http://ip:port/工程名/资源名，比如http://localhost:8080/hello/hello.html
- 简化部署：将项目打成一个 wa r包，再将 war 包放置到 webapps 目录下。
  - war 包会自动解压缩（访问路径为 war 包的名称）
配置 conf/server.xml 文件
在<Host>标签体中配置<Context docBase=”××××” path=”××××” />
- docBase：项目存放的路径
- path：虚拟目录（即” /工程名 “），访问资源路径：http://ip:port/工程名/资源名
在 conf\Catalina\localhost 创建任意名称的xml文件。在文件中编写]<Context docBase=”D:\hello” />
- 虚拟目录：xml文件的名称 ,访问资源路径：http://ip:port/xml文件名/资源名（热部署，推荐）

注意：

当我们在浏览器地址栏中输入访问地址如下：
http://ip:port/ ====>>>> 没有工程名的时候，默认访问的是 ROOT 工程。
当我们在浏览器地址栏中输入的访问地址如下：
http://ip:port/工程名/ ====>>>> 没有资源名，默认访问 index.html 页面

（4）IDEA 添加 Tomcat 服务器

操作的菜单如下： File | Settings | Build, Execution, Deployment | Application Servers

点击 + 号，选择Tomcat Server，Tomcat Home为 apache-tomcat-8.0.50 的安装路径，之后点击OK即可。

（举例：F:\Program Files\apache-tomcat-8.0.50-windows-x64\apache-tomcat-8.0.50）

之后创建一个Java Enterprice 模块，如果在 Application Server 中可以选择 Tomcat 服务器，即配置成功。

（5）IDEA 中动态 web 工程的操作

① 创建一个新模块，选择 Java Enterprise，注意勾选 Web application。

② 为web工程添加额外jar包

方式一：在 WEB-INF 目录下，创建一个 lib 文件夹，将需要的 jar 包复制到此文件夹下，并 Add as library。
方式二：File->Project Structure->Libraries->点击+，选择 java，添加需要的 jar 包->选择需要用此jar包的模块->apply，接着选择 Artifacts->模块名：war exploded->Fix->add…（将类库，添加到打包部署中）

③ 在 IDEA 中部署工程到 Tomcat 上运行

可以在上方选择 Tomcat 的 Edit Configrations 编辑其属性，如名称、端口号、默认浏览器、url等

右边有启动、Debug 启动和停止。

java动态项目的目录结构：

项目的根目录
- WEB-INF目录：（此目录下的资源不能被浏览器直接访问）
  - web.xml：web项目的核心配置文件
  - classes目录：放置字节码文件的目录
  - lib目录：放置依赖的jar包

三. Servlet

1. 名词解释

Servlet 是运行在服务器上的一个 java 小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。
Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
Servlet 就是一个接口，定义了 Java 类被浏览器访问到（tomcat识别）的规则。
Servlet 的体系结构
- Servlet – 接口
  |
  GenericServlet – 抽象类
  |
  HttpServlet – 抽象类
- GenericServlet：将 Servlet 接口中其他的方法做了默认空实现，只将 service() 方法作为抽象
  - 将来定义 Servlet类时，可以继承 GenericServlet，实现 service() 方法即可
- HttpServlet：对http协议的一种封装，简化操作
  1. 定义类继承 HttpServlet
  2. 复写 doGet/doPost 方法

2. 实现 Servlet 接口实现 Servlet 程序

（1）步骤

① 自定义一个类，实现 Servlet 接口
② 实现接口中的抽象方法，其中 service 方法，用于处理请求，并响应数据
③ 到 web.xml 中去配置 servlet 程序的访问地址

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

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

（2）执行原理

http://localhost:8080/07_servlet/hello

URL	含义
http://	协议
localhost	ip
:8080	端口号
/07_servlet	工程路径
/hello	资源路径

① 当服务器接受到客户端浏览器的请求后，会解析请求 URL 路径，获取访问的 Servlet 的资源路径

② 查找 web.xml 文件，是否有对应的 <url-pattern> 标签体内容。

③ 如果有，则在找到对应的 <servlet-class> 全类名

④ tomcat 会将字节码文件加载进内存(有了全类名，使用反射的方式)，并且创建其对象。

⑤ 调用其方法。

（3）Servlet 中方法的生命周期

作用	方法	调用时间	调用次数
实例化	构造方法	第一次访问请求时	1
初始化	init	构造方法被调用后	1
服务	service	当 client（客户机）访问请求到达时	N（每次访问都会调用）
销毁	destory	server（服务器）关闭时	1

（4）注解配置（了解）

好处：不需要 web.xml 了。
步骤：
1. 创建 JavaEE 项目，选择 Servlet 的版本 3.0 以上，可以不创建 web.xml
2. 定义一个类，实现 Servlet 接口
3. 复写方法
4. 在类上使用@WebServlet注解，进行配置：@WebServlet(“资源路径”)

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {
    String name() default "";//相当于<Servlet-name>
    String[] value() default {};//代表urlPatterns()属性配置
    String[] urlPatterns() default {};//相当于<url-pattern>
    int loadOnStartup() default -1;//相当于<load-on-startup>
    WebInitParam[] initParams() default {};
    boolean asyncSupported() default false;
    String smallIcon() default "";
    String largeIcon() default "";
    String description() default "";
    String displayName() default "";
}

（5）service 方法

service(ServletRequest servletRequest, ServletResponse servletResponse)

服务器创建一个请求对象，处理客户端请求
服务器创建一个响应对象，响应客户端请求
服务器激活 Servlet 的 service() 方法，传递请求和响应对象作为参数
service() 方法获得关于请求对象的信息，处理请求，访问其他资源，获得需要的信息

service 方法是专门用来处理请求和响应的，service() 方法使用响应对象的方法，将响应传回 Server，最终到达客户端。service() 方法可能激活其它方法以处理请求，如 doGet() 或 doPost() 或程序员自己开发的新的方法。

@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws
ServletException, IOException {
	System.out.println("Servlet 被访问了");
    // 类型转换（因为它有 getMethod() 方法）
    HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
    // 获取请求的方式
    String method = httpServletRequest.getMethod();
    if ("GET".equals(method)) {
    	doGet();
    } else if ("POST".equals(method)) {
    	doPost();
    }
}
//做 get 请求的操作
public void doGet(){
    System.out.println("处理get请求");
}
//做 post 请求的操作
public void doPost(){
    System.out.println("处理post请求");
}

3. 继承 HttpServlet 方法实现 Servlet 程序

一般在实际项目开发中，都是使用继承 HttpServlet 类的方式去实现 Servlet 程序。

（1）步骤

① 自定义一个类，去继承 HttpServlet 类
② 根据业务需要重写 doGet 或 doPost 方法
③ 到 web.xml 中的配置 Servlet 程序的访问地址**

public class HttpServletTest extends HttpServlet {
    //重写doGet方法
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("处理get请求");
    }

    //重写doPost方法
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("处理Post请求");
    }
}

（2）使用IDEA自动创建

① 在包下，右键 New

② 选择 Create New Sevlet

③ 写类名，并将下方的使用注解的方式不勾选（当然也可以使用注解）

此时就创建了一个类，并且重写了 doGet 和 doPost 方法，注意还要去修改 web.xml 文件

4. ServletConfig 类

说明：

ServletConfig 类是 Servlet 程序的配置信息类。
Servlet 程序和 ServletConfig 对象都是由 Tomcat 负责创建，我们负责使用。
每个 Servlet 程序创建时，ServletConfig就创建一个对应的 ServletConfig 对象。也可以使用this.getservletconfig()。

作用：

获取 Servlet 名称 getServletName()
获取 Servlet 初始化参数 getInitParameter() /getInitParameterNames()
获取 ServletContext 对象：域对象

初始化参数的配置文件：

在 web.xml 文件中我们可以对 servlet 进行配置，在 <servlet> 配置标签内可以有以下这样的子标签：

<!--init-param 是初始化参数 -->
<init-param>
    <param-name>参数名</param-name>
    <param-value>参数值</param-value>
</init-param>

方法：

方法	说明
String getServletName()	获取在web应用程序中部署的servlet实例的名称
String getInitParameter(String name)	获取包含指定初始化参数的值的String,如果不存在，返回null
Enumeration getInitParameterNames()	以 String 对象的 Enumeration 的形式返回 servlet 的初始化参数的名称
ServletContext getServletContext()	返回对调用者在其中执行操作的 ServletContext 的引用。

//举例
@Override
public void init(ServletConfig config) throws ServletException {
    super.init(config);
    String servletName = config.getServletName();
    String username = config.getInitParameter("username");
    System.out.println("Servlet程序名称为：" + servletName);//Servlet程序名称为：HttpSevletTest
    System.out.println("初始化参数username的值是：" + username);//初始化参数username的值是：root
}

@Override
public void init() throws ServletException {
    super.init();
    String servletName = this.getServletConfig().getServletName();
    String username = this.getServletConfig().getInitParameter("username");
    System.out.println("Servlet程序名称为：" + servletName);//Servlet程序名称为：HttpSevletTest
    System.out.println("初始化参数username的值是：" + username);//初始化参数username的值是：root
}

5. ServletContext 类

说明：

ServletContext 是一个接口，它表示 Servlet 上下文对象
一个 web 工程，只有一个 ServletContext 对象实例。
ServletContext 对象是一个域对象（可以像 Map 一样存取数据的对象。这里的域指的是存取数据的操作范围，整个 web 工程。）
ServletContext 是在 web 工程部署启动的时候创建。

作用：

获取 WEB 应用的初始化参数。（获取 web.xml 中配置的上下文参数 context-param）
获取当前的工程路径，格式: /工程路径
获取工程部署后在服务器硬盘上的绝对路径
实现资源的共享（可以共享所有用户所有请求的数据）。（多个 Servlet 通过 ServletContext 对象数据共享）

获取 servletContext 对象：

this.getServletConfig.getServletContext()
this.getServletContext()
request.getServletContext()

方法：

方法	说明
void setAttribute(String name, Object obj);	添加属性
Object getAttribute(String name)	获取属性值，这个方法返回Object
void removeAttribute(String name)	删除属性
String getRealPath(String path)	返回资源文件在服务器文件系统上的真实路径（文件的绝对路径）。参数 path 代表资源文件的虚拟路径，以 / 开始，/ 表示当前 Web 应用的根目录
String getInitParameter(String name)	获取Tomcat的初始化参数（上下文参数）

上下文参数的配置文件：

在 web.xml 文件中我们可以对 servlet 进行配置，在 <web-app> 配置标签内可以有以下这样的子标签：

<!--context-param 是上下文参数 ( 它属于整个 web 工程 )-->
<context-param>
	<param-name>参数名</param-name>
	<param-value>参数值</param-value>
</context-param>

注意：通过S ervletCintext 对象添加的属性，在全局内可以共享，即多个 Servlet 通过 ServletContext 对象数据共享。

public class HttpServletTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取ServletContext对象
        ServletContext servletContext = this.getServletConfig().getServletContext();
        // 添加属性
        servletContext.setAttribute("password","123");
        servletContext.setAttribute("key","value");
        // 获取属性
        Object password = servletContext.getAttribute("password");
        Object key = servletContext.getAttribute("key");
        System.out.println("password:" + password);//password:123
        System.out.println("key:" + key);//key:value
        System.out.println(servletContext.getInitParameter("name"));
        // 删除属性
        servletContext.removeAttribute("key");
        // 获取绝对路径(/ 斜杠被服务器解析地址为 :http://ip:port/ 工程名 / 映射到 IDEA 代码的 web 目录 <br/>)
        String realPath = servletContext.getRealPath("/");
        System.out.println(realPath);// D:\IDEA_JAVA\JavaWeb\out\artifacts\07_serlvet_war_exploded\
    }
}

public class HttpServletTest1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletConfig().getServletContext();
        System.out.println(servletContext.getAttribute("password"));// 123，实现了资源的共享
    }
}

6. HTTP 协议

（1）概念

Hyper Text Transfer Protocol 超文本传输协议（传输协议：定义了，客户端和服务器端通信时，发送数据的格式）

（2）特点

基于 TCP/IP 的高级协议
默认端口号：80
基于请求/响应模型的：一次请求对应一次响应
无状态的：每次请求之间相互独立，不能交互数据

（3）请求消息数据格式

HTTP 有 7 种请求方式，常用的是 GET 和 POST 请求。

GET 请求

1）请求行：包含三部分内容

① 请求的方式：GET
② 请求的资源路径[+?+请求参数]
③ 请求的协议的版本号： HTTP/1.1

举例：GET /07_servlet/ HTTP/1.1

2）请求头：客户端浏览器告诉服务器一些信息，由不同的键值对组成。

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

举例：

Accept-Language: zh-CN,zh;q=0.9
POST 请求

1）请求行

① 请求的方式： POST

② 请求的资源路径[+?+请求参数]

③ 请求的协议的版本号：HTTP/1.1

举例：POST /07_servlet/hello1 HTTP/1.1

2）请求头：客户端浏览器告诉服务器一些信息，由不同的键值对组成。
3）请求空行：就是用于分割POST请求的请求头，和请求体的。
4）请求体（正文）：就是发送给服务器的数据（封装POST请求消息的请求参数的,比如username=123&password=123）

区别：

请求方式	GET	POST
安全性	不安全	相对安全
url长度	有限制	无限制
请求参数	请求参数在请求行中，在url后。	请求参数在请求体中
常见情景	1、form 标签 method=get 2、a 标签 3、link 标签引入 css 4、Script 标签引入 js 文件 5、img 标签引入图片 6、iframe 引入 html 页面 7、在浏览器地址栏中输入地址后敲回车	form 标签 method=pos

（4）响应消息数据格式

响应行
① 响应的协议和版本号 HTTP/1.1

② 响应状态码
- 1xx：消息。服务器接收客户端消息，但没有接收完成，等待一段时间后，发送1xx多状态码
- 2xx：成功。比如200 表示请求成功
- 3xx：重定向。比如302 表示请求重定向，304表示访问缓存
- 4xx：客户端错误。比如404 表示请求服务器已经收到了，但是你要的数据不存在（请求地址错误），405一般表示请求方式错误
- 5xx：服务器端错误。比如500 表示服务器已经收到请求，但是服务器内部错误（代码错误）
③ 响应状态描述符

举例：HTTP/1.1 200 OK
响应头：key : value 不同的响应头，有其不同含义
空行
响应体（正文）：就是回传给客户端的数据

（5）MIME 类型说明

MIME 是 HTTP 协议中数据类型，全称是”Multipurpose Internet Mail Extensions” 多功能 Internet 邮件扩充服务。MIME 类型的格式是“大类型/小类型”，并与某一种文件的扩展名相对应。

类型	描述	典型示例
`text`	表明文件是普通文本，理论上是人类可读	普通文本：`text/plain`, 超文本标记语言文本:`text/html`, `text/css,` `text/javascript`…
`image`	表明是某种图像。不包括视频，但是动态图（比如动态gif）也使用image类型	GIF图像：`image/gif` `image/png`, `image/jpeg`….
`audio`	表明是某种音频文件	`audio/midi`, `audio/mpeg, audio/webm, audio/wav`…
`video`	表明是某种视频文件	`video/webm`, `video/ogg`
`application`	表明是某种二进制数据	`application/vnd.mspowerpoint`,`application/xml`, `application/pdf`…

7. HttpServletRequest 类

作用：

每次只要有请求进入 Tomcat 服务器，Tomcat 服务器就会把请求过来的 HTTP 协议信息解析好封装到 Request 对象中。然后传递到 service 方法（doGet 和 doPost）中给我们使用。我们可以通过 HttpServletRequest 对象，获取到所有请求的信息。service 方法中的 request 的类型是 ServletRequest，而 doGet/doPost 方法的request 的类型是 HttpServletRequest，HttpServletRequest 是 ServletRequest 的子接口，功能和方法更加强大。

HttpServletRequest对象代表客户端的请求，当客户端通过HTTP协议访问服务器时，HTTP请求头中的所有信息都封装在这个对象中。

request对象继承体系结构：
ServletRequest – 接口
| 继承
HttpServletRequest – 接口
| 实现
org.apache.catalina.connector.RequestFacade 类(tomcat)

常用方法：

方法	说明
getMethod()	获取请求的方式 GET 或 POST
getContextPath()	获取请求的工程路径（/工程名）（动态获取工程路径）
getRequestURI()	获取请求的资源路径（统一资源标识符）（/工程名/资源名）
getRequestURL()	获取请求的统一资源定位符（绝对路径 http://ip:port/工程名/资源名）
getRemoteHost()	获取客户端的 ip 地址
getHeader(String name)	获取请求头
getParameter(string name)	获取请求的参数
getParameterValues(string name)	获取请求的参数（多个值的时候使用，比如表单的复选框）
setAttribute(key, value)	设置域数据
getAttribute(key)	获取域数据
removeAttribute(key)	删除域数据
getRequestDispatcher()	获取请求转发对象
setcharacterEncoding(“UTF-8”)	中文转码
getServletContext()	获取ServletContext对象

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 获取请求方法
        String method = request.getMethod();
        System.out.println("请求方式：" + method);//请求方式：GET
        // 获取资源路径
        System.out.println("资源路径：" + request.getRequestURI());//资源路径：/07_servlet/servlet1111
        // 获取绝对路径
        System.out.println("URL：" + request.getRequestURL());//URL：http://localhost:8080/07_servlet/servlet1111
        // 获取客户端ip地址
        System.out.println("客户端ip地址：" + request.getRemoteHost());//客户端ip地址：127.0.0.1
        // 获取请求头
        System.out.println("Host：" + request.getHeader("Host"));//Host：localhost:8080
        // 获取请求体
        System.out.println("用户名：" + request.getParameter("username"));//用户名：张三
        String[] hobbies = request.getParameterValues("hobby");
        System.out.println("兴趣爱好："+ Arrays.asList(hobbies) );//兴趣爱好：[java, Python]
    }

注意中文乱码问题：
get 方式：tomcat 8 已经将 get 方式乱码问题解决了
post 方式：仍会乱码，解决方法是在获取参数前，设置 request 的编码 request.setCharacterEncoding(“utf-8”);

请求转发：

请求转发是指，一个 web 资源收到客户端请求后，通知服务器去调用另外一个 web 资源进行处理。

步骤：
- 通过 request 对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
- 使用 RequestDispatcher 对象来进行转发：forward(ServletRequest request, ServletResponse response)
特点：
- 浏览器地址栏路径不发生变化（因为是在服务端实现的）
- 只能转发到当前服务器内部资源中，不可访问工程以外的资源
- 转发是一次请求，可以使用 request 对象来共享数据
- 可以转发到 WEB-INF 目录下

域对象：一个有作用范围的对象，可以在范围内共享数据

request 域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据。

public class Servlet1 extends HttpServletTest {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 请求转发必须要以斜杠打头， / 斜杠表示地址为： http://ip:port/ 工程名 / , 映射到 IDEA 代码的web目录
        RequestDispatcher requestDispatcher = req.getRequestDispatcher("/servlet2");
        requestDispatcher.forward(req,resp);
    }
}

public class Servlet2 extends HttpServletTest {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("在转发后的程序中处理");
    }
}

绝对路径和相对路径：

在 javaWeb 中，路径分为相对路径和绝对路径两种：

相对路径：
- ./表示当前目录（./可以省略不写）
- ../表示上一级目录
- 资源名表示当前目录/资源名
绝对路径：http://ip:port/工程路径/资源路径

在 web 中 / 斜杠是一种绝对路径。

/ 斜杠如果被浏览器解析，得到的地址是：http://ip:port/

response.sendRediect(“/”); 把斜杠发送给浏览器解析。得到 http://ip:port/

建议工程路径动态获取，使用 request.getContextPath()

response.sendRediect(request.getContextPath() + “/资源名”)
/ 斜杠如果被服务器解析，得到的地址是：http://ip:port/工程路径/

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

8. HttpServletResponse 类

作用:

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

HttpServletResponse是对服务器的响应对象。这个对象中封装了向客户端发送数据、发送响应头，发送响应状态码的方法。

常用方法：

方法	说明
getOutputStream()	用于返回 Servlet 引擎创建的字节输出流对象，Servlet 程序可以按字节形式输出响应正文。常用于下载（传递二进制数据）
getWriter()	用于返回 Servlet 引擎创建的字符输出流对象，Servlet 程序可以按字符形式输出响应正文。常用于回传字符串（常用）
addHeader(String name,String value)	该方法是设置有多个值的响应头,参数 name 表示响应头名称,参数 value 表示响应头的值
setStatus(int value)	设置临时定向响应码
setHeader(String name,String value)	该方法是设置只有一个值的响应头,参数 name 表示响应头名称,参数value表示响应头的值
setContentType(“text/html; charset=UTF-8”);	同时设置服务器和客户端都使用 UTF-8 字符集，解决中文乱码问题

注意：getOutputStream() 和 getWriter() 这两个方法互相排斥，调用了其中的任何一个方法后，就不能再调用另一方法。

//向客户端回传数据
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码问题
//        方式一：
//        resp.setCharacterEncoding("UTF-8");//设置服务器字符集为 UTF-8
//        resp.setHeader("Content-Type","text/html;UTF-8");//通过响应头，设置浏览器也使用 UTF-8 字符集
//        方式二：【推荐】同时设置服务器和客户端都使用 UTF-8 字符集，还设置了响应头
        resp.setContentType("text/html; charset=UTF-8");// 此方法一定要在获取流对象之前调用才有效
        PrintWriter writer = resp.getWriter();
        writer.write("回传给客户端的数据".toCharArray());
        writer.close();
    }

请求重定向：

重定向指的是一个 web 资源收到客户端请求后，web 服务器通知客户端去访问另外一个web资源。（可能之前的地址已经被废弃）

实现的原理就是给客户端返回了 302 状态码和 location 头。

步骤：
方式一：
- 设置状态码为 302。 response.setStatus(302);
- 设置响应头 location。 response.setHeader(“location”,”新的地址”);：
方式二【推荐】：response.sendRedirect("新的地址");

特点:
- 地址栏发生变化（因为是在客户端实现的）
- 重定向可以访问其他站点(服务器)的资源
- 重定向是两次请求。不能使用 request 对象来共享数据。

转发 forward 和重定向 Redirect 的区别

	转发	重定向
浏览器URL地址	转发是在服务器端实现的。所以请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。	而重定向是在客户端实现的。所以调用重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL 地址变成重定向的目标 URL。
访问资源范围	只能将请求转发给同一个WEB应用中的其他资源；	还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。
请求次数	forward 方法的调用者与被调用者之间共享相同的 request 对象和 response 对象，它们属于同一个访问请求和响应过程；	sendRedirect方法调用者与被调用者使用各自的 request 对象和 response 对象，它们属于两个独立的访问请求和响应过程。也就是说，重定向生成了新的 request 对象和 response对象。
客户端是否可见	forward 方法在服务器端将请求转发给另外一个资源，相当过程于对客户端不可见。	sendRedirect 方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个 URL 的访问请求

四. 文件上传与下载

1. 文件上传

文件上传主要是将文件通过 IO 流传放到服务器的某一个特定的文件夹下。（就是将客户端的数据发送到服务器上的操作）

（1）HTML 页面

<form action="链接" method="post"  enctype="multipart/form-data" >
<!--
（表单要求） 
1.设置enctype="multipart/form-data"，它不对字符进行编码，用于发送二进制的文件（即所有文件类型，如视频、图片、音乐、文档都可以用此类型entype）。
2.请求方式必须为post。
3.需要提供文件上传框(组件) <input type="file">
-->
    
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    
<form action="/08_upload&download/upload" method="post"  enctype="multipart/form-data" >
    用户名：<input type="text" name="username"><br/>
    <br/>
    头像：<input type="file" name="uploadpicture"><br/>
    <br/>
    <input type="submit" value="上传头像">
</form>
    
</body>
</html>

（2）导入 jar 包

需要导入两个 jar 包（commons-fileupload-1.2.1.jar、commons-io-1.4.jar）核心类有：

DiskFileItemFactory：创建 FileItem 对象的工厂

ServletFileUpload：用于解析上传的数据，并将表单中每个输入项封装成一个FileItem 对象中。常用方法有：

boolean isMultipartContent(HttpServletRequest request)：判断上传表单是否为multipart/form-data类型
List parseRequest(HttpServletRequest request：解析request对象，并把表单中的每一个输入项包装成一个fileItem 对象，并返回一个保存了所有FileItem的list集合。

FileItem：表示每一个表单项，常用方法有：

String getFieldName()：用于返回表单标签name属性值。
String getName()：用于获得文件上传字段中的文件名。
String getString()：获取字段的内容。如果是普通字段，则是它的value值；如果是文件字段，则是文件内容。
String getContentType()：获取上传的文件类型，例如text/plain、image。如果是普通字段，则返回null。
long getSize()：获取字段内容的大小，单位是字节。
boolean isFormField()：判断是否是普通表单字段，若是，返回true，否则返回false(即上传的是文件类型)。
InputStream getInputStream()：获得文件内容的输入流。如果是普通字段，则返回value值的输入流。
void write( file )：将上传的文件写到参数 file 所指向抽硬盘位置。

（3）Servlet页面

实现步骤：

创建一个 DiskFileItemFactory工厂，DiskFileItemFactory 工厂名= new DiskFileItemFactory();
创建文件上传解析器，ServletFileUpload 解析器名 = new ServletFileUpload(factory);
使用解析器解析request对象，调用parseRequest方法解析request对象，得到一个保存了所有上传内容的List对象。

对list进行迭代，每迭代一个FileItem对象，调用其isFormField方法判断是否是上传文件：

如果为普通表单字段，则调用getFieldName()、getString()方法得到字段名和字段值。
如果为上传文件，则调用write( file)方法将上传数据写入磁盘

注意：中文乱码问题解决：

文件名中文乱码处理：解析器名.setHeaderEncoding(“utf-8”) 或 request.setCharacterEncoding(“utf-8”);
表单普通字段中文乱码处理：FileItem.getString(“utf-8”);

public class Upload extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        1.创建工厂类：
        DiskFileItemFactory factory = new DiskFileItemFactory();
//        2.创建解析器：
        ServletFileUpload upload = new ServletFileUpload(factory);
        	//解决上传文件名的中文乱码                       
            upload.setHeaderEncoding("UTF-8")
        try {
//           3.使用解析器解析request对象：
            List<FileItem> list = upload.parseRequest(req);
//           4.遍历
            for (FileItem fileItem : list) {
                //判断是否是普通表单字段，若是，返回true，否则返回false。
                if (fileItem.isFormField()) {
                    System.out.println(fileItem.getFieldName());//获取表单项的name的属性值。
                    System.out.println(fileItem.getString("utf-8"));//获取字段的内容。如果是普通字段，则是它的value值；如果是文件字段，则是文件内容。
                } else {
                    if (fileItem.getName() != "") {//获取文件字段的文件名,如果没有上传，则返回空串。
                        //将文件写入指定磁盘
                       fileItem.write(new File("D:\\IDEA_JAVA\\JavaWeb\\08_upload&download\\b.jpg"));
                    } else {
                       System.out.println("没有上传文件");
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 文件下载

文件下载主要是将文件从服务器的特定的文件夹下的文件通过 IO 流下载到本地。（就是将服务器的数据下载到客户端上的操作）

步骤：

设置响应头信息，告诉客户端收到的数据是用于下载使用(如果不设置，文件会直接在页面显示，而不是下载)

Content-Disposition 响应头，表示收到的数据怎么处理
attachment 表示附件，表示下载使用
filename 表示指定下载的文件名（此名字只是用户下载后显示的名字，可以与服务器文件的名字不一样）

示例：resp.setHeader(“Content-Disposition”, “attachment; filename=” + “指定所下载文件的名称”);

注意：为了解决中文乱码问题，可以将上面示例改为：

resp.setHeader(“Content-Disposition”, “attachment; filename=” + URLEncoder.encode(“指定所下载文件的名称”, “UTF-8”));
获取文件输入流

示例：InputStream inputStream = new FileInputStream(new File(“文件路径”));
获取响应输出流

示例：OutputStream outputStream = resp.getOutputStream();
将文件回传到客户端（即实现文件的复制）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
	<a href="/08_upload&download/download" name="filename">下载图片</a>
</body>
</html>

public class Download extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1、设置响应头信息
        resp.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode("随便", "UTF-8"));
        //2.获取文件输入流
        InputStream resourceAsStream = this.getServletContext().getResourceAsStream("/" + a.jpg);
//        InputStream inputStream = new FileInputStream(new File("D:\\IDEA_JAVA\\JavaWeb\\08_upload&download\\b.jpg"));
        //3.获取响应的输出流
        OutputStream outputStream = resp.getOutputStream();
        //4 、把文件内容回传给客户端
        byte[] bytes = new byte[1024];
        int len;
        while ((len = inputStream.read(bytes)) != -1) {
            outputStream.write(bytes, 0, len);
        }
    }
}

五. JSP

JSP全名为Java Server Pages，即 java 服务器页面。JSP 是⼀种基于⽂本的程序，其特点就是 HTML 和 Java 代码共同存在！Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高，而 jsp 的主要作用就是代替 Servlet 程序回传 html 页面的数据。

jsp 页面本质上是一个 Servlet 程序。
当我们第一次访问 jsp 页面的时候。Tomcat 服务器会帮我们把 jsp 页面翻译成为一个 java 源文件。并且对它进行编译成为.class 字节码程序。而java源文件中的类间接的继承了 HttpServlet 类。

1. jsp 的语法

（1）指令

作用：用于配置JSP页面，导入资源文件
格式：<%@ 指令名称属性名1=属性值1 属性名2=属性值2 … %>
分类：

page：配置JSP页面
- <%@ page contentType=”text/html;charset=UTF-8” language=”java” %>
- contentType：等同于response.setContentType()
  1. 设置响应体的mime类型以及字符集
  2. 设置当前jsp页面的编码（只能是高级的IDE才能生效，如果使用低级工具，则需要设置pageEncoding属性设置当前页面的字符集）
- import：导包
- errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
- isErrorPage：标识当前也是是否是错误页面。
  - true：是，可以使用内置对象exception
  - false：否。默认值。不可以使用内置对象exception
include：页面包含的。导入页面的资源文件
- <%@include file=”top.jsp”%>
taglib：导入资源
- <%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core" %>
- prefix：前缀，自定义的

（2）注释

html注释：:只能注释html代码片段
jsp注释：推荐使用
<%– –%>：可以注释所有

（3）脚本

<% java语句 %>（代码脚本）【定义局部变量，编写语句】
- 代码脚本翻译之后都在_jspService 方法中
- 代码脚本由于翻译到_jspService()方法中，所以在jspService()方法中的现有对象都可以直接使用。
- 可以由多个代码脚本块组合完成一个完整的 java 语句。
- java语句会在控制台输出。
- 如果没有<% %>，则会被认为是html文本，输出到页面上。
<%!声明java代码 %>（声明脚本）【定义类或⽅法，但是没⼈这样⽤！】
<%=表达式 %>（表达式脚本）【输出各种类型的变量，int、double、String、Object等】
- 表达式结果会在html页面上展示。
- 所有的表达式脚本都会被翻译到_jspService() 方法中_
- 表达式脚本都会被翻译成为 out.print()输出到页面上
- 由于表达式脚本翻译的内容都在_jspService() 方法中,所以jspService()方法中的对象都可以直接使用。
- 表达式脚本中的表达式不能以分号结束。

2. jsp 内置对象

JSP 的内置对象即：在jsp页面中不需要获取和创建，可以直接使用的对象

变量名	真实类型	作用
pageContext	PageContext	当前页面共享数据，还可以获取其他八个内置对象
request	HttpServletRequest	一次请求访问的多个资源(转发)
session	HttpSession	一次会话的多个请求间
application	ServletContext	所有用户间共享数据
response	HttpServletResponse	响应对象
page	Object	当前页面(Servlet)的对象 this
out	JspWriter	输出对象，数据输出到页面上
config	ServletConfig	Servlet的配置对象
exception	Throwable	异常对象

3. jsp 域对象

jsp的九大内置对象中有四个域对象：pageContext、request、session、application。

它们从小到大的顺序分别是：pageContext 、Request、Session 、application

使用的优先顺序是从小到大：pageContext 、Request、Session 、application

out和Response输出的区别。
out输出都写到out缓冲区中，response输出都写到Respnse的缓冲区中

response.getWriter()数据输出永远在out.write()之前

当jsp页面中所有代码都执行完成之后。全做以下两个操作
1、执行out.flush()操作，把out缓冲区中的数据都追加到Response缓冲区中
2、执行Response的flush()操作。把Response缓冲区中的数据，都写给客户端。

在jsp页面中，统一使用out来进行输出。

out.write()可以输出字符串
out.print()可以输出任意数据

4. EL 表达式

（1）概念：Expression Language 表达式语言

（2）作用：代替 jsp 页面中的表达式脚本在 jsp 页面中进行数据的输出。因为 EL 表达式在输出数据时比 jsp 的表达式脚本要简洁很多。

（3）语法：${表达式}

1
2
3

注意：jsp默认支持el表达式的。如果要忽略el表达式
方式一：设置jsp中page指令中：isELIgnored="true" 忽略当前jsp页面中所有的el表达式
方式二：\${表达式} ：忽略当前这个el表达式

（4）使用：

运算

算数运算符： + - * / %

比较运算符： > < >= <= == !=

逻辑运算符： &&(and) ||(or) !(not)

空运算符： empty（用于判断字符串、集合、数组对象是否为null或者长度是否为0）

举例：${empty list}:判断字符串、集合、数组对象是否为null或者长度为0

获取值（EL表达式只能从域对象中获取值）

① ${域名称.键名}：从指定域中获取指定键的值

域名称：

pageScope –> pageContext

requestScope –> request

sessionScope –> session

applicationScope –> application（ServletContext）

举例：在request域中存储了name=张三，获取值：${requestScope.name}
②${键名}：表示依次从最小的域中查找是否有该键对应的值，直到找到为止。

③获取对象、List集合、Map集合的值

1
2
3

对象：${域名称.键名.属性名}（本质上会去调用对象的getter方法）
List集合：${域名称.键名[索引]}
Map集合：${域名称.键名.key名称}、${域名称.键名["key名称"]}

隐式对象：（EL表达式中有11个隐式对象）
1. pageContext 对应于JSP⻚⾯中的pageContext对象（注意：取的是pageContext对象）
2. pageScope 代表page域中⽤于保存属性的Map对象
3. requestScope 代表request域中⽤于保存属性的Map对象
4. sessionScope 代表session域中⽤于保存属性的Map对象
5. applicationScope 代表application域中⽤于保存属性的Map对象
6. param 表示⼀个保存了所有请求参数的Map对象
7. paramValues表示⼀个保存了所有请求参数的Map对象，它对于某个请求参数，返回的是⼀个string[]
8. header 表示⼀个保存了所有http请求头字段的Map对象
9. headerValues同上，返回string[]数组。
10. cookie 表示⼀个保存了所有cookie的Map对象
11. initParam 表示⼀个保存了所有web应⽤初始化参数的map对象

5. JSTL 标签

（1）概念：JavaServer Pages Tag Library JSP标准标签库（是由Apache组织提供的开源的免费的jsp标签）

（2）作用：EL 表达式主要是为了替换 jsp 中的表达式脚本，而标签库则是为了替换代码脚本。

（3）使用步骤：

①导入jstl相关jar包

②引入标签库：taglib指令： <%@ taglib %>

③使用标签

（4）常用的JSTL标签

<c:if />:相当于java代码的if语句
- 属性：
  
  test 必须属性，接受boolean表达式，如果表达式为true，则显示if标签体内容，如果为false，则不显示标签体内容
  
  一般情况下，test属性值会结合el表达式一起使用
- 注意：c:if标签没有else情况，想要else情况，则可以在定义一个c:if标签
< c:choose> < c:when> < c:otherwise>:相当于java代码的switch语句
- 使用choose标签声明相当于switch声明
- 使用when标签做判断相当于case
- 使用otherwise标签做其他情况的声明相当于default
<c:forEach />:相当于java代码的for语句
1. 完成重复的操作
  for(int i = 0; i < 10; i ++){}
  - 属性：
    begin：开始值
    end：结束值
    var：临时变量
    step：步长
    varStatus:循环状态对象
    index:容器中元素的索引，从0开始
    count:循环次数，从1开始
2. 遍历容器
  List<User> list;
  for(User user : list){}
  - 属性：
    items:容器对象
    var:容器中元素的临时变量
    varStatus:循环状态对象
    index:容器中元素的索引，从0开始
    count:循环次数，从1开始

六. Listener

1. 概念

web 的三大组件之一。（JavaWeb 的三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。）

Listener 它是 JavaEE 的规范，就是接口。

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

2. 事件监听机制

事件：一件事情

事件源：事件发生的地方

监听器：一个对象

注册监听：将事件、事件源、监听器绑定在一起。当事件源上发生某个事件后，执行监听器代码

3. ServletContextListener 监听器

ServletContextListener 它可以监听 ServletContext 对象的创建和销毁。

ServletContext 对象在 web 工程启动的时候创建，在 web 工程停止的时候销毁。

监听到创建和销毁之后都会分别调用 ServletContextListener 监听器的方法反馈。

方法：
- void contextDestroyed(ServletContextEvent sce) ：ServletContext对象被销毁之前会调用该方法
- void contextInitialized(ServletContextEvent sce) ：ServletContext对象创建后会调用该方法

步骤：

定义一个类，实现 ServletContextListener 接口

实现其两个回调方法

public class MyServletContextListenerImpl implements ServletContextListener {
	@Override
	public void contextInitialized(ServletContextEvent sce) {
		System.out.println("ServletContext 对象被创建了");
	}
	@Override
	public void contextDestroyed(ServletContextEvent sce) {
	System.out.println("ServletContext 对象被销毁了");
	}
}

配置

方式一：web.xml

<!-- 配置监听器 -->
<listener>
	<listener-class>全类名</listener-class>
</listener>

方式二：注解：@WebListener

1. 名词解释

概念：Cookie 是客户端会话技术，用于将数据保存到客户端，客户端有了 Cookie 后，每次请求都会将此 Cookie 中数据发送给服务器。浏览器对于单个cookie 的大小有限制(4kb) 以及对同一个域名下的总 cookie 数量也有限制(20个)

作用：Cookie 可以在不登录的情况下，完成服务器对客户端的身份识别，比如用户在第二次登录一个页面时，可以记住用户的账号、密码等，用户就无需重新输入。

就像我们去超市买东西，没有积分卡的情况下，我们买完东西之后，超市没有我们的任何消费信息，但我们办了积分卡之后，超市就有了

我们的消费信息。cookie 就像是积分卡，可以保存积分，商品就是我们的信息，超市的系统就像服务器后台，http协议就是交易的过程。

2. 基本使用

创建 Cookie 对象，绑定数据 new Cookie(String name, String value)
发送 Cookie 对象 response.addCookie(Cookie cookie)
获取 Cookie，拿到数据 Cookie[] request.getCookies()

注意：一次可以创建多个 Cookie 对象，使用 response 调用多次 addCookie 方法发送 cookie 即可。

@WebServlet("/cookieDemo1")
public class CookieDemo1 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.创建Cookie对象
        Cookie c = new Cookie("msg","hello");
        //2.发送Cookie
        response.addCookie(c);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

@WebServlet("/cookieDemo2")
public class CookieDemo2 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //3. 获取Cookie
        Cookie[] cs = request.getCookies();
        //获取数据，遍历Cookies
        if(cs != null){
            for (Cookie c : cs) {
                String name = c.getName();
                String value = c.getValue();
                System.out.println(name+":"+value);
            }
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

//先访问cookieDemo1，再访问cookieDemo2，可以获取cookieDemo1设置的cookie信息。

cookie 在浏览器中保存时间：

默认情况下，当浏览器关闭后，Cookie 数据被销毁
持久化存储：setMaxAge(int seconds)
1. 正数：将 Cookie 数据写到硬盘的文件中。持久化存储。并指定 cookie 存活时间，时间到后，cookie 文件自动失效
2. 负数：默认值
3. 零：删除 cookie 信息

八. Session

概念：服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession
快速入门：
获取 HttpSession 对象：

HttpSession session = request.getSession();
1. 使用HttpSession对象：
- Object getAttribute(String name)
- void setAttribute(String name, Object value)
- void removeAttribute(String name)
原理

Session 的实现是依赖于 Cookie 的。

细节：
- 当客户端关闭后，服务器不关闭，两次获取 session 是否为同一个？
  - 默认情况下。不是。
  - 如果需要相同，则可以创建 Cookie，键为 JSESSIONID，设置最大存活时间，让 cookie 持久化保存。
    1
    2
    3
    Cookie c = new Cookie("JSESSIONID",session.getId());
    c.setMaxAge(60*60);
    response.addCookie(c);
- 客户端不关闭，服务器关闭后，两次获取的 session 是同一个吗？
  - 不是同一个，但是要确保数据不丢失。tomcat 自动完成以下工作
    - session 的钝化：
      - 在服务器正常关闭之前，将session对象系列化到硬盘上
    - session 的活化：
      - 在服务器启动后，将 session 文件转化为内存中的 session 对象即可。
- session 什么时候被销毁？
  1. 服务器关闭
  2. session 对象调用 invalidate() 。
  3. session 默认失效时间 30分钟
    选择性配置修改
    1
    2
    3
    <session-config>
    <session-timeout>30</session-timeout>
    </session-config>
session 的特点
1. session 用于存储一次会话的多次请求的数据，存在服务器端
2. session 可以存储任意类型，任意大小的数据
session 与 Cookie 的区别：
session存储数据在服务器端，Cookie在客户端
session 没有数据大小限制，Cookie有
session 数据安全，Cookie相对于不安全

九. Filter

概念：

生活中的过滤器：净水器,空气净化器，土匪、
web中的过滤器：当访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能。
过滤器的作用：一般用于完成通用的操作。如：登录验证、统一编码处理、敏感字符过滤…

快速入门：

步骤：
- 定义一个类，实现接口 Filter
- 复写方法
- 配置拦截路径使用web.xml / 注解

代码：

@WebFilter("/*")//访问所有资源之前，都会执行该过滤器
public class FilterDemo1 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
	}

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    	 System.out.println("filterDemo1被执行了....");
      	 //放行
		 filterChain.doFilter(servletRequest,servletResponse);	
	}
		
    @Override
    public void destroy() {
	}
}

过滤器细节：

web.xml配置

<filter>
     <filter-name>demo1</filter-name>
     <filter-class>cn.itcast.web.filter.FilterDemo1</filter-class>
 </filter>
 <filter-mapping>
     <filter-name>demo1</filter-name>
	<!-- 拦截路径 -->
     <url-pattern>/*</url-pattern>
 </filter-mapping>

过滤器执行流程
1. 执行过滤器
2. 执行放行后的资源
3. 回来执行过滤器放行代码下边的代码
过滤器生命周期方法
- init：在服务器启动后，会创建Filter对象，然后调用init方法。只执行一次。用于加载资源
- doFilter：每一次请求被拦截资源时，会执行。执行多次
- destroy：在服务器关闭后，Filter对象被销毁。如果服务器是正常关闭，则会执行destroy方法。只执行一次。用于释放资源
过滤器配置详解
- 拦截路径配置：
  1. 具体资源路径： /index.jsp 只有访问index.jsp资源时，过滤器才会被执行
  2. 拦截目录： /user/* 访问/user下的所有资源时，过滤器都会被执行
  3. 后缀名拦截： *.jsp 访问所有后缀名为jsp资源时，过滤器都会被执行
  4. 拦截所有资源：/* 访问所有资源时，过滤器都会被执行
- 拦截方式配置：资源被访问的方式
  - 注解配置：
    
    设置 dispatcherTypes 属性
    1. REQUEST：默认值。浏览器直接请求资源
    2. FORWARD：转发访问资源
    3. INCLUDE：包含访问资源
    4. ERROR：错误跳转资源
    5. ASYNC：异步访问资源
  - web.xml 配置
    
    设置<dispatcher></dispatcher>标签即可
过滤器链(配置多个过滤器)
- 执行顺序：如果有两个过滤器：过滤器1和过滤器2
  
  过滤器1–>过滤器2–>资源执行–>过滤器2–>过滤器1
- 过滤器先后顺序问题：
  - 注解配置：按照类名的字符串比较规则比较，值小的先执行
    - 如： AFilter 和 BFilter，AFilter就先执行了。
  - web.xml配置： <filter-mapping>谁定义在上边，谁先执行

十. AJAX

1. 概念

ASynchronous JavaScript And XML：异步的 JavaScript 和 XML

异步和同步：客户端和服务器端相互通信的基础上

同步：客户端必须等待服务器端的响应。在等待的期间客户端不能做其他操作。
异步：客户端不需要等待服务器端的响应。在服务器处理请求的过程中，客户端可以进行其他的操作。：

Ajax 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术（局部刷新）

通过在后台与服务器进行少量数据交换，Ajax 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

传统的网页（不使用 Ajax）如果需要更新内容，必须重载整个网页页面。

2. 实现方式

原生的JS实现方式（了解）

// 1.创建核心对象
      var xmlhttp;
      if (window.XMLHttpRequest)
      {// code for IE7+, Firefox, Chrome, Opera, Safari
          xmlhttp=new XMLHttpRequest();
      }
      else
      {// code for IE6, IE5
          xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
      }
      
// 2. 建立连接
  /*
      参数：
          1. 请求方式：GET、POST
              * get方式，请求参数在URL后边拼接。send方法为空参
              * post方式，请求参数在send方法中定义
          2. 请求的URL：
          3. 同步或异步请求：true（异步）或 false（同步）

   */
  xmlhttp.open("GET","ajaxServlet?username=tom",true);

  // 3.发送请求
  xmlhttp.send();

  // 4.接受并处理来自服务器的响应结果
  // 获取方式 ：xmlhttp.responseText
  // 什么时候获取？当服务器响应成功后再获取

  // 当xmlhttp对象的就绪状态改变时，触发事件onreadystatechange。
  xmlhttp.onreadystatechange=function()
  {
      // 判断readyState就绪状态是否为4，判断status响应状态码是否为200
      if (xmlhttp.readyState==4 && xmlhttp.status==200)
      {
         // 获取服务器的响应结果
          var responseText = xmlhttp.responseText;
          alert(responseText);
      }
  }

JQeury 实现方式

$.ajax()

语法：$.ajax({键值对});

// 使用$.ajax()发送异步请求
   $.ajax({
       url:"ajaxServlet1111" , // 请求路径
       type:"POST" , // 请求方式
       //data: "username=jack&age=23",// 请求参数
       data:{"username":"jack","age":23},
       success:function (data) {
           alert(data);
       },// 响应成功后的回调函数
       error:function () {
           alert("出错啦...")
       },// 表示如果请求响应出现错误，会执行的回调函数
	   dataType:"text"// 设置接受到的响应数据的格式
	 });

$.get()：发送get请求

语法：$.get(url, [data], [callback], [type])
- url：请求路径
- data：请求参数
- callback：回调函数
- type：响应结果的类型

$.post()：发送post请求

语法：$.post(url, [data], [callback], [type])
- url：请求路径
- data：请求参数
- callback：回调函数
- type：响应结果的类型

十一. JSON

1. 名词解释

JSON：JavaScript 对象表示法（JavaScript Object Notation）。 JSON 是存储和交换文本信息的语法。类似 XML。但比 XML 更小、更快，更易解析。

2. 基本语法

基本规则：

数据在名称/值对中：json数据是由键值对构成的
- 键用引号(单双都行)引起来，也可以不使用引号
- 值得取值类型：
  1. 数字（整数或浮点数）
  2. 字符串（在双引号中）
  3. 逻辑值（true 或 false）
  4. 数组（在方括号中） {“persons”:[{},{}]}
  5. 对象（在花括号中） {“address”:{“province”：”陕西”….}}
  6. null
数据由逗号分隔：多个键值对由逗号分隔
花括号保存对象：使用{}定义json 格式
方括号保存数组：[]
示例：

{
    "book": [
        {
            "id":"01",
            "language": "Java",
            "edition": "third",
            "author": "Herbert Schildt"
        },
        {
            "id":"07",
            "language": "C++",
            "edition": "second"
            "author": "E.Balagurusamy"
    }]
}

获取数据:

json对象.键名
json对象[“键名”]
数组对象[索引]
遍历

//1.定义基本格式
     var person = {"name": "张三", age: 23, 'gender': true};
	//获取name的值
	var name = person.name;  //json对象.键名
	var name = person["name"];//json对象["键名"]
//2.嵌套格式   {}———> []
    var persons = {
        "persons": [
            {"name": "张三", "age": 23, "gender": true},
            {"name": "李四", "age": 24, "gender": true},
            {"name": "王五", "age": 25, "gender": false}
        ]
    };
    //获取王五值
    var name1 = persons.persons[2].name;

//3.嵌套格式   []———> {}
    var ps = [{"name": "张三", "age": 23, "gender": true},
              {"name": "李四", "age": 24, "gender": true},
              {"name": "王五", "age": 25, "gender": false}];
    //获取李四值
	var name2 = ps[1].name;	
//4.遍历操作
    var ps = [{"name": "张三", "age": 23, "gender": true},
              {"name": "李四", "age": 24, "gender": true},
              {"name": "王五", "age": 25, "gender": false}];
	//获取person对象中所有的键和值
    //for in 循环
    for(var key in person){
        //这样的方式获取不行。因为相当于  person."name"
        //alert(key + ":" + person.key);
        alert(key+":"+person[key]);
    }
    //获取ps中的所有值
    for (var i = 0; i < ps.length; i++) {
        var p = ps[i];
        for(var key in p){
            alert(key+":"+p[key]);
        }
    }

3. JSON数据和Java对象的相互转换(Jackson)

JSON解析器：Jsonlib，Gson，fastjson，jackson……

（1）JSON转为Java对象

导入 jackson 的相关 jar 包
创建 Jackson 核心对象 ObjectMapper
调用 ObjectMappe r的相关方法进行转换：readValue(json字符串数据,Class);

@Test
public void objectToJson() throws IOException {
    //1.Json数据
    String Json ="{\"name\":\"张三\",\"score\":98,\"gender\":\"男\"}";

    //2.使用objectMapper的readValue方法将Json数据转换为java对象
    ObjectMapper objectMapper = new ObjectMapper();
    Student student = objectMapper.readValue(Json, Student.class);

    //3.输出转换的java对象
    System.out.println(student);//Student{name='张三', score=98, gender='男'}
}

（2）Java 对象转换 JSON

导入 jackson 的相关jar包
创建 Jackson 核心对象 ObjectMapper
调用 ObjectMapper 的相关方法进行转换
- 转换方法：
  - writeValue(参数1，obj):
    参数1：
    File：将obj对象转换为JSON字符串，并保存到指定的文件中
    Writer：将obj对象转换为JSON字符串，并将json数据填充到字符输出流中
    OutputStream：将obj对象转换为JSON字符串，并将json数据填充到字节输出流中
  - writeValueAsString(obj)：将对象转为json字符串
- 注解：
  - @JsonIgnore：排除属性。
  - @JsonFormat：属性值格式化。举例：@JsonFormat(pattern = “yyyy-MM-dd”)

@Test
public void jsonToObject() throws JsonProcessingException {
    //1.java对象
    Student student = new Student("李四",80,"男");

    //2.使用objectMapper的writeValueAsString方法将java对象转换为Json数据
    ObjectMapper objectMapper = new ObjectMapper();
    String json = objectMapper.writeValueAsString(student);

    //3.输出转换的Json数据
    System.out.println(json);//{"name":"李四","score":80,"gender":"男"}
}

（3）复杂 Java 对象和 JSON 的相互转换

List：数组

//将list集合转换为Json数组【注意只有list转换后是json数组，其他转换是json对象】
@Test
public void listToJson() throws JsonProcessingException {
    //1.list对象
    Student s1 = new Student("李四",80,"男");
    Student s2 = new Student("王二",88,"男");
    Student s3 = new Student("小花",96,"女");
    List<Student> list = new ArrayList<>();
    list.add(s1);
    list.add(s2);
    list.add(s3);

    //2.使用objectMapper的writeValueAsString方法
    ObjectMapper objectMapper = new ObjectMapper();
    String json = objectMapper.writeValueAsString(list);

    //3.输出转换结果
    System.out.println(json);//[{"name":"李四","score":80,"gender":"男"},{"name":"王二","score":88,"gender":"男"},{"name":"小花","score":96,"gender":"女"}]
}


//将Json数组转换为List集合
@Test
public void jsonToList() throws IOException {
    //1.json数组
    String json = "[{\"name\":\"李四\",\"score\":80,\"gender\":\"男\"},{\"name\":\"王二\",\"score\":88,\"gender\":\"男\"},{\"name\":\"小花\",\"score\":96,\"gender\":\"女\"}]";

    //2.使用objectMapper的readValue方法
    ObjectMapper objectMapper = new ObjectMapper();
    List<Student> list = objectMapper.readValue(json,new TypeReference<List<Student>>() { });

    //3.输出结果
    Iterator<Student> iterator = list.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
     /*控制台输出结果
    Student{name='李四', score=80, gender='男'}
    Student{name='王二', score=88, gender='男'}
    Student{name='小花', score=96, gender='女'}*/
}

Map：对象格式一致

//map转换为json数据
@Test
public void mapToJson() throws JsonProcessingException {
    //1.map对象
    Map<String,Object> map = new HashMap<>();
    map.put("name","小明");
    map.put("score",50);
    map.put("gender","男");

    //2.使用objectMapper的writeValueAsString方法
    ObjectMapper objectMapper = new ObjectMapper();
    String json = objectMapper.writeValueAsString(map);

    //3.输出转换结果
    System.out.println(json);//{"score":50,"gender":"男","name":"小明"}
}

//json数据转换为map
@Test
public void jsonToMap() throws IOException {
    //1.json数据
    String json ="{\"name\":\"张三\",\"score\":98,\"gender\":\"男\"}";

    //2.使用objectMapper的readValue方法
    ObjectMapper objectMapper = new ObjectMapper();
    Map map = objectMapper.readValue(json, Map.class);

    //3.输出map结果
    Set set = map.keySet();
    for (Object obj:set){
        System.out.println(obj + "=" + map.get(obj));
    }
    /*控制台结果为：
    name=张三
    score=98
    gender=男 */
}

一. JavaWeb概述

一. XML

1. 名词解释

2. 语法

（1）规范

（2）文档声明

（3）标签（元素）

（4）特殊字符

（5）CDATA 区

3. XML 解析

4. dom4j 解析技术

二. Tomcat

1. 名词解释

2. 基本使用

（1）安装

（2）启动

（3）部署

（4）IDEA 添加 Tomcat 服务器

（5）IDEA 中动态 web 工程的操作

三. Servlet

1. 名词解释

2. 实现 Servlet 接口实现 Servlet 程序

（1）步骤

（2）执行原理

（3）Servlet 中方法的生命周期

（4）注解配置（了解）

（5）service 方法

3. 继承 HttpServlet 方法实现 Servlet 程序

（1）步骤

（2）使用IDEA自动创建

4. ServletConfig 类

5. ServletContext 类

6. HTTP 协议

（1）概念

（2）特点

（3）请求消息数据格式

（4）响应消息数据格式

（5）MIME 类型说明

7. HttpServletRequest 类

8. HttpServletResponse 类

四. 文件上传与下载

1. 文件上传

（1）HTML 页面

（2）导入 jar 包

（3）Servlet页面

2. 文件下载

五. JSP

1. jsp 的语法

（1）指令

（2）注释

（3）脚本

2. jsp 内置对象

3. jsp 域对象

4. EL 表达式

5. JSTL 标签

六. Listener

1. 概念

2. 事件监听机制

3. ServletContextListener 监听器

七. Cookie

1. 名词解释

2. 基本使用

3. Cookie 生命控制

八. Session

九. Filter

十. AJAX

1. 概念

2. 实现方式

十一. JSON

1. 名词解释

2. 基本语法

3. JSON数据和Java对象的相互转换(Jackson)

（1）JSON转为Java对象

（2）Java 对象转换 JSON

（3）复杂 Java 对象和 JSON 的相互转换