JavaWeb了解之开门篇

目录
  1. 概念
  2. 配置Tomcat
  3. 创建Web项目（手动，基本不使用该方式）
  4. 创建Web项目（MyEclipse、IDEA）

开发动态Web资源的Java技术统称为JavaWeb。

1. 概念

Web即网页：Internet主机里供外界访问的资源。
资源分为：
  1. 静态Web资源
    涉及技术：HTML、CSS、JavaScript、VBScript等。
  2. 动态Web资源
    涉及技术：JSP/Servlet、ASP、PHP等。
/*
用户在Web浏览器（客户端）中输入网址访问页面，会经过网络连接到Web服务器（服务端），并使用HTTP协议向Web服务器发起请求： 

1. 静态Web资源访问流程
  Web服务器收到请求后，从文件系统中取出相应文件 并将文件内容返回给浏览器进行解析显示。
  缺点：Web内容无法动态更新；无法连接数据库。

2. 动态Web资源访问流程
  所有请求都先经过一个WEB Server Plugin（服务器插件）处理，如果请求的是静态Web资源（.html、.js、.css、.jpg）则将请求直接转交给Web服务器，处理同上；如果请求的是动态Web资源（*.jsp、*.asp/*.aspx、*.php）则将请求转交给WEB Container（WEB容器），在WEB容器中连接数据库取出数据，进行相关逻辑业务处理然后拼凑出展示页面内容后将内容交给Web服务器，由Web服务器将该内容发送回客户端浏览器进行解析显示。
*/

静态Web资源访问流程

动态Web资源访问流程

JavaWeb应用（供浏览器访问的应用程序，即网站）
  由多个静态web资源（如：.html、.css、.js、.png）、动态web资源（如：jsp、Servlet）、其他资源（Java类、配置文件、依赖jar包）组成，可以在Servlet容器（即Web容器，由Web服务器提供）中运行。
  Servlet规范规定（便于Servlet容器寻找JavaWeb应用的各文件）：JavaWeb应用必须采用固定的目录结构（不同类型的文件有严格的存放规则，见下图），否则不仅可能会使web应用无法访问，还会导致web服务器启动报错。
    1. JavaWebApp（Web应用的根目录，名称自定义）必需
      存放：该Web应用的所有资源。
    2. WEB-INF目录（名称固定。必须以这样的形式命名，字母全大写，中间是-）必需
      存放：
        1. web.xml（JavaWeb应用的配置文件，名称固定，且必须放在WEB-INF目录下）必需
          其内容可参考Tomcat安装目录/webapps/ROOT/WEB-INF目录下的web.xml文件。
        2. lib目录（存放依赖jar包）
        3. classes目录（存放.class类）
  部署应用
    项目开发完成后若想供外界访问，则需把web应用部署到web服务器中，这个过程称之为虚似目录映射。
    以Tomcat为例，通常将JavaWeb应用存放到Tomcat的webapps目录（webapps目录下每一个子目录都是一个独立的Web应用，子目录的名字就是Web应用的名字，也被称为Web应用的上下文根，用户可以通过这个上下文根来访问JavaWeb应用中的资源）下，默认情况下Tomcat会自动加载webapps目录下的所有JavaWeb应用，并发布到名为localhost的虚拟主机中。
      1. Tomcat既可以运行采用开放式目录结构（只编译不打包）的Web应用。
        将（按上述规范创建的）JavaWeb应用的所有文件直接复制到webapps目录下。
        用于开发阶段，便于调试。
      2. Tomcat也可以运行Web应用的打包文件（.war文件、.jar文件）。
        将项目打包（方式1. 使用IDE打包；方式2. 在终端执行jar -cvf hello.war hello命令会生成hello.war包）后放到webapps目录下，Tomcat会自动将打包文件转为开放式的目录结构。
        用于发布阶段。
/*
Servlet（基于Java实现的动态Web开发技术）
  Java是一种功能强大的通用型编程语言，可以处理HTTP请求、访问数据库、生成HTML代码，完全可以使用原生Java来开发动态网站，但会非常麻烦（需要自己解析HTTP请求的报头、自己分析用户的请求参数、自己加载数据库组件等）。 Java官方推出的Servlet对开发动态网站需要使用的原生Java API进行了封装，形成了一套新的API，称为Servlet API。使用Servlet开发动态网站非常方便，使开发员专注于业务逻辑，不再需要编写基础性通用功能的代码；完全可以胜任企业级开发，能够处理那些高并发、大吞吐量、业务逻辑复杂的应用场景。
  Servlet规范
    Servlet只是一套JavaWeb开发的规范（技术标准）。只有规范并不能做任何事情，还必须有实现（真正编写代码去实现Servlet规范提到的各种功能，包括类、方法、属性）。
    Servlet规范是开放的，除了Sun公司，其它公司也可以实现Servlet规范，目前常见的实现了Servlet规范的产品包括：Tomcat、Weblogic、Jetty、Jboss、WebSphere等，它们都被称为“Servlet 容器”（用来管理程序员编写的Servlet类）。
  Servlet接口
    所有的Servlet功能都是通过一个名为Servlet的接口向外暴露的，编写Servlet代码需要实现Servlet接口（implements Servlet），直接实现Servlet接口比较麻烦（需要实现很多方法），所以Servlet规范又提供了两个抽象类：GenericServlet类和HttpServlet类（开发中使用最多），它们都实现了Servlet接口的很多常用功能。
  Servlet属于第一代JavaWeb开发技术（将HTML代码以字符串的形式向外输出），编写HTML文档就是在拼接字符串，非常麻烦。Java官方又推出了第二代JavaWeb开发技术：JSP（在Servlet的基础上做了进一步封装）。

JSP
  允许HTML代码和JSP代码分离，让程序员能够在HTML文档中直接嵌入JSP代码（JSP代码可以调用Servlet类，程序员可以将部分功能在Servlet中实现，然后在JSP中调用）。 
  JSP依赖于Servlet，当用户访问JSP页面时，JSP代码会被翻译成Servlet代码，最终HTML代码还是以字符串的形式向外输出的。
*/

JavaWeb应用结构

部署动态网站一般至少需要三个组件：
  1. Web服务器
    对外提供Web服务的软件（可以接收浏览器的HTTP请求，并将处理结果返回给浏览器）。
    通常所说的Web服务器（Apache、IIS、Nginx等传统意义上的服务器），功能比较单一（只能提供http/https服务），只能允许用户访问静态资源（html页面、图片、css文件、js文件等），不能执行任何编程语言，不能访问数据库，更不能进行注册登录、发表文章评论等功能。
    如果只有Web服务器，则只能部署静态网站，不能部署动态网站。要想部署动态网站，则必须要有编程语言运行时和数据库的支持。 
  2. 脚本语言运行时/运行环境（以下各种支持脚本语言运行的部件的统称）
    1. 解释器（执行脚本语言的核心部件）
      开发动态网站使用的编程语言一般都是脚本语言（如：Servlet/Jsp、PHP、ASP、Python），源代码自己并不能运行，必须要有解释器的支持。当用户访问动态页面时，解释器负责分析、编译和执行源代码，然后得到处理结果。
    2. 垃圾回收器
      负责及时释放不需要的内存，腾出资源供其它页面使用。
    3. 标准库
      任何编程语言都会附带标准库（提供了很多通用性的功能），极大地提高了开发效率，避免重复造轮子。
    Servlet是基于Java实现的动态Web开发技术，运行Servlet需要：
      1. JDK/JRE（Java运行环境）
        包含了JVM虚拟机、Java核心类库、一些辅助性性文件。
        负责解析和执行.class字节码文件。
      2. Servlet容器（Servlet运行环境）
        实现了Servlet规范定义的各种接口和类，为Servlet的运行提供底层支持；
        管理开发员创建的Servlet类：创建/销毁实例对象、调用方法；
        提供HTTP服务（相当于一个简化的Web服务器，但足以应付大部分开发场景）。
    常用的Web容器：Tomcat、Jboss、Jetty、WebLogic等。
  3. 数据库
    数据库是一款独立的软件，Web服务器和编程语言都不自带数据库。要想实现用户注册、发布文章、提交评论等功能，就必须安装一款数据库。
    常用的数据库有：MySQL、Oracle、SQL Server。

Web容器
  为了简化部署流程，Web容器往往会自带Web服务器模块（提供基本的HTTP服务），可以不用再安装Apache、IIS、Nginx等传统意义上的服务器，只需要安装一款Web容器就能部署Servlet网站了。
  
  用户的HTTP请求首先到达Web服务器，Web服务器判断该请求是静态资源还是动态资源：如果是静态资源就直接返回（相当于用户下载了一个服务器上的文件）；如果是动态资源将无法处理，必须将该请求转发给Servlet容器。Servlet容器接收到请求以后，会根据web.xml配置文件找到并加载对应的Servlet类，创建实例对象并调用其方法来处理用户请求；处理结束后，Servlet容器将处理结果再转交给Web服务器，由Web服务器将处理结果进行封装，以HTTP响应的形式发送给最终的用户。

常见的Web服务器
  1. Tomcat（初学者最常使用）
    一个实现了JavaEE标准的最小的WEB服务器。
    优点：免费开源、占用资源少、扩展性好、运行稳定、支持负载均衡、易于学习和使用。
  2. WebLogic
    用于开发、集成、部署和管理大型分布式Web应用、数据库应用。
  3. Jetty
  4. JBoss
  5. WebSphere
  6. IIS
    IIS是一种Web服务组件，包含了Web服务器（网页浏览）、FTP服务器（文件传输）、NNTP服务器（新闻服务）、SMTP服务器（邮件发送）。    
    提供了一个图形界面管理工具（Internet信息服务管理器），可用于监视配置和控制Internet服务。
    ASP/ASP.NET网站一般选择部署在IIS服务器中。
  7. Nginx
    PHP网站一般部署在Apache或Nginx服务器中。

Servlet容器：Servlet的运行时环境；JRE：Java的运行时环境

2. Tomcat的下载和常用配置

下载Tomcat（MAC）

不同Tomcat版本支持的Java（JDK）版本不同，根据自己的JDK/JRE版本选择对应的Tomcat版本

Tomcat版本	Servlet规范	JSP规范	EL规范	WebSocket规范	认证（JASIC）规范	JDK/JRE 版本
10.0.x	5.0	3.0	4.0	2.0	2.0	8 以及更高
9.0.x	4.0	2.3	3.0	1.1	1.1	8 以及更高
8.5.x	3.1	2.3	3.0	1.1	1.1	7 以及更高
7.0.x	3.0	2.2	2.2	1.1	N/A	6 以及更高

从官网下载Tomcat

选择Core下的tar.gz

目录说明:
  1. bin目录
    存放：启动和关闭Tomcat服务器的脚本文件。
    常用：
      1. startup.sh/.bat：用来启动Tomcat。
      2. shutdown.sh/.bat：用来关闭Tomcat。
      3. catalina.bat/.bat：用来设置Tomcat的内存。
  2. conf目录
    存放：Tomcat服务器的各种配置文件（server.xml为核心配置文件）。
    常用：
      1. server.xml：用来设置域名、IP、端口号、默认加载的项目、请求编码等。
      2. context.xml：用来配置数据源等；
      3. tomcat-users.xml：用来配置和管理Tomcat的用户与权限；
      4. web.xml：用来设置Tomcat支持的文件类型；
      5. 在Catalina目录下可以设置默认加载的项目。 
  3. lib目录
    存放：Tomcat服务器运行时依赖的jar包。
  4. logs目录
    存放：Tomcat服务器运行时产生的日志文件（清空该目录中的文件不会对Tomcat的运行带来影响）。
      1. 在Windows系统中，控制台的输出日志保存在catalina.xxxx-xx-xx.log文件（如：catalina.2012-10-02.log）中。
      2. 在Linux系统中，控制台的输出日志保存在catalina.out文件中。 
  5. temp目录
    存放：Tomcat服务器运行时产生的临时文件（清空该目录中的文件不会对Tomcat的运行带来影响）。
  6. webapps目录
    存放：供外界访问的web应用/网站（Tomcat启动时会去加载该目录下的所有Web应用）。
  7. work目录（Tomcat服务器的工作目录）
    存放：Tomcat服务器运行时生成的编译文件（class字节码文件），如：.jsp编译后的文件。
    清空该目录后需要重启Tomcat。

===》看一下server.xml文件，内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
  <GlobalNamingResources>
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>
  <Service name="Catalina">
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <Engine name="Catalina" defaultHost="localhost">
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />
      </Host>
    </Engine>
  </Service>
</Server>
Tomcat服务器的启动基于server.xml文件。
  1. Tomcat启动时首先会创建一个Server，Server会创建一个Service，Service会创建多个Connector(连接器) 等待客户机的连接。
  2. 当用户使用浏览器去访问服务器上面的web资源时，首先是连接到Connector(连接器)，Connector(连接器)是不处理用户的请求的，而是将用户的请求交给一个Engine引擎去处理。
  3. Engine引擎接收到请求后就会解析用户想要访问的Host，然后将请求交给相应的Host。
  4. Host收到请求后就会解析出用户想要访问这个Host下面的哪一个Web应用,一个web应用对应一个Context标签。

Tomcat工作原理

Tomcat服务器的启动、关闭

1. 将下载的压缩包解压后，将目录更名为Tomcat，然后移到/Library目录下。
2. 在终端执行
  cd /Library/Tomcat/bin。
  sudo sh startup.sh 开启服务（出错则加权限：chmod +x *.sh）
  // sudo sh shutdown.sh 关闭服务器
3. 浏览器输入：http://localhost:8080/ ，若页面正常显示则表示配置成功。

修改服务器端口（当端口发生冲突时需要修改）

修改conf目录下的server.xml文件中的Connector节点的port字段。
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

注意：修改配置文件后需要重启Tomcat服务器才能生效。

虚拟目录映射（3种方式）

Web应用开发好后，若想供外界访问，需要把web应用交给web服务器管理，这个过程称之为虚似目录映射。

方式1. 在server.xml文件的host元素中添加Context（Java6后不再建议使用这种方式，因为每次修改后都要重启服务器）
  <Host name="localhost"  appBase="webapps"
             unpackWARs="true" autoDeploy="true"
             xmlValidation="false" xmlNamespaceAware="false">
         <Context path="/JavaWebApp" docBase="项目所根目录所在路径" />
   </Host>
说明：
  1. Context表示上下文，代表一个JavaWeb应用。
  2. path：映射的虚拟目录。
  3. docBase：应用根目录所在路径。
  4. 在浏览器中访问 http://localhost:8080/JavaWebApp/hello.jsp进行测试

方式2. 让Tomcat服务器自动映射
  Tomcat服务器会自动管理其webapps目录下的所有web应用并映射成同名的虚似目录（即外界可直接访问）。

方式3. 在Tomcat服务器的conf/Catalina/localhost目录下添加一个xml文件（文件名即为映射路径），在xml中添加<Context docBase="项目所根目录所在路径" />。
  修改xml文件名（即映射目录）后不需要重启Tomcat。

配置虚拟主机

需要在conf目录下的server.xml文件中创建新的Host元素。

server.xml文件中默认有一个Host。
  平时在浏览器中输入的地址"http://localhost:端口号/hello"，访问的就是name为localhost的那台虚拟主机(Host)管理的webapps下的hello项目。
  <Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="true">
  </Host>

添加一个新的虚拟主机
  <Host name="com.sst.cx"  appBase="JavaWebapps">
  </Host>
配置的主机要想通过域名被外部访问，必须在DNS服务器或本机中注册域名。

本机注册域名
  1. windows系统
    在C:\Windows\System32\drivers\etc目录下的hosts文件中添加
      127.0.0.1   com.sst.cx
    将com.sst.cx域名和本机的ip地址进行绑定。
  2. MAC系统
    终端输入sudo vi /etc/hosts命令，在hosts文件中添加
      127.0.0.1   com.sst.cx

当在浏览器中输入http://com.sst.cx:8080/hello/hello.jsp访问com.sst.cx所对应的服务器的hello项目的hello.jsp资源时，浏览器会进行如下操作：
  1. 首先根据域名(主机名)从本操作系统的Hosts文件中查找域名对应的IP地址。如果没有找到，则会从互联网的DNS服务器上查询。
  2. 查找到IP地址后，连接IP地址对应的Web服务器。
  3. 连接上Web服务器后，使用HTTP协议向服务器发送请求（请求消息的请求行中指明了想请求的web应用资源：/helo/hello.jsp，请求头中通过Host字段指明了要访问的主机名及端口：com.sst.cx:8080）。浏览器进入等待状态（等待服务器返回资源）。
  4. 服务器收到请求后进行解析，然后去获取对应资源放入响应数据返回给浏览器。
  5. 浏览器将响应数据解析后，将内容展示在页面中。

浏览器与服务器交互图

https连接

Tomcat服务器启动时候会启动多个Connector(连接器) 分为加密连接器和非加密连机器。

对称加密
  采用单钥密码系统的加密方法。通信双方使用同一个密钥，该密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密（单密钥加密）。
  加密过程是一个不可逆过程，即只有用私有密钥才能解密。
  常用的对称加密有：DES、IDEA、RC2、RC4、SKIPJACK、RC5、AES算法。
  安全性：因为加密和解密都使用同一个密钥，如何把密钥安全地传递到解密者手上就成了必须要解决的问题。

非对称加密
  非对称加密算法需要一对密钥：公开密钥（publickey）和私有密钥（privatekey）。如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。 

非对称加密的工作原理和过程
  1. A和B之间想通信（即相互发送信息），就需要各自产生一对用于加密和解密的公钥和私钥。A的私钥保密，公钥告诉B；B的私钥保密，公钥告诉A。
  2. A向B发送信息时，会用B的公钥加密（签名）后再发送。
  3. B收到消息后再用私钥解密（验签）。
  其他所有收到这个报文的人都无法解密，因为只有B才有B的私钥。

  安全性：相互发送公钥时仍然存在被第三方拦截的安全隐患（第三方拦截双方的公钥后，发送自己的公钥给双方进行通讯）。
  A如何确定拿到的公钥一定是B发的？解决这个问题只能靠一个第三方机构(CA机构，即证书授权中心，或称证书授权机构)来担保。A想向B发数据，B首先将公钥发给CA机构，CA机构拿到B的公钥后跑到B的家里问：这是你发的公钥吗？B确认过后说是：没错，是我发的！那么此时CA机构就会为B的公钥做担保，生成一份数字证书给B，数字证书包含了CA的担保认证签名和B的公钥，B拿到CA的这份数字证书后，就发给A，A拿到数字证书后，看到上面有CA的签名，就可以确定当前拿到的公钥是B发的，那么就可以放心使用公钥加密数据，然后发给B了。

首先生成数字证书并在服务器中进行配置，让服务器收到浏览器的请求之后，会向浏览器出示它的数字证书。浏览器看到数字证书后，就可以使用数字证书里面的公钥加密数据。

1. 生成数字证书
  在终端输入 keytool -genkey -alias tomcat -keyalg RSA -keystore hello.keystore 命令生一个名为tomcat的证书，不指定-keystore时存放在.keystore文件中（通过ls -all可以查看到）
// 转为PKCS12格式
// keytool -importkeystore -srckeystore /Users/cx/hello.keystore -destkeystore /Users/cx/hello.keystore -deststoretype pkcs12

查看.keystore文件中的所有证书
  keytool -list -keystore hello.keystore

2. 将hello.keystore复制到Tomcat服务器的conf目录下,在sever.xml中添加加密Connector。
<Connector port="8686" protocol="HTTP/1.1"
               connectionTimeout="20000"
               maxThreads="150" SSLEnabled="true" scheme="https" secure="true"
                clientAuth="false" sslProtocol="TLS" 
                keystoreFile="conf/hello.keystore" keystorePass="123456" />

重启Tomcat（关闭再开启）
在浏览器中访问https://localhost:8686/

点击高级，点击接受风险，会自动安装证书（火狐）

删除数字证书（火狐）

3. 创建Web项目（手动）

实际开中不使用该方式（效率低下、容易出错）。

===》1. 按照上述目录规范创建如下目录结构：
  HelloWeb目录
    WEB-INF目录
      classes目录
      web.xml配置文件

===》2. 创建HelloServlet.java，在终端使用javac命令编译生成HelloServlet.class并移动到classes目录中。
package com.sst.cx;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter writer = response.getWriter();
        writer.write("Hello World!");
        writer.close();
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}
/*
编译Java源代码的2种方式：
  1. 在终端使用javac进行编译
    在终端中执行：
      1. set classpath = /Library/Tomcat9/lib/servlet-api.jar 为当前窗口设置临时环境变量,或者将servlet-api.jar复制到JDK安装目录/
        Servlet是JavaEE下的技术标准，不是JDK的组成部分，所以在编译Servlet前，需要先引入servlet-api.jar包（位于JDK安装目录/Contents/Home/jre/lib/ext目录下）
      2. javac -encoding UTF-8 -d . HelloServlet.java 编译HelloServlet.java类
        说明：
          1. javac ：编译命令。
          2.  -encoding UTF-8 ：指定编译源文件时的字符编码。
          3. javac -d ：带包编译。
          4. . ：表示当前位置。
  2. 使用IDE进行编译（使用方便，但隐藏了编译过程中的许多细节，无法了解其中的原理和机制）
*/

===》3. 在 web.xml配置文件为HelloServlet添加URL映射。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.sst.cx.HelloServlet</servlet-class>
    </servlet>
   <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/HelloServlet</url-pattern>
    </servlet-mapping>
</web-app>
说明：
  1. <web-app>：根元素。
  2. <servlet>：用于注册Servlet。
    <servlet-name>：指定Servlet的名称，该名称需要唯一。
    <servlet-class>：指定Servlet的完整限定名（包名+类名）。
  3. <servlet-mapping>：与<servlet>成对出现，用于给Servlet添加URL映射。
    <servlet-name>：必须与对应的<servlet>中的<servlet-name>相同。
    <url-pattern>：URL映射（虚拟路径）。

===》4. 启动Tomcat
在终端下执行
  cd /Library/Tomcat9/bin/
  sudo sh startup.sh
在浏览器中访问http://localhost:8080/HelloWeb/HelloServlet
说明：
  1. http：表示使用HTTP协议。
  2. localhost：表示服务器域名（在hosts文件中将localhost和当前主机的IP地址进行了绑定）。
  3. 8080：表示端口号。
  4. /HelloWeb：表示该Web应用的上下文根路径。
  5. /HelloServlet：表示要访问的资源的路径（此处为<url-pattern>中配置HelloServlet对应的URL映射）。

浏览器中访问

4. 创建Web项目（使用IDE）

开发工具（任选其一）：MyEclipse(默认自带Tomcat)下载、Eclipse下载、IDEA下载

使用MyEclipse

1、项目栏空白处，右键 创建web项目
2、选中项目，右键 运行项目
/*
src目录下存放所有的Java文件，编译后会生成.class文件并存储在WEB-INF目录/classes目录下。
WebRoot目录对应web应用的根目录，该目录下所有的子目录/文件在部署时会原封不动的发布到web应用目录下。
*/

项目栏空白处右键

选中项目右键

运行结果

3、在src下创建包：com.sst.cx
4、在包下创建Servlet
    访问时路径http://localhost:8080/ProjectTestOne/TestServlet,因为doGet没有任何代码，所以会显示空白页面。
  新版本：
    @WebServlet("/TestServlet")    注解映射（自动配置映射，无需手动在web.xml去配置映射）
  以前的版本：
    会在web.xml中自动生成如下代码(映射配置)，而不是使用注解
    <servlet>
      <description>This is the description of my J2EE component</description>
      <display-name>This is the display name of my J2EE component</display-name>
      <servlet-name>TestServlet</servlet-name>
      <servlet-class>com.sst.cx.TestServlet</servlet-class>
    </servlet>
    <servlet-mapping>
      <servlet-name>TestServlet</servlet-name>
      <url-pattern>/TestServlet</url-pattern>
    </servlet-mapping>

在包下创建Servlet

创建的TestServlet.java文件

5、小试牛刀。
  修改doGet方法并运行，然后刷新页面（再次访问该Servlet）：
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
        out.println("<HTML>");
        out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");
        out.println("  <BODY>");
        out.print("    This is ");
        out.print(this.getClass());
        out.println(", using the GET method");
        out.println("  </BODY>");
        out.println("</HTML>");
        out.flush();
        out.close();
    }

运行结果（修改后的Servlet界面）

MyEclipse配置Tomcat
  Window | Show View | servers  出现视图后右键添加Server（选择/Library/Tomcat/）

使用Eclipse

创建Web项目、创建Servlet、运行

第1步. 点击File->New->Project 或者 项目栏右键->New->Project。
第2步. 选择项目类型（常用的有：Java Project、Maven Project、Dynamic Web Project）选择Dynamic Web Project。
第3步. 填写JavaWeb项目名，配置运行时环境；点击Next；勾选生成web.xml文件，点击Finsh。
第4步. 创建包路径，在包路径下创建HelloServlet.java类。
第5步. 运行项目，在浏览器中访问http://localhost:8080/HelloWeb/HelloServlet。
/*
可能遇到的错误：
  1. 运行项目后，没有生成class文件。
    解决：使用JDK1.8版本进行编译。
*/

第1步. 点击File->New->Project

第1步. 项目栏右键->New->Project

第2步. 选择项目类型

第3步. 填写JavaWeb项目名，配置运行时环境

点击Next

勾选生成web.xml文件，点击Finsh

生成的Web目录结构

创建包路径-1

创建包路径-2

创建Servlet-1

创建Servlet-2，填写Servlet名

创建Servlet-3，配置Servlet的URL映射

创建Servlet-4，勾选需要赋写的方法

创建Servlet-5，修改Servlet内容

运行项目

选择之前配置的Tomcat服务器

使用IDEA

1. 创建普通的java项目：
  File｜New｜Project｜输入项目名，点击Create创建
2. 添加WebFramwork支持：
  右键项目｜Add Framework Support | Web Application
  添加支持后，会自动：在根目录下创建web目录，web目录下创建WEB-INF目录、index.jsp文件，WEB-INF目录下创建web.xml文件。
3. 添加Servlet依赖包（创建文件时才会新增Sevlet选项）：
  在WEB-INF目录下创建lib目录，并在lib目录下添加servlet-api.jar。
  File｜Project Structure｜Modules｜Dependencies下 点击加号｜JARs or Directories 选择servlet-api.jar。
5. 配置Tomcat
  Run｜Edit Configurations｜点加号｜Tomcat Server｜Local｜选择Tomcat目录 
6. 在Tomcat中部署项目
  Tomcat配置｜Deployment | 点击加号｜点击Artifact添加
  修改Application context路径（Server选项卡下面的URL会同步修改）
  注意：Deployment选项卡下面的Application context路径要和Server选项卡下面的URL后面的路径一致。
7. 运行
8. 小试牛刀
  在src下创建包，创建HelloServlet文件，修改doGet方法：
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("hello world");
    out.flush();
    out.close();
  运行（http://localhost:8080/hello/HelloServlet）
/*
可能遇到的错误：
1. jakarta.servlet.ServletException
方案1: 换成Tomcat 9版本
方案2:
*/

创建普通的java项目

添加WebFramwork

添加servlet-api.jar

现在可以创建Servlet文件了，没配置依赖包前是没有Servlet选项的

配置Tomcat

在Tomcat中部署项目