javaweb笔记1
javaweb概述
1、什么是servlet？
英文：server applet（服务器小程序）
2、JavaEE实际上包括很多种规范，13种规范，
其中Servlet就是JavaEE规范之一。学Servlet还是Java语言。
Servlet是一种小型的Java程序，它扩展了Web服务器的功能。
作为一种服务器端的应用，当被请求时开始执行。
Servlet提供的功能大多与JSP类似，不过实现的方式不同。
JSP通常是大多数HTML代码中嵌入少量的Java代码，
而servlets全部由Java写成并且生成HTML。
3、Servlet生成的HTML代码保存在哪个内置对象中？
response
生成的html源码在计算机的那个位置查看？
4、servlet是单例的。
5、tomcat的logo是一只公猫（寓意表示Tomcat服务器是轻巧的，小巧的，果然，体积小，运行速度快，只实现了Servlet+JSP规范）
tomcat是纯java语言写的。
tomcat服务器要想运行，必须先有jre（Java的运行时环境）
6、一个WEB系统的通信原理？通信步骤：
第一步：用户输入网址（URL）
第二步：域名解析器进行域名解析：http://110.242.68.3:80/index.html
第三步：浏览器软件在网络中搜索110.242.68.3这一台主机，直到找到这台主机。
第四步：定位110.242.68.3这台主机上的服务器软件，因为是80端口，可以很轻松的定位到80端口对应的服务器软件。
第五步：80端口对应的服务器软件得知浏览器想要的资源名是：index.html
第六步：服务器软件找到index.html文件，并且将index.html文件中的内容直接输出响应到浏览器上。
【浏览器软件负责请求驱动，服务器软件负责响应驱动】
第七步：浏览器接收到来自服务器的代码（HTML CSS JS）
第八步：浏览器渲染，执行HTML CSS JS代码，展示效果。
7、什么是请求，什么是响应？
请求和响应实际上说的是数据的流向不同。
从Browser端发送数据到Server端，我们称为请求。英语单词：request
从Server端向浏览器Browser端发送数据，我们称为响应。英语单词：response
B --> S （请求request）
S --> B （响应response）
8、WEB服务器软件都有哪些呢？（这些软件都是提前开发好的。）
Tomcat（WEB服务器）
jetty（WEB服务器）
JBOSS（应用服务器）
WebLogic（应用服务器）
WebSphere（应用服务器）
这些软件有什么作用？
浏览器发送请求之后服务器软件负责找到浏览器请求的资源，负责把这个资源响应给浏览器。
9、应用服务器和WEB服务器的关系？
应用服务器实现了JavaEE的所有规范。(JavaEE有13个不同的规范。)
WEB服务器只实现了JavaEE中的Servlet + JSP两个核心的规范。
通过这个讲解说明了：应用服务器是包含WEB服务器的。
用过JBOSS服务器的同学应该很清楚，JBOSS中内嵌了一个Tomcat服务器。
10、关于Tomcat服务器的目录
bin ： 这个目录是Tomcat服务器的命令文件存放的目录，比如：启动Tomcat，关闭Tomcat等。
conf： 这个目录是Tomcat服务器的配置文件存放目录。（server.xml文件中可以配置端口号，默认Tomcat端口是8080）
lib ：这个目录是Tomcat服务器的核心程序目录，因为Tomcat服务器是Java语言编写的，这里的jar包里面都是class文件。
其中：servlet-api.jar这个不是tomcat服务器的开发人员编写的，servlet-api.jar是Java语言制定者编写的（javaee规范当中的代码）
jsp-api.jar也是一样的，里面都是jsp规范，都是Java语言制定者编写的接口。
tomcat服务器是web服务器是实现servlet和jsp规范的。所以tomcat服务器要运行是依赖servlet-api和jsp-api这两个jar包下的class文件的。
logs: Tomcat服务器的日志目录，Tomcat服务器启动等信息都会在这个目录下生成日志文件。
temp：Tomcat服务器的临时目录。存储临时文件。
webapps：这个目录当中就是用来存放大量的webapp（web application：web应用）
work：这个目录是用来存放JSP文件翻译之后的java文件以及编译之后的class文件。
11、Tomcat服务器的安装：
1.绿色版本的安装很简单，直接zip包解压即可。解压就是安装。
2.我有一个好习惯，在C盘的根目录下新建一个dev目录，java开发所有相关的工具都安装到dev目录下，这样比较方便管理。（你随意）
3.启动Tomcat
bin目录下有一个文件：startup.bat,通过它可以启动Tomcat服务器。
xxx.bat文件是个什么文件？bat文件是windows操作系统专用的，bat文件是批处理文件，这种文件中可以编写大量的windows的dos命令，然后执行bat文件就相当于批量的执行dos命令。
startup.sh，这个文件在windows当中无法执行，在Linux环境当中可以使用。在Linux环境下能够执行的是shell命令，大量的shell命令编写在shell文件当中，然后执行这个shell文件可以批量的执行shell命令。
tomcat服务器提供了bat和sh文件，说明了这个tomcat服务器的通用性。
分析startup.bat文件得出，执行这个命令，实际上最后是执行：catalina.bat文件。
catalina.bat文件中有这样一行配置：MAINCLASS=org.apache.catalina.startup.Bootstrap （这个类就是main方法所在的类。）
tomcat服务器就是Java语言写的，既然是java语言写的，那么启动Tomcat服务器就是执行main方法。（main方法执行成功代表tomcat服务器启动成功了）
我们尝试打开dos命令窗口，在dos命令窗口中输入startup.bat来启动tomcat服务器。
启动Tomcat服务器只配置path对应的bin目录是不行的。有两个环境变量需要配置：
JAVA_HOME=JDK的根
CATALINA_HOME=Tomcat服务器的根
12、点击超链接和在地址栏上输入地址访问，两种方式都是get方式访问。
点击超链接的方式可以省略“ip地址”和“端口号”。
以“/”开始，带项目名是绝对路径。
如果要是以“/”开始那么就是从服务器的根路径开始。
如果不以“/”开始那么就是当前路径。
【“/”代表tomcat服务器的根目录（webapps）。一个tomcat只有一个根目录】
也可以不写ip地址和端口号从一个项目中跳转到另一个项目中（一个项目是一个文件夹）。
13、因为servlet是属于JavaEE的，所以在JDK中没有集成这套接口。
我们要使用servlet的时候必须手动引入。
14、在整个BS结构的系统当中，有哪些人参与进去了
浏览器软件的开发团队（浏览器软件太多了：谷歌浏览器、火狐浏览器、IE浏览器…）
WEB Server的开发团队（WEB Server这个软件也是太多了：Tomcat、Jetty、WebLogic、JBOSS、WebSphere…）
DB Server的开发团队（DB Server这个软件也是太多了：Oracle、MySQL…）
webapp的开发团队（WEB应用是我们做为JavaWEB程序员开发的）
15、角色和角色之间需要遵守哪些规范，哪些协议
webapp的开发团队 和 WEB Server的开发团队 之间有一套规范: JavaEE规范之一Servlet规范。
Servlet规范的作用是什么？
WEB Server 和 webapp解耦合。
Browser 和 WebServer之间有一套传输协议：HTTP协议。（超文本传输协议。）
webapp开发团队 和 DB Server的开发团队之间有一套规范：JDBC规范。
16、Servlet规范是一个什么规范（严格意义上来说他不仅仅是一套简单的接口）？
遵循Servlet规范的webapp，这个webapp就可以放在不同的WEB服务器中运行。（因为这个webapp是遵循Servlet规范的。）
Servlet规范包括什么呢？
规范了哪些接口
规范了哪些类
规范了一个web应用中应该有哪些配置文件
规范了一个web应用中配置文件的名字
规范了一个web应用中配置文件存放的路径
规范了一个web应用中配置文件的内容
规范了一个合法有效的web应用它的目录结构应该是怎样的。
17、JDBD和servlet的对比：
1.JDBC是SUN公司定义的一套规范，是一套接口，Servlet也是SUN定义的一套规范/一套接口。
2.有了JDBC规范我们java程序员就可以和数据库驱动开发团队解耦合，我们面向JDBC调用，数据库驱动开发团队面向JDBC写实现。【我们现象接口调用，数据库驱动团队开发者面向接口是是实现】
有了servlet规范，我们写webapp的java程序员就可以和web Server开发团队解耦合，我们面向servlet写实现，web Servlet开发团队面向servlet写调用。【我们面向接口实现，web Server开发团队面向接口调用】
18、我们只需要做：
编写一个类实现servlet接口。
将编写的类配置到配置文件中，在配置文件中： 指定“请求路径”和“serlvet类名”的关系。
19、指定“请求路径”和“serlvet类名”的关系的这个配置文件？
这个配置文件的文件名、在项目中的存放路径都是固定的。
这个配置文件也是属于servlet规范中的明细。
这样才能达到我们这的webapp和web服务器解耦合，因为每一个web服务器都是不同的厂商开发的，不同的厂商需要遵守相同的servlet规定
每一个web服务器都需要去解析这个配置文件，所以这个配置文件也是规范中的明细。
20、关于JavaEE的版本
JavaEE目前最高版本是 JavaEE8
JavaEE被Oracle捐献了，Oracle将JavaEE规范捐献给Apache了。
Apache把JavaEE换名了，以后不叫JavaEE了，以后叫做 jakarta EE。
以后没有JavaEE了。以后都叫做Jakarta EE。
JavaEE8版本升级之后的"JavaEE 9"，不再是"JavaEE9"这个名字了，叫做JakartaEE9
JavaEE8的时候对应的Servlet类名是：javax.servlet.Servlet
JakartaEE9的时候对应的Servlet类名是：jakarta.servlet.Servlet （包名都换了）
如果你之前的项目还是在使用javax.servlet.Servlet，那么你的项目无法直接部署到Tomcat10+版本上（tomcat10实现了jakarta EE 9规范）。
你只能部署到Tomcat9-版本上。在Tomcat9以及Tomcat9之前的版本中还是能够识别javax.servlet这个包。
21、为什么servlet-api.jar就需要在classpath中配置才可以编译通过，jdk中的jar包就不用在classpath中配置也可以编译通过？
因为编译器是jdk中自带的，jdk中的编译器，肯定知道jdk自己有那些jar包并且存放在什么位置。
主要原因：编译器不是tomcat自带的（jdk中的编译器想使用tomcat中的servlet-api.jar包，jdk是找不到的(因为每个人安装到自己电脑上的tomcat位置不同)，必须将servlet-api.jar配置到classpath环境变量中）。
22、重点：你怎么能让你的HelloServlet编译通过呢？配置环境变量CLASSPATH
CLASSPATH=.;C:\dev\apache-tomcat-10.0.12\lib\servlet-api.jar
思考问题：以上配置的CLASSPATH和Tomcat服务器运行有没有关系？
没有任何关系，以上配置这个环境变量只是为了让你的HelloServlet能够正常编译生成class文件。
因为编译使用的是jdk中的javac工具，编译器不知道servlet-api.jar包在哪里，所以就需要配置环境变量（这是给javac编译器用的跟tomcat运行没有关闭）。
tomcat运行的时候知道自己下面有一个lib下面有一个servlet-api.jar包，直接可以引用。
23、浏览器发送请求，到最终服务器调用Servlet中的方法，是怎样的一个过程？（以下这个过程描述的很粗糙。其中还有很多步骤我省略了。）
用户输入URL，或者直接点击超链接：http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd
然后Tomcat服务器接收到请求，截取路径：/crm/fdsa/fd/saf/d/sa/fd/sa/fd
Tomcat服务器找到crm项目
Tomcat服务器在web.xml文件中查找/fdsa/fd/saf/d/sa/fd/sa/fd 对应的Servlet是：com.bjpowernode.servlet.HelloServlet
Tomcat服务器通过反射机制，创建com.bjpowernode.servlet.HelloServlet的对象。
Tomcat服务器调用com.bjpowernode.servlet.HelloServlet对象的service方法。
24、直接点击“超链接”和“url-pattern”中配置路径的区别：
浏览器上的请求路径和web.xml文件中的url-pattern的唯一区别就是：
浏览器上的请求路径带项目名：/crm
如果在html中编写的超链接连接到某个地址，这个地址可以省略ip地址和端口号（省略IP地址和端口号代表使用当前的IP地址和端口号，所以还是原来的IP地址对应的端口号也是原来的端口号，服务器还是原来的哪个服务器，只不过可能是从这个服务器的一个项目跳转到另一个项目，所以“省略ip地址和端口号”，以“/”开始的路径默认是当前服务器的根路径）【超链接以“/”开始的默认路径是tomcat服务器的根目录（webapps）】
如果在url-pattern中配置servlet的路径，这个路径必须以“/”开始且这个路径不带项目名，因为url-pattern在web.xml中，一个项目对应一个web.xml【url-pattern以“/”开始的默认路径是“项目”的根路径】
超链接默认是：服务器的根，url-pattern默认是项目的根。
24.1、在项目的web.xml文件中配置的
25、html页面只能放到WEB-INF目录外面。
26、以后不需要我们编写main方法了。
tomcat服务器负责调用main方法，Tomcat服务器启动的时候执行的就是main方法。
我们javaweb程序员只需要编写Servlet接口的实现类，然后将其注册到web.xml文件中，即可。
27、
Servlet基础
1、ServletResponse类
1. java.io.PrintWriter getWriter(); //返回一个“PrintWriter”对象，它可以往客户端发送字符串数据。【PrintWriter这个是是一个输出流，可以通过System.setOut(输出指向)，的方式设置他的输出位置，这个字符输出流的输出位置是浏览器，就像我们可以通过这个想一个文本文件中输出字符串一样（就像jdk默认设置向控制台输出一样）。】
这是一个输出流对象，负责输出字符串到浏览器，这个流不需要我们刷新也不需要我们关闭，这些都是由Tomcat来维护的。
调用PrintWriter对象的println或者print方法可以输出。【就像我们一开始使用的System.out.println("Hello World");中的println是一样的】
2.ServletResponse对象的setContentType()方法可以设置服务器往浏览器上响应的内容类类型是普通文本还是html代码。
默认是普通文本类型。
“text/html;charset=utf-8”:设置响应的内容类型是html文档，html中也可以是javascript类型的代码。
设置响应的内容类型的的时候不要在获取流之后设置。
2、直接写：System.out.println是往控制台上打印，这是jdk规定的。
通过tomcat的ServletResponse对象的getWriter方法获取的输出流是往浏览器上打印。
3、在一个webapp中去连接数据库，需要将驱动jar包放到WEB-INF/lib目录下。（com.mysql.jdbc.Driver 这个类就在驱动jar包当中。）
【lib下面是存放第三方jar包的，MySQL驱动属于第三方jar包，所以需要放在WEB-INF目录下】
tomcat会自动去lib目录下找第三方jar包。
4、在IDEA工具中根据Web Application模板生成的目录中有一个web目录，
这个目录就代表webapp的根，是一个应用（例如crm）的根（一个服务器下面可能有好多应用），并不是tomcat服务器的根。
web目录仅仅代表一个应用的根目录，并不是webapps（webapps是服务器的根）。
5、在idea中写的web项目不用必须写在“CATALINA_HOME”录下的webapps目录下，因为idea中的
“项目名.iml”这个配置文件中描述了“web应用的”根路径，
使用：
file://$MODULE_DIR$代表idea中项目的根路径 项目下面的web就是一个web应用的根路径
有了这个描述关系，不管web应用在哪里tomcat服务器都能找到web应用的位置，不需要必须在webapps下面。
5、为什么将CATALINA_HOME都导入项目中，idea的“External Libraries”只显示两个jar包？
可以配置，一般我们是面向接口写实现类，而SUN规定的接口都是在servlet-api.jar和jsp-api.jar中的，
所以我们只需要引入这两个jar包就可以编译通过，但是运行还是需要“CATALINA_HOME\lib”下面的jar包的。
6、为什么部署形目的时候项目名默认都是：项目名_war_exploded这样的格式？
在idea中项目输出的时候会把整个web项目的产品输出到以“项目名_war_exploded”为文件名的一个目录下。
所以“项目名_war_exploded”就是成品，所以部署的时候就是将成品部署到tomcat。
“项目名_war_exploded”就是web应用的根路径，就相当于是“webapps”下面的一个文件夹代表一个项目。
7、在idea中开发的web项目，jsp文件翻译成servlet的时候就不是在“CATALINA_HOME”的work文件夹中了，
是idea开发团队规定的特定的地方：知道文件在哪里就好，至于为什么做么做，后期研究。
C:\Users\XueYingHao\AppData\Local\JetBrains\IntelliJIdea2022.1\tomcat\3460990b-5fca-47be-bf8b-9cb9aef7dba3
Servlet的生命周期
1、什么是Servlet对象生命周期？
Servlet对象什么时候被创建。
Servlet对象什么时候被销毁。
Servlet对象创建了几个？
Servlet对象的生命周期表示：一个Servlet对象从出生在最后的死亡，整个过程是怎样的。
2、Servlet对象是由谁来维护的？
Servlet对象的创建，对象上方法的调用，对象最终的销毁，我们webapp程序员是无权干预的。
Servlet对象的生命周期是由Tomcat服务器（WEB Server）全权负责的。
WEB服务器通常我们又称为：WEB容器。(Tomcat就是一个web容器)
WEB容器来管理Servlet对象的生命周期。
3、我们自己new的Servlet对象受WEB容器的管理吗？
我们自己new的Servlet对象是不受WEB容器管理的。
WEB容器创建的Servlet对象，这些Servlet对象都会被放到一个集合当中（HashMap），只有放到这个HashMap集合中的Servlet才能够被WEB容器管理，自己new的Servlet对象不会被WEB容器管理。（自己new的Servlet对象不在容器当中）
web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系
4、服务器在启动的Servlet对象有没有被创建出来（默认情况下）？
在Servlet中提供一个无参数的构造方法，启动服务器的时候看看构造方法是否执行。？
经过测试得出结论：默认情况下，服务器在启动的时候Servlet对象并不会被实例化。
这个设计是合理的。用户没有发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的，并且创建出来的Servlet如果一直没有用户访问，显然这个Servlet对象是一个废物，没必要先创建。
5、怎么让服务器启动的时候创建Servlet对象呢？
在servlet标签中添加子标签（
6、用户在发送第一次请求的时候Servlet对象被实例化，（Tomcat调用Servlet的无参构造方法创建Servlet对象）
Servlet对象创建成功之后，Tomcat马上调用Servlet的init方法。
用户发送第一次请求的时候，init方法执行之后，Tomcat服务器马上调用Servlet对象的service方法。
Servlet的无参构造方法 --> Servlet对象的init方法 --> Servlet对象的service方法
7、用户在发送第二次，或者第三次，或者第四次请求的时候，Servlet对象并没有新建，还是使用之前创建好的Servlet对象，直接调用该Servlet对象的service方法，这说明：
第一：Servlet对象是单例的（单实例的。但是要注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。之所以单例是因为Servlet对象的创建我们javaweb程序员管不着，这个对象的创建只能是Tomcat来说了算，Tomcat只创建了一个，所以导致了单例，但是属于假单例。真单例模式，构造方法是私有化的。）
第二：无参数构造方法、init方法只在第一次用户发送请求的时候执行（init方法在Servlet对象创建后立马被调用，不是在service方法执行之前）。
也就是说无参数构造方法只执行一次。init方法也只被Tomcat服务器调用一次。
第三：只要用户发送一次请求：service方法必然会被Tomcat服务器调用一次。发送100次请求，service方法会被调用100次。
8、Servlet的destroy方法只被Tomcat服务器调用一次。
destroy方法在什么时候被调用？
在服务器关闭的时候。
因为服务器关闭的时候要销毁AServlet对象的内存。
服务器在销毁Servlet对象内存之前，Tomcat服务器会自动调用Servlet对象的destroy方法。
9、init方法实在Servlet对象创建出来之后第一个被Tomcat调用的方法。
destroy方法是在Servlet对象被销毁之前最后一个被Tomcat调用的方法。
10、当我们Servlet类中编写一个有参数的构造方法，如果没有手动编写无参数构造方法会出现什么问题？
报错了：500错误。
注意：500是一个HTTP协议的错误状态码。
500一般情况下是因为服务器端的Java程序出现了异常。（服务器端的错误都是500错误：服务器内部错误。）
如果没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象。
所以，一定要注意：在Servlet开发当中，不建议程序员来定义构造方法，因为定义不当，一不小心就会导致无法实例化Servlet对象。
11、Servlet的无参数构造方法是在对象第一次创建的时候执行，并且只执行一次。init方法也是在对象第一次创建的时候执行，并且只执行一次。那么这个无参数构造方法可以代替掉init方法吗？
不能。
Servlet规范中有要求，作为javaweb程序员，编写Servlet类的时候，不建议手动编写构造方法，因为编写构造方法，很容易让无参数构造方法消失，这个操作可能会导致Servlet对象无法实例化。所以init方法是有存在的必要的。
12、init、service、destroy方法中使用最多的是哪个方法？
使用最多就是service方法，service方法是一定要实现的，因为service方法是处理用户请求的核心方法。
适配器方式改造Servlet
1、我们编写一个Servlet类直接实现Servlet接口有什么缺点？
我们只需要service方法，其他方法大部分情况下是不需要使用的。代码很丑陋。
2、适配器设计模式Adapter
手机直接插到220V的电压上，手机直接就报废了。怎么办？可以找一个充电器。这个充电器就是一个适配器。手机连接适配器。适配器连接220V的电压。这样问题就解决了。
3、编写一个GenericServlet类，这个类是一个抽象类，其中有一个抽象方法service。
GenericServlet实现Servlet接口。GenericServlet是一个适配器。
以后编写的所有Servlet类继承GenericServlet，重写service方法即可。
4、思考第一个问题：我提供了一个GenericServlet之后，init方法还会执行吗？
还会执行。会执行GenericServlet类中的init方法。
5、init方法中的ServletConfig对象是谁创建的？是谁传过来的？
都是Tomcat干的。
Tomcat服务器先创建了ServletConfig对象，然后调用init方法，将ServletConfig对象传给了init方法。
6、Servlet 是服务器小程序
ServletConfig 是一个servlet配置对象，由servlet容器以便在Servlet初始化期间将信息传递给servlet。
ServletContext 定义servlet用于与其servlet容器通信的一组方法
ServletConfig
1、什么是ServletConfig？
Servlet对象的配置信息对象。
ServletConfig对象中封装了标签(web.xml文件中
2、一个Servlet对应一个ServletConfig对象。
3、Servlet对象是Tomcat服务器创建的，并且ServletConfig对象也是Tomcat服务器创建的。
默认情况下他们是在用户发送第一次请求的时候被创建。
4、Tomcat服务器调用Servlet对象的init方法的时候，需要传一个ServletConfig对象的参数给init方法
5、ServletConfig接口的实现类是Tomcat服务器给实现的。（Tomcat服务器就是WEB服务器）
6、ServletConfig接口中的常用方法：
public String getInitParameter(String name) //通过初始化参数的name获取value
public Enumeration
public ServletContext getServletContext () //获取ServletContext对象
public String getServletName() // 获取Servlet的name
【因为GenericServlet也实现了ServletConfig接口，并且实现了这四个方法，
所以我们自己写的Servlet类继承了GenericServlet抽象类就可以直接使用我们写的Servlet对象调用这些方法，
没有必要一定去获取ServletConfig对象】
7、ServletConfig中的getInitPatameter(String name)方法
Servlet的配置信息是在web.xml文件的
方法name传进去
ServletContext
1、一个Servlet对象对应一个ServletConfig，100个Servlet对象则对应100个ServletConfig。
【一个ServletConfig对象中可以认为分封装了一个servlet标签中的内容】
2、只要在同一个webapp当中，只要在同一个应用当中，所有Servlet对象共享一个ServletContext对象。
【一个服务器中可能有多个应用，一个应用对应一个ServletContext对象，一个ServletContext对象可以认为是封装了web.xml中web-app标签中所有的内容】
3、ServletContext对象在服务器启动阶段创建，在服务器关闭的时候销毁，这就是ServletContext对象的生命周期。
Servlet对象是应用级对象。
4、Tomcat服务器中有一个webapps，这个webapps下可以存放多个webapp，假设有100个webapp，
那么就有100个ServletContext对象。【一个应用/webapp只有一个ServletContext对象】
5、ServletContext对象被称为Servlet上下文对象（Servlet对象的四周环境对象）
6、ServletContext是一个接口，Tomcat服务器对ServletContext接口进行了实现。
ServletContext对象的创建也是Tomcat服务器完成的。启动Tomcat的时候创建。
7、一个ServletContext对象对应一个web.xml文件。
8、在Tomcat10源码中有两个包：
1.jakarta 包中的都是规范，是SUN公司编写的一些接口。
2.org.apache 包下的都是对规范的实现，是Tomcat开发团队编写的。
9、ServletContext接口的常用方法
1.public String getInitParameter(String name); //通过初始化参数name获取value
2.public Enumration
以上两个方法是ServletContext对象的方法，这个方法获取的是什么信息？是以下配置信息：
以上的配置信息属于应用级的配置信息，一般一个项目中共享的配置信息会放到以上的标签当中
如果你的配置信息只想给某一个Servlet做参考，那么你配置到Servlet标签当中即可，使用ServletConfig对象来获取。
3.String getRealPath(String path) : 主要用于获取webapp中项目的的资源的绝对路径，【所以默认从webapp的根目录开始找(不是服务器的根目录)】
返回一个字符串，该字符串包含给定虚拟路径的实际路径。
path ：以/开始，代表从webapp的根路径开始寻找【测试String path1 = application.getRealPath("/");返回项目的根路径，getRealPath("/");不管写多少个/，返回项目的根路径】
path ：不带/默认也是从webapp的根目录下开始寻找【测试String path1 = application.getRealPath("");也是返回项目的根路径】
path：写成以下3种情况都是一样的
out.print(application.getRealPath("/a/123.txt"));【“/”代表请用的根路径】
out.print(application.getRealPath("a/123.txt"));【开头不写/默认从应用的根路径开始】
out.print(application.getRealPath("a123.txt"));【不管写几个/tomcat或把他转换成一个/】
WEB-INF下面的资源虽然不能直接访问，但是可以通过getRealPath获取资源的真实路径。
getRealPath(path),哪怕后面跟的这个path路径的这个资源不存在，也会把这个path拼接到应用的根路径后面返回。
可以用来获取应用的绝对路径。
4.InputStream getResourceAsStream (java.lang.String path)
这里的path和getRealPath写法是一样的。可以直接返回一个流。
5.getContextPath() : 用于获取webapp的根目录，也可以说是“/＋项目名”
6.public void log(String msg)
public void log(String msg,Throwable t)
通过ServletContext对象记录日志：日志记录到了localhost.日期.log文件中了。
7.操作应用域中的数据：
存：向ServletContext应用域中存数据
public void setAttribute(String name,Object value); //map.put(k,v)
取：从ServletContext应用域中取数据[指定的name不存在返回null]
public Object getAttribute(String name); //Object obj = map.get(k)
删：从ServletContext应用域中删除数据
public void removeAttribute(String name); //map.remove(k)
获取所有应用域属性的名字：
Enumeration
9.1、Enumeration
1.boolean hasMoreElements() : 判断有没有更多的元素，如果有返回true，没有返回false
2.E nextElement() : 将指针向后移动一个，并且返回指针指向的一个元素
10、当使用idea工具开发javaweb应用的时候，日志并不是直接记录到“CATALINA_HOME\logs”目录下了，
因为idea可以创建多个tomcat，多个tomcat不能使用同一个logs目录，
所以idea工具自己创建了很多tomcat的“CATALINA_HOME”目录idea自己创建的“CATALINA_HOME”是根据真正的“CATALINA_HOME”生成的。
在控制台的“CATALINA_BASE”这个值后面就是idea工具创建的“CATALINA_HOME”.
idea生成的“CATALINA_HOME”中有3个文件夹：
conf：存放配置信息
logs：存放日志文件【里面有三类文件】
catalina.2023-03-28.log：服务器端Java程序运行的控制台信息【后面的2023-03-28是日期】
localhost.2023-03-28.log:ServletContext对象的log方法记录的日志信息存储到这个文件中
localhost_access_log.2023-03-28.txt：访问日志
work：存放jsp生成的java源代码以及编译之后生成的字节码文件。
12、ServletContext对象还有另一个名字：应用域（除了应用域之外还有其他域会话域、请求域）
如果所Servlet对象共享一份数据，并且这个数据很少被修改，并且这个数据量很小可以将这个数据放到ServletContext应用域当中
1、为什么是所有Servlet共享的？不是共享的没有意义，如果只是一个Servlet的数据另一个Servlet也能取出来，那就不中
2、为什么是很少被修改/几乎不修改？因为多线程并发的环境下，修改数据很可能引发线程安全问题。
3、为什么是数据量很少？大数据量一直放到内存中是很消耗资源的，ServletContext对象生命周期很长。
13、以后我们编写Servlet类的时候，实际上不会直接继承GenericServlet类，因为我们是B/S结构的系统
这种系统是基于HTTP超文本传输协议的，在Servlet规范当中提供了一个类叫做HttpServlet
他是专门为Hppt协议准备的一个Servlet类。我们编写Servlet类的时候要继承HttpServlet。
jakarta.servlet.Servlet(接口)【爷爷】
jakarta.servlet.GenericServlet(抽象类)【爸爸】
jakarta.servlet.HttpServlet(抽象类)【孙子】
14、我们目前了解的缓存机制：
方法区内存中的字符串常量池。
“abc” 先在字符串常量池中查找，如果有，直接拿来用。如果没有则新建，然后再放入字符串常量池。
堆内存当中的整数型常量池：
连接池：
这里所说的连接池中的连接是Java语言连接数据库的连接对象：java.sql.Connection.
JVM是一个进程。DBMS也是一个进程，进程和进程之间建立连接，打开通道是很费劲的。
是很耗费资源的，怎么办？可以提前创建好N和Connection连接对象，将连接对象放到一个集合当中
我们吧这个放有N个Connection对象的集合叫做连接池。每一次用户连接的时候不需要在新建对象了
省去了新建对象的环节，直接从连接池中获取连接对象，大大提升了访问效率。
线程池：
Tomcat服务器本身就是支持对线程的。
Tomcat服务器实在用户发送一次请求，就新建一个Thread线程对象吗？
不是。实际上Tomcat在启动的时候，会先创建好N多个线程Thread对象，
然后将线程对象放到集合当中，成为线程池，用户发送请求过来之后，
需要有一个对应的线程来出来这个请求，这个时候线程对象就会直接从线程池中拿，
效率比较高。
向ServletContext应用域中存储数据，也就是将数据放到了cache当中了
HTTP协议
1、什么是协议？
协议实际上是某些人或者某些组织提前制定的一套规范，大家都按照这个规范来这样可以做到无障碍沟通。
协议就是一套规范一套标准。由其他人或其他组织来负责制定的。
2、什么是HTTP协议？
HTTP协议是W3C制定的一套超文本传输协议。（通信协议：发送消息的模板提前被制定好）
这种协议游走在B和S之间。B向S发送数据要遵循HTTP协议，S向B发送数据同样要遵循HTTP协议。这样B和S才能解耦合
3、Http协议包括：
请求协议：
浏览器向WEB服务器发送数据的时候，这个发送的数据需要遵循HTTP请求协议标准，这套标准中规定了B向S发送的数据的具体格式。
相应协议：
WEB服务器向浏览器发送数据的时候，这个发送的数据需要遵循HTTP响应协议标准，这套协议中规定了S向B发送的数据的具体格式。
4、Http的请求协议：（B-->S）包括四部分
请求行
请求头
空白行
请求体
Http的响应协议：（S-->B）包括四部分
状态行
响应头
空白行
响应体
4.1、Http请求具体报文：get请求
GET /servlet01/hst2?username=xueyinghao&pwd=123456&m=get HTTP/1.1 请求行
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif, 请求头
image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Connection: keep-alive
Cookie: JSESSIONID=B2F3B5123EA5378F63FD6EBD13014DDE
Host: localhost:8080
Referer: http://localhost:8080/servlet01/
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36
sec-ch-ua: "Chromium";v="110", "Not A(Brand";v="24", "Google Chrome";v="110"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
空白行【用于分割请求头和请求体】
请求体【get请求没有请求体】
Http请求具体报文：post请求
POST /servlet01/hst2 HTTP/1.1 请求行
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif, 请求头
image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cache-Control: max-age=0
Connection: keep-alive
Content-Length: 37
Content-Type: application/x-www-form-urlencoded
Cookie: JSESSIONID=B2F3B5123EA5378F63FD6EBD13014DDE
Host: localhost:8080
Origin: http://localhost:8080
Referer: http://localhost:8080/servlet01/
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36
sec-ch-ua: "Chromium";v="110", "Not A(Brand";v="24", "Google Chrome";v="110"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
空白行
username=xueyinghao&pwd=12345&m=post 请求体【一般是B向S发送的数据】
Http响应具体报文:get和post都一样
HTTP/1.1 200 ok 状态行
Content-Type: text/html;charset=utf-8 响应头
Content-Length: 3
Date: Wed, 29 Mar 2023 06:26:46 GMT
Keep-Alive: timeout=20
Connection: keep-alive
空白行【用于分割响应头和响应体】
GET 响应体【一般是S向B发送的数据：例如out.print("GET");】
请求行主要包括三部分：
第一部分：请求的方式
get[常用]
post[常用]
delete
head
put
options
trace
第二部分：URI
什么是uri，统一资源标识符。代表网络中某个资源的名字。但是通常uri是无法定位资源的
什么是URL，统一资源定位符。代表网络中某个资源，同时URL可以定位到该资源
URI和URL什么关系？
URL包括URI
http://localhost:8080/servlet05/index.html 这是URL。
/servlet05/index.html 这是URI。
第三部分：HTTP协议版本号。
状态行主要包括三部分：
第一部分：协议版本号HTTP/1.1
第二部分：状态码（HTTP协议中规定的响应状态码，不同的响应结果对应不同的状态码）
200 表示请求响应成功，正常结束。
404表示访问的资源不存在，通常是因为要么是你路径写错了，我们认为是前端浏览器的错误
405表示前端发送的请求方式与后端请求的处理方式不一致时发生：
500表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的。
以4开始的，一般是浏览器端的错误导致的。
以5开始的，一般是服务器端的错误导致的
第三部分：状态的描述信息
ok 表示正常成功结束。
not found 表示资源找不到。
4.2、get请求和post请求有什么区别？
get请求在W3C中是这样说的：get请求比较适合从服务器端获取数据。
post请求在W3C中是这样说的：post请求比较适合向服务器端传送数据。
get请求方式支持缓存。post方式不支持缓存。
get请求只能发送普通的字符串。并且发送的字符串长度有限制，不同的浏览器限制不同。这个没有明确的规范。get方式无法发送大数据量。
post请求可以发送任何类型的数据，包括普通字符串，流媒体等信息：视频、声音、图片。post请求可以发送大数据量，理论上没有长度限制。
get请求方式是用来获取服务器端的资源的：
任何一个get请求最终的“响应结果”都会被浏览器缓存起来。在浏览器缓存当中：
一个get请求的路径a 对应 一个资源。
一个get请求的路径b 对应 一个资源。
一个get请求的路径c 对应 一个资源。
我们可以在请求路径后面加一个时间戳组织走缓存。
post请求是用来修改服务器端的资源的：
post请求之后，服务器“响应的结果”不会被浏览器缓存起来。因为这个缓存没有意义。
4.3、不管你是get请求还是post请求，发送的请求数据格式是完全相同的，只不过位置不同，格式都是统一的：
name=value&name=value&name=value&name=value
5、
超链接：中的“/”代表服务器的根路径
模板方法设计模式
1、什么是设计模式？
某个问题的固定的解决方案。(可以被重复使用。)
2、什么是模板方法设计模式?
在模板类的模板方法中定义核心算法骨架，具体实现可以延伸到子类中去完成。
3、模板类通常是一个抽象类，模板类当中的模板方法定义核心算法，这个算法通常是final的（但也可以不是final的）
4、模板类中的抽象方法就是不确定的方法，这个不确定怎么实现的事交给儿子去做。
HttpServlet源码分析
1、HttpServlet类是专门为Http协议准备的。
2、HttpServlet在那个包下？
jakarta.servlet.http.HttpServlet
3、到目前位置我们接触到了Servlet规范中的哪些接口？
jakarta.servlet.Servlet
jakarta.servlet.ServletConfig
jakarta.servlet.ServletContext
jakarta.servlet.GenericServlet
jakarta.servlet.ServletException
jakarta.servlet.ServletRequest
jakarta.servlet.ServletResponse
http包下都有那些类喝接口？jakarta.servlet.http.*;
jakarta.servlet.http.HttpServlet
jakarta.servlet.http.HttpServletRequest
jakarta.servlet.http.HttpServletResponse
4、HttpServletRequest对象中封装了那些信息？
HttpServletRequest 简称 request对象
HttpServletRequest中封装了请求协议的全部内容【请求行、请求头、空白行、请求体】
Tomcat服务器将“请求协议”中的数据全部解析出来，然后将这些数据前部封装到request对象当中
我们要面向HttpServletRequest，就可以获取请求协议中的全部数据。
HttpServletResponse对象专门用来用来响应“Http协议”到浏览器的。
会议Servlet的生命周期：
用以第一次请求：
Tomcat通过反射机制，调用无参数构造方法。创建Servlet对象。（web.xml文件中配置的Servlet对象）
Tomcat调用Servlet的init方法来完成初始化。
Tomcat调用Servlet的service方法处理请求。
用户第二次请求：
Tomcat调用Servlet的service方法处理请求。
服务器关闭：
Tomcat调用Servlet的destroy方法，做销毁之前的准备工作。
Tomcat服务器销毁Servlet对象。
5、如果我们写一个Servlet继承HttpServlet
不重写其中的任何方法如果前端发送过来的请求是get请求就会执行到HttpServlet的doGet方法
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String msg = lStrings.getString("http.method_get_not_supported");
sendMethodNotAllowed(req, resp, msg); //执行到这行代码的时候就会抛出405错误
}
6、我们写一个Servlet继承HttpServlet的源码执行分析：
public class HelloServlet extends HttpServlet {
// 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。
public HelloServlet() {
}
//override 重写 doGet方法
//override 重写 doPost方法
}
首先Tomcat会调用我们我们写的Servlet的无参数构造方法创建Servlet对象
然后调用Servlet对象的init方法，我们没有重写所以调用父类的init方法
因为HttpServlet也没有重写init方法，所以调用GenericServlet类的init方法
然后调用Servlet类的service方法，因为我们的写的Servlet类中没有重写service方法
所以会调用HttpServlet类的service(ServletRequest req,ServletResponse resp)方法,
然后调用到HttpServlet类的模板方法service(HttpServletRequest req,HttpServletResponse resp)。
模板方法会根据用户发送过来的请求，调用到具体的方法。
【如果前端发送过来的请求是get请求那么就会调用到模板类的doGet方法】
如果不重写模板类的doGet方法，就相当于我们没有处理get请求，这是Servlet默认是抛出405异常的。
如果我们直接重写service方法就相当于我们破坏了模板类的，模板方法，破坏了模板方法中的算法。
所以我们就无法享受到405服务了。
7、HttpServletRequest对象的常用方法：
1.getMethod() 获取请求的方法
设置欢迎页
【实例】
9、WEB-INF下面的资源虽然不能直接访问但是可以通过设置欢迎页面的方式访问到：
不能：服务器URL/项目名/WEB-INF/资源名
可以：
10、欢迎页面可以是一个Servlet。
欢迎页面如果要是一个Servlet的话，就不能以“/”开始了。
以“/”开始就代表在web目录下寻找，发现没有这个资源，那么就会报404错。
不以“/”开始代表在项目名后面加个“/”接着拼接。
以“/”开始代表从web下寻找资源。
11、不以“/”开始代表在项目名后面加个“/”接着虚拟拼接。【所以欢迎页面设置成Servlet的时候不能加“/”，Servlet的路径是虚拟的“物理性的”寻找Servlet资源肯定找不到】
以“/”开始代表从web下物理性的寻找资源。【所以以“/”开始才能访问到WEB-INF下面的资源】
物理寻找能找到的资源虚拟拼接一定能找到。
虚拟拼接能找到的资源物理寻找不一定能找到。【因为有的Servlet是我们通过
12、只有welcome这里带“/”是物理寻找，不带“/”是虚拟拼接。
getRealPath带“/”和不带“/”都是一样的效果，采用“虚拟拼接”寻找。
13、什么是物理寻找什么是虚拟拼接？
物理寻找：在磁盘的目录下寻找有没有该路径对应的实体
虚拟拼接：一个虚拟的路径拼接之后能否对应上一个资源
物理寻找能找到的资源说明他是一个真真正正存在的实体，那么虚拟拼接就一定能找到。
反而虚拟拼接能找到的资源物理寻找不一定能找到。
14、对于welcome“物理寻找”和“虚拟拼接”各有好处
“物理寻找”：能访问到WEB-INF中的资源。
“虚拟拼接”：能用Servlet做欢迎页面。
关于WEB-INF目录
1、放在WEB-INF目录下的资源是受保护的，在浏览器上不能直接通过路径直接访问。
所以像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外。
2、在WEB-INF下的资源可以通过设置欢迎页直接访问到，但是
HttpServletRequest
1、HttpServletRequest是一个接口，全限定类名：jakarta.servlet.http.HttpServletRequest
2、HttpServletRequest是Servlet规范中的一员。
3、HttpServletRequest的父接口是ServletRequest。
所以在HttpServlet类中的service(ServletRequest req,ServletResponse resp)方法中
req可以直接转换成HttpServletRequest类型。
源码：public interface HttpServletRequest entends ServletRequest {}
4、HttpServletRequest接口的实现类是谁写的？HttpServletRequest对象是谁创建的？
通过测试：org.apache.catalina.connector.RequestFacade实现了HttpServletRequest接口
测试结果说明Tomcat服务器实现了HttpServletRequest接口，是说明了Tomcat服务器实现了Servlet规范。
对于我们javaweb程序员来说，实际上不需要关心这个，我们只需要面向接口编程即可。
我们关心的是HttpServletRequest接口中有哪些方法，这些方法可以完成哪些功能！！！
5、HttpServletRequest对象中都有那些信息？都包装了什么信息？
HttpServletRequest对象是Tomcat服务器负责拆创建的。
这个对象中封装了什么信息？
封装了HTTP的请求协议。
实际上用户发送请求的时候，遵循了Http协议，发送的是Http请求协议，Tomcat服务器将Http协议中的信息以及数据全部解析出来
然后Tomcat服务器将这些信息封装到了HttpServletRequest对象当中了，传给了我们javaweb程序员。
javaweb程序员面向HttpServletRequest接口调用方法就可以获取请求信息了。
6、request和response对象的生命周期？
request对象和response对象，一个是请求对象，一个是响应对象，这两个对象只能在当前请求中有效。
一次请求，一个request，一个response
两次请求，两个request，两个response
7、HttpServletRequest接口中有哪些常用的方法？
Map
Enumeration
String[] getParameterValues(String name) 根据key获取一维数组value
String getParameter(String name) 一般的value都是一个数据并不是一个数组，只有复选框的时候才是一个数组所以这个方法最常用，【获取一维数组中的第一个元素】
请求域对象
1、request对象实际上又被称为“请求域”对象。
2、“请求域”对象要比“应用域”对象小很多。生命周期很短，请求域只在一次请求内有效。
3、一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就销毁了。
4、“请求域”对象的三个方法：
void setAttribute(String name,Object obj) // 向请求域中绑定数据
Object getAttribute(String name) // 从请求域当中根据name获取数据
void removeAttribute(String name) // 将域中绑定的数据移除
5、请求域和应用域选用原则？
尽量使用小的域对象，因为小的域对象占用的资源较少。
6、能不能让两个Servlet在一次请求当中共同使用一个请求域对象：
可以使用Servlet中的请求转发机制。
7、请求转发实现步骤：
第一步获取请求转发器：
RequestDispatcher dispatcher = request.getRequestDispatcher("以/开始的路径");【这里的“/”代表应用的根路径，假如这里的路径不以“/”开始，那么默认也是从应用的“根路径”开始的】
第二部：调用转发器的forward方法完成跳转/转发
dispatcher.forward(request,response);
两步可以合并在一起。
request.getRequestDispatcher("转发的路径").forward(request,response);
转发路径：
如果以“/”开始代表从应用的根路径下开始寻找。
如果不以“/”开始代表从当前资源所以在路径下寻找。
【除了welcome哪里以“/”开始使用的是“物理寻找”其他的都是使用的虚拟拼接】
getRequestDispatcher是ServletRequest接口中的方法。
转发的路径：可以使用“../”可以跳转到其他的应用。
默认是从应用的根路径开始，使用一个“../”返回上级目录就是服务器的根目录。
因为请求转发是在一次请求当中，如果转发之前是post请求，转发之后还是post请求，转发之前是get请求，转发之后还是get请求。
8、两个Servlet怎么共享数据？
将数据放到ServletContext应用域当中，当然是可以的，但是应用域范围太大，占用的资源太多，不建议使用。
可以将数据放到request域当中，然后AServlet转发到BServlet，保证了AServlet和Bservlet在一次请求当中。
这样两个Servlet或者多个Servlet可以共享用一份数据。
9、WEB-INF下面的资源虽然用户不能直接通过浏览器输入地址的方式访问但是，可以通过Servlet的请求转发转发到WEB-INF下面的资源。
【即使这里使用的数虚拟拼接也可以直接转发到WEB-INF下面的资源】
超链接前端直接点击超链接的方式就相当于直接在浏览器上输入地址，所以不能访问到WEB-INF下面的资源。
10、转发过去的的request不是同一个对象：
转发者： org.apache.catalina.connector.RequestFacade
转发的目标： org.apache.catalina.core.ApplicationHttpRequest
虽然不是同一个对象，但是请求域中的数据连个对象是共享的。
因为RequestFacade和ApplicationHttpRequest都是ServletRequest接口的子类型，
所以他们都有setAttribute、getAttribute、removeAttribute等方法【用来操作域中的数据】。
11、转发的下一个资源必须是一个Servlet吗？
不一定，只要是Tomcat服务器当中的合法资源，都是可以转发的。例如：html…
12、注意：转发的时候，路径的写法要注意，转发的路径以“/”开始，不加项目名。【/代表项目的个根路径，不写/默认也是从项目的根路径开始虚拟拼接的】
13、从AServlet对象转发到BServlet之后，浏览器地址栏上面的地址是不变的。
14、RequestDispatcher中有两个方法：
forward(ServletRequest resuest,Response response) // 请求转发
从AServlet转发到BServlet，AServlet中的东西就不显示了
include(ServletRequest request,Response response) // 请求包含
从AServlet转发到BServlet，AServlet中的东西仍然显示
15、request的常用方法【包括ServletRequest和HttpServletRequest】
1.String getRemoteAddr(); // 获取发出请求的客户端的IP地址
int getRemotePort(); // 获取发出请求的客户的端口号
String getServerName(); //获取服务器的名字【localhost,127.0.0.1】
int getServerPort(); // 获取服务器的端口号【8080】
String getLocalName(); //获取本机主机名
int getLocalPort(); // 获取本地端口号
2.void setCharacterEncoding(String enc); // 设置请求体内容的字符编码方式
ServletResponse中也有setCharacterEncoding()方法,用于设置相应给浏览器的响应体的编码方式。
可以使用response.setContentType("text/html;charset=字符编码")这种方式代替
3.get请求乱码问题怎么解决？
get请求数据实在请求行上提交的，不是在请求体当中提交的。所以通过setCharacterEncoding方法这个只能这只请求体的编码方式，不能设置请求行的编码方式。
解决方案:修改CATALINA_HOME/conf/server.xml配置文件
从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了。
3.String getContextPath(); // 获取应用的根路径，和ServletContext中的getContextPath效果一样【/servlet01】
4.String getServletPath(); // 获取请求的Servlet的path【Servlet的路径】
String getRequestURI(); //获取请求的URI 【/servlet01/Servlet的路径】
5.String getMethod(); // 获取请求的方式 【GET】
7.String getRealPath(String path); // 获取真是(绝对)路径，这个方法已经过时，可以使用ServletContext类中的getRealPath方法获取资源的绝对路径
9.String getProtocol(); // 获取请求协议的版本号
16、getRemoteXXX() ;// 都是获取远程的XXX信息。
getLocalXXX() ;// 都是获取本地的XXX信息。
重定向
1、什么是重定向？
重定向(Redirect)就是通过各种方法将各种网络请求重新定个方向转到其它位置
2、在web应用中如何完成资源的跳转？
第一种方式: 请求转发。
第二种方式：重定向。
3、转发和重定向有什么区别?
转发：
request.getRequestDispatcher(path).forward(request,response).
不管转发多少次，都是一次请求。AServlet转发到BServlet，再从BServlet转发到CServlet，不管转发了多少次，都在同一个request当中。
因为调用forward方法的时候，会将当前的request和response对象传递给下一个Servlet。
path：带“/”表示从应用的根路径开始虚拟拼接。
path：不带“/”表示从当前Servlet所在的路径开始虚拟拼接。
比如AServlet的请求路径是“localhost:8080/servlet01/a/b/c/tas”.
再AServlet中有一个request.getRequestDispatcher("tbs").forward(request,response),这行代码执行之后，
就会从AServlet所在的路径下找tbs。AServlet所在的路径是：“localhost:8080/servlet01/a/b/c”
所以就会在“localhost:8080/servlet01/a/b/c”的基础上拼接上tbs，结果就是：localhost:8080/servlet01/a/b/c/tbs.
重定向：
response.sendRedirect(path)
path:如果带“/”就代表是从服务器的根路径下开始寻找，多以带“/”就得加上项目名。【绝对路径】
path:如果不带“/”就代表从当前路径下寻找。【相对路径】
比如AServlet的请求路径是“localhost:8080/servlet01/a/b/c/tas”
AServlet中有一个response.sendRedirect("tbs"),执行到这行代码的时候。
就会从AServlet所在的路径下寻找tbs。AServlet所以在的路径是“localhost:8080/servlet01/a/b/c”
所以就会在“localhost:8080/servlet01/a/b/c”的基础上拼接上tbs，结果就是：localhost:8080/servlet01/a/b/c/tbs.
3.1、转发和重定向唯一不同的就是以“/”开始的绝对路径：
转发：以“/”开始代表应用的根路径。
重定向：以“/”开始代表服务器的根路径。
4、重定向和请求转发再形式上有什么区别？
请求转发：一次请求，转发完成之后浏览器地址栏上的地址不发生改变。
重定向：一次重定向两次请求，n次重定向n+1次请求，重定向之后浏览器地址栏上的内容发生改变。
请求转发和重定向都可以连续多次。
请求转发使request对象去调用方法，重定向使response对象去调用方法。
5、转发和重定向本质有什么区别？
转发：是由web服务器来控制的。A资源跳转到B资源这个动作是由Tomcat服务器内部完成的。
重定向：是浏览器完成的，具体跳转到那个资源是浏览器说了算。
因为请求转发是服务器内部完成的，所以请求转发可以访问到WEB-INF下面的资源，
重定向是前端发送过去的请求，不能直接访问WEB-INF下面的资源。
6、转发和重定向怎么选择?
如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet当中吧request域里面的数据取出来，使用转发机制
剩下所有的请求均使用重定向。（重定向使用较多）
7、跳转的下一个资源不一定必须是一个Servlet，跳转的资源只要是服务器内合法的资源即可。
8、转发存在浏览器的刷新问题。
Servlet注解，简化配置
1、分析oa项目的web.xml文件
只是一个简单的crud，没有复杂的业务逻辑，很贱的一丢丢功能。web.xml文件中就有如此多的配置信息
如果采用这种方式，对于一个大的项目来说，这样web.xml就会非常庞大，可能最终会达到几十兆。
再web.xml文件中进行Servlet信息的配置，显然开发效率比较低，团队中每一个人都需要用这一个web.xml文件配置。
而且再web.xml文件中的配置是很少被修改的，所以这种信息能不能直接写到java类当中？
必须可以。
2、Servlet3.0之后，推出了各种Servlet基于注解式开发。优点是什么？
开发效率高，不需要编写大量的配置信息。直接在java类上使用注解进行标注。
web.xml文件的体积变小了。
3、并不是有了注解之后web.xml文件就不需要了：
有一些需要变化的信息，还是需要配置到web.xml文件中。一般都是 注解+配置文件 的开发模式。
一些不会经常修改的配置建议使用注解。一些可能会被修改的配置建议写到配置文件中。
4、jakarta.servlet.annotation.WebServlet
@WebServlet有那些属性？
name：用来指定Servlet的名字。等同于
urlPatterns:用来指定Servlet的映射路径。可以是多个字符串。和value的作用相同。等同于
value:用来指定Servlet的映射路径，当注解名是value的时候，使用注解的时候value可以省略【前提是使用注解的时候只有一个value属性】
loadOnStartUp:用于指定服务器在启动阶段是否实例化Servlet。等同于:
initParams:用来指定当前Servlet的初始化参数，等同于
initParams的属性值是：@WebInitParam 类型的，WebInitParam注解有两个属性
name:用来指定初始化参数的名字，等同于
value：用来指定初始化参数的值，等同于
5、在任何地方直接对象使用的格式都是：
@注解名称(属性名=属性值,属性名=属性值,属性名=属性值,属性名=属性值,....)
6、Servlet映射路径的模糊匹配：
只要请求是以“/dept”开始的，都走这个Servlet。
@WebServlet("/dept/*")
错误写法：
@WebServlet("/dept/**")
@WebServlet("/dept/*/*")
会话技术（session）
1、什么是会话？
绘画的英语单词：session
用户打开浏览器进行一系列操作，然后最终关闭浏览器，这个整个过程叫做：一次会话。
会话在服务器端有一个Java对象叫做session。【在Java的Servlet规范当中，session对应的类名是HttpSession（jakarta.servlet.http.HttpSession）】
什么是一次请求：用户在浏览器上点击了一下，然后到页面停下来，可以粗略的认为是一次请求，请求对应的服务器端的Java对象是request。（如果存在重定向那么就有多次请求）
一次会话中包含多次请求。（一次会话对应N次请求）
2、session机制属于B/S结构系统的一部分，不是Java特有的。如果用PHP开发web项目，同样也有session这种机制。
session实际上是一种规范不同语言对这种会话机制都有实现。
3、session对象的主要作用就是：保存会话状态。【用户登录成功了，这是一种登录成功的状态，你怎么把登录成功的状态一直保存下来呢？使用session对象可以保留会话状态。】
4、为什么需要session对象来保存会话状态呐？
因为Http协议是一种无状态协议。
什么是无状态：请求的时候B和S是连接的请求结束之后，连接就断了。
为什么要这做？Http协议为什么设计成这样？
因为无状态的协议，可以降低服务器的压力，请求瞬间是连接的，请求结束之后连接断开，这样服务器压力小。
只要B和S断开了，再一次浏览器在发送请求的时候，服务器以为是一个全新的请求，并不认为是原来的哪个浏览器发送过来的。
全新的请求就全新呗，这有什么关系呐？如果第一次请求是登录的请求，已经登录成功了，只有登录成功的用户才能进入系统内部，
如果第一次请求用户登录成功了，第二次请求想进行系统内部数据的操作，如果服务器把第二次请求认为是一次全新的请求，就不能进行数据的操作，
所以需要使用session对象保存用户登录的状态。
在服务器端使用session对象记录用户的状态要比不同计算机两个不同应用之间一直建立连接省劲得多。
5、在同一个浏览器上，同一段时间段内，访问某一个服务器的同一个应用，使用的session对象是用一个对象。
6、为什么不使用request对象保存会话的状态？为什么不用ServletContext对象保存会话的状态？
request.setAttribute()存，request.getAttribute()取，ServletContext对象也有这个方法。request是请求域，ServletContext是应用域。
request是一次请求一个对象，ServletContext是一个应用一个对象。
request再一次请求中有效，ServletContext再服务器启动的时候创建，在服务器关闭时销毁。
ServletContext对象域太大。
request请求域(HttpServletRequest),session会话域(HttpSession)，application应用域(ServletContext)
request
以下这行代码的作用是：用request对象中的sessionId从服务器中获取session对象，如果没有session对象，则新建。
HttpSession session = request.getSession();
这行代码很神奇，张三访问的时候获取的是张三的session，李四访问的时候获取的session对象就是李四的。
8、session的实现原理
1、session使用的是session超时机制。【服务器端的session对象超时自动销毁】
2、一个session对应一个会话。
3、一次会话中包含多次请求。
4、session对象怎么获取？
HttpSession session = request.getSession();
以上代码表示：从服务器端获取session对象，如果没有获取到任何session对象则新建。
HttpSession session = request.getSession(false);
以上代码表示：从服务器端获取session对象，如果获取不到，则不会新建，返回一个null；
5.session的实现原理：
再web服务器中有一个session列表。类似于map集合。
这个map集合的key存储的是sessionid
这个map集合的value存储的是session对象
用户发送第一次请求的时候：服务器会新建一个session对象，同时给session对象生成一个sessionid
然后web服务器会将sessionid发送给浏览器，浏览器将sessionid保存在浏览器的缓存中（以cookie的形式保存的）。
【所以第一次请求的时候浏览器中没有sessionid并不会发送sessionid给服务器】
浏览器发送第二次请求的时候，会自动将浏览器缓存中的sessionid自动发送给服务器，服务器取到sessionid
然后从session列表中找到对应的session对象。
6、为什么浏览器关闭的时候，会话结束？
关闭浏览器之后，浏览器中保存的sessionid消失，下次重新打开浏览器的之后，
浏览器的缓存中没有这个sessionid，自然找不到服务器中对应的session对象。
session对象找不到等同于会话结束。
实际上session对象使用的是session超时机制。当服务器里的这个session对象一定时间没有被访问的时候这个session对象被销毁。
7.什么是浏览器缓存？
就相当于ServletContext对象是Tomcat服务器的缓存一样，服务器关闭ServletContext对象自动消失。
缓存就是将数据存放到了一个能快速拿到的区域当中。这个区域也是内存中的一部分。就像ServletContext对象再JVM内存中一样。
8.session对象的销毁销毁？
一种是超时销毁：【Tomcat服务器默认的销毁方式】
超时销毁：超时的时间是可以配置的，再web.xml文件中
不设置session的超时时间，默认也是30分钟。
一种是手动销毁：【安全退出使用的手段】
9.会话结束：
第一种：浏览器端的sessionid没有了，所以关闭浏览器会话一定结束。
第二种：服务器端的session对象没有了【超时销毁，或者手动销毁】，所以浏览器不关闭会话可能结束,重启服务器会话一定结束。
9、没有经过网络，浏览器不会发送sessionid给服务器。
直接访问本地的一个html页面request Header里不会携带cookies的sessionid。
10、cookie禁用了还能找到session吗？
cookie禁用就是：服务器正常发送cookie给浏览器，但是浏览器不要了，拒收了，并不是服务器不发了。
找不到了，每一次请求都会获取到新的session对象。
11、session实验
1.如果浏览器请求的页面没有使用到session对象【没有request.getSession()这个方法或者其他获取session对象的方法】
那么服务器不会生成并发送sessionid给浏览器，浏览器第二次请求也不会携带sessionid给服务器。
2.如果浏览器请求的页面使用到了session对象【存在request.getSession()这个方法或者其他获取session对象的方法】
那么服务器会生成session对象，并且发送sessionid给浏览器，浏览器会cookie的形式（键值对）保存在浏览器的缓存中。
浏览器第二次请求的时候会携带这个sessionid给服务器。
第一次：S给B发送的响应【在响应头中的信息，请求头中不会有JSESSIONID】
Set-Cookie: JSESSIONID=FF68B6626123F3859E6F51B5473E759A; Path=/servlet02; HttpOnly
Set-Cookie：表示设置cookie的意思，表示sessionid以cookie的形式存储在浏览器当中，多个键值对之间使用分号分隔。
JSESSIONID=FF68B6626123F3859E6F51B5473E759A;：表示cookie中的一个键值对，这个键值对就是sessionid，用来寻找服务器中的session对象的
Path=/servlet02; 这个表示浏览器请求的路径是“/servlet02”(或者它的所有子路径)的时候会携带这个“JSESSIONID”给服务器
【这个路径“/servlet02”一般都是应用的根路径，所以就是：一个用户一个应用一次会话对应一个session对象】
HttpOnly：表示仅http协议有效。
第二次：B给S发送的请求【在请求头中的信息，响应头中不会再有新的JSESSIONID】
Cookie: JSESSIONID=FF68B6626123F3859E6F51B5473E759A
如果重启了服务器，服务器中多有的session对象会被清除，浏览器中原本有一个“JSESSIONID=FF68B6626123F3859E6F51B5473E759A”发送给了服务器
服务器中没有找到对应的session对象，会新建一个session对象，发送给浏览器，这是cookie中键值对的键值相同，服务器生成的这个新的session的JSESSIONID的value发送给浏览器
浏览器原来的哪个JSESSIONID会被覆盖。
3.jsp本身内置session对象，所以访问jsp页面的时候肯定用到了session对象。
可以通过以下方法禁用session：
<%@ session="false" %>
false:表示禁用session
true：表示启用session
12、cookie禁用了，session机制还能实现吗？
可以需要使用URL重写机制。
http://localhost:8080/servlet02/xyh;jsessionid=1D684FCFFCB14DF033981FB5417EAD05
URL后面跟的是“;”后面加一个jsessionid的键值对
URL重写机制会提高开发者的成本。开发人员在编写任何请求路径的时候，后面都要添加一个sessionid，给开发带来了很大的难度，很大的成本。所以大部分的网站都是这样设计的：你要是禁用cookie，你就别用了。
但是有小部分客户可能是程序员，他为了系统的安全，就是禁用cookie，使用URL重写机制的jsessionid的值还要是动态的，这个没办法只能增加系统的开发成本。
13、URL重写机制和请求头哪个优先级更高？【请求头】
【如果浏览器发送请求的时候请求头中带有sessionid，我们使用URL重写机制也重写了sessionid，那么就以浏览器发送的请求头中的sessionid为准】
如果是第一次请求，因为浏览器缓存中并没有sessionid，我们发送请求的时候请求头中并不会携带sessionid。
我们使用URL重写机制，
如果我们重写的这个jsessionid在服务器中已经存在与之对应的session对象，那么服务器就不再新建session对象，
所以也不会在返回响应的sessionid，所以响应头中也没有sessionid。
如果我们重写的这个sessionid在服务器端没有与之对应的session对象，那么服务器会创建新的session对象，生成这个session对象sessionid
所以在相应头中会返回新的sessionid。
14、反正就本着一个原则：
重写和请求头中sessionid同时存在的时候，以请求头中为主。
在服务其中找到了与之对应的sessionid则不新建，肯定也不会响应，没找到则新建
如果有session对象新建，则在响应头中有对应的sessionid响应给浏览器。
15、session对象为什么用request对象来获取？
因为request对象中封装了请求报文：请求行、请求头、空白行、请求体
而sessionid就在请求头中，所以使用request对象类获取。
HttpSession session = request.getSession();
代表：使用request对象的getSession方法获取session对象。
利用request中的sessionid与服务器中存储session对象的map集合的key进行比对。
如果找到了则返回map集合中key对应的value，如果没找到则新建一个map集合的键值对，
键：session对象
值：sessionid
16、销毁session对象：
session.invalidate();
17、案例：有可能张三在A浏览器上进行操作访问服务器上的资源，登陆成功的状态存储到了Asession对象中，Asession对象的sessionid被服务器返回到A浏览器上
李四在B浏览器上进行操作访问服务器上的同一个资源，没有登录，但是李四知道记录张三登录的哪一个session的sessionid，通过URL重写机制可以找到张三的登陆状态从而使登陆环节失效。
18、session对象的常用方法：
1.String getId(); 获取sessionid。
2.long getCreationTime(); 获取创建此会话的时间戳
3.long getLastAccessedTime(); 返回该会话对象最后一次被访问的时间戳
4.int getMaxInactiveInterval(); 获取最大不活动间隔,session的过期时间
5.ServletContext getServletContext(); 获取ServletContext对象
6.Object getAttribute(String name);通过name获取
7.Enumertation
8.void setAttribute(String name,Object obj);向会话域中设置元素
9.void removeAttribute(String name);通过name删除会话域中的属性
19、session对象不能自己new，cookie对象能自己new。
20、session对象的jsessionid存储到cookie中的默认的挂载路径是应用的根路径。
Tomcat为我们创建的这个session对象在通过加密算法生成的JSESSIONID这样的Cookie对象，
调用cookie对象的setPath(request.getContextPath())方法设置Cookie对象的挂载路径，为应用的根路径。
【JSESSIONID是:Java Session Id的简称，因为Tomcat是Java写的也只能用作Java的服务器所以就叫做JSESSIONID了】
总结到目前为止我们了解的域对象
1、request(对应的类名：HttpServletRequest)
请求域（请求级别的，一个请求一个）
2、session（对应类名：HttpSession）
会话域（用户级别的，一个用户一个）
3、application（对应的类名：ServletContext）
应用域（项目级别的，一个项目一个）
4、这三个域的大小关系：
request
void setAttribute(String name,Object obj);向域中绑定数据
Object getAttribute(String name);从域中获取数据
void removeAttribute(String name);从域中删除数据
6、使用原则，尽量使用较小的域。
Cookie
1、session的实现原理中，每一个session对象都有一个sessionid，
例如：JSESSIONID=41C481F0224664BDB28E95081D23D5B8
以上这个键值对其实就是cookie对象。【键值相同后面的value覆盖前面的value】
cookie的键和值都是字符串。
对于session关联的cookie来说这个JSESSIONID，这个cookie是被保存在浏览器运行内存当中的，并且挂载的路径是应用的根路径
Tomcat创建了cookie对象，并且设置了他的过期时间是负数或者没有设置（以下是Tomcat的伪代码）：
Cookie cookie = new Cookie("JSESSIONID","41C481F0224664BDB28E95081D23D5B8");//创建一个cookie对象
cookie.setMaxAge(-1);//设置cookie存储在浏览器的运行内存中，或者没有这行代码，默认也是存在浏览器的运行内存中
cookie.setPath(request.getContextPath());//设置挂载路径是应用的根路径
response.addCookie(cookie);//吧JSESSIONID响应给浏览器客户端
只要浏览器不关闭，用户再次发送请求的时候，只要是这个cookie对象挂载的这个路径，会自动将这个路径关联的cookie发送给服务器。
服务器是根据JSESSIONID这个Cookie来查找session对象的。
2、cookie怎么生成？cookie保存在什么地方？cookie有什么用？浏览器什么时候会发送cookie，发送那些cookie给服务器？
cookie在服务器端生成。
cookie最终是保存在浏览器客户端上的。
可以保存在运行内存中。（浏览器只要关闭cookie就消失了）
也可以保存在硬盘文件中。（只要不过期，永久保存）
cookie有啥用？
cookie和session机制都是为了保存会话的状态。
cookie是将会话保存在浏览器客户端上，session是将会话保存在服务器端上。
为什么要有cookie和session机制？因为http是无状态无连接的协议。
3、126邮箱中有一个功能：十天免登录
这个功能也需要cookie实现。
用户输入正确的用户名和密码同时选择十天免登录的复选框，登录成功后。
浏览器客户端会保存一个cookie（这个cookie是由服务器生成的），这个cookie保存了用户名和密码等信息，
这个cookie是保存在硬盘文件中的，十天有效。在十天内用户再次访问126的时候，浏览器自动提交126关联的cookie给服务器
服务器接收到cookie之后，获取用户名和密码验证，通过之后，自动登录。
怎么让cookie失效？
十天过后自动失效。
修改密码。
在客户端上清除cookie。【硬盘上的cookie和内存中的cookie都可以清除】
4、cookie机制和session机制其实不属于Java中的机制，实际上cookie机制和session机制都是属于HTTP协议的一部分
PHP开发中也有cookie和session机制，只要你是做web开发不管你是什么编程语言，cookie和session都是很重要的。
5、Http协议中规定：任何一个cookie都是由name和value组成的。name和value都是字符串类型的。
6、在Java的servlet中对cookie提供了那些支持呐？
提供了一个Cookie类专门用来表示Cookie数据。jakarta.servlet.http.Cookie
Java程序怎么把cookie数据发送给浏览器呐？response.addCookie(Cookie cookie)
7、在Http协议中是这样规定的：
当浏览器发送请求的时候，会自动携带该path下的cookie数据给服务器。
可以通过cookie的setPath(String path)设置该cookie对象挂载到了哪个path下。
8、cookie的有效时间：
怎么使用Java设置cookie的有效时间？
cookie.setMaxAge(int timeOut);这是cookie的过期时间是timeOut秒。
如果没有设置有效时间默认保存在浏览器的运行内存当中，浏览器关闭则cookie消失。
如果这只了有效时间:有以下三种情况
有效时间>0：这个cookie一定会存储到硬盘文件当中。
有效时间=0：同名cookie被删除
有效时间<0: 保存在运行内存当中，和不设置一样的效果。
9、如果一个cookie挂载在“/a”路径上，
那么访问“/a”路径或者此路径的所有子路径都会，携带此cookie。
10、通过cookie对象的setPath(String path)方法可以设置cookie挂载的路径：
如果不设置cookie挂载的路径的话：自动挂载到当前路径的父路径【当前路径所在的目录】
如果访问的路径是：http://localhost:8080/servlet02/a/b/c/xyh
那么他就会自动挂载到：http://localhost:8080/servlet02/a/b/c
如果设置的路径：cookie.setPath("/a/b")【假设服务器的根路径是 http://localhost:8080/】
那么就是挂载到服务器的根路径下的这个路径：http://localhost:8080/a/b
11、浏览器发送cookie给了服务器，服务器中的Java程序怎么获取cookie对象？
Cookie[] cookies = request.getCookies(); // 如果浏览器没有提交任何cookie那么cookies就是null
if (cookies != null) {
for (Cookie cookie : cookies) { // 遍历浏览器这次请求提交的所有的cookie对象
String name = cookie.getName(); // 获取当前cookie对象的name
String value = cookie.getValue();// 获取当前cookie对象value
}
}
11.1、为什么用request对象获取cookie：
因为cookie信息通过请求头提交给服务器，请求头中共的信息都封装在request对象当中。
12、删除获取cookie，对cookie的一系列操作：
对于在浏览器客户端的运行内存中和硬盘文件上的操作是一样的。
13、Cookie类的常用方法：
构造方法：
Cookie(String name,String value)
成员方法：
1.void setMaxAge(int expiry); 设置cookie的有效时间，以秒为单位
int getMaxAge(); 获取cookie的过期时间，以秒为单位
2.void setPath(String path); 设置cookie的挂载路径
String getPath(); 获取cookie的挂载路径
3.String getName(); 【cookie对象是一个键值对】用于获取cookie的名字(key)
4.String getValue();【cookie对象是一个键值对】用于获取cookie对象的值(value)
void setValue (String newValue) 【给cookie设置一个新的值（value）】
14、经过测试：不同路径下可以存在同名cookie。
Set-Cookie: name=xueyinghao; Path=/user/xyh
Set-Cookie: name=wangyunxia; Path=/user/xyh1
cookie是以路径为单位的，操作哪个路径写的cookie一定要通过setPath设置到对应的路径。
15、cookie的有效时间是用：setMaxAge(int time)设置的，是以秒为单位的，默认是保存在浏览器的缓存当中，浏览器关闭则失效
session的有效时间是用：默认是30分钟
idea通用：
1、idea中的“External Libraries”是外部库的意思。
在“Project Settings”项目结构的“Project”中设置SDK（就是JDK的位置）之后，
jdk中所有的jar包就会在“External Libraries”下面显示。
“External Libraries”就是我们在系统的环境变量中配置的“classpth”
“External Libraries”根“classpath”功能一样，都是帮助我们编译程序的，和运行期没有关系。
“External Libraries”中的“library root”是类的根路径的意思。
2、如果我们需要使用多个第三方库（jar包）来进行编译：
在项目结构下面“Modules”可以设置模块的依赖“Dependencies”,
可以直接添加“jars or Directories”就是直接添加jar包。
也可以直接添加“library”，我们可以通过“Libraries”来添加常用库“多个jar包”组成一个库。
3、对于web项目：“External Libraries”中主要是idea的classpath让编译通过的，和运行没有关系，也不会部署到服务器中。
对于web项目WEB-INF下面的lib是需要部署到tomcat服务器中的，和编译没有关系，这是运行的时候依赖的第三方jar包。