JavaEE初阶（12）HTTPS（“加密“ 、对称加密、非对称加密、所谓证书、Tomcat内容介绍和下载安装、部署静态页面、初识Servlet、第一个 Servlet 程序）

di-Dora

已于 2023-11-03 11:44:29 修改

阅读量159

点赞数

分类专栏： JavaEE 重难知识点前端网络文章标签： java-ee HTTPS Tomcat servlet 网络网络编程加密

于 2023-10-24 21:36:54 首次发布

本文链接：https://blog.csdn.net/m0_74343467/article/details/134019110

版权

重难知识点同时被 3 个专栏收录

33 篇文章 1 订阅

订阅专栏

JavaEE

31 篇文章 0 订阅

订阅专栏

前端网络

10 篇文章 0 订阅

订阅专栏

接上次博客：JavaEE初阶（11）HTTP 协议（发展历程、报文格式、URL、HTTP请求详解、HTTP 响应详解、构造HTTP请求、form 表单构造、AJAX的方式构造）-CSDN博客

2. 部署带有 CSS / JavaScript / 图片的 HTML

4. HttpServletRequest 和 HttpServletResponse

5. 使用 resp.getWriter()

HTTPS

当前网络上主要都是HTTPS，很少见到HTTP。

HTTPS（Hypertext Transfer Protocol Secure）是基于HTTP的升级版本，我们前面讲解的HTTP的各个方面的内容也适用于HTTPS。只不过它添加了加密层以保护数据的安全传输。HTTP是一种明文传输的协议，这意味着在传输过程中数据是未经加密的，可以被中间人截取和窃听。

运营商劫持：

商场路由器任何人都可以访问，如果有黑客入侵这个路由器，并对这个路由器的数据包进行抓包分析，甚至把自己伪装成商场路由器一样的设备。你设备访问网络的数据就是经过黑客设备的数据……

HTTPS通过使用SSL/TLS（Secure Sockets Layer/Transport Layer Security）协议来加密通信，确保数据在传输过程中是加密的，不容易被第三方窃听或篡改。这为用户提供了更高的隐私和安全。

HTTPS的工作原理简要如下：

客户端发起HTTPS请求，请求与服务器建立安全连接。
服务器返回其SSL证书，其中包含公钥。
客户端验证证书的合法性，并使用服务器的公钥来生成一个对称密钥。
客户端将生成的密钥传输到服务器，同时告知服务器它准备好了。
服务器使用私钥解密客户端传来的对称密钥，然后使用这个对称密钥来加密通信。
之后的通信都使用对称密钥加密，保证数据的机密性和完整性。

HTTPS的广泛采用是因为它提供了更高的安全性，尤其对于敏感信息（如个人资料、信用卡信息等）的传输，以及保护用户免受网络攻击的威胁。在今天的互联网中，大多数网站都采用HTTPS以确保数据的隐私和安全。

"加密" 是什么

加密是一种信息安全技术，用于将明文（原始数据）转换为密文（经过变换的数据），以防止未经授权的访问或窃取，确保数据在存储或传输时不被未经授权的人访问或修改。解密则是将密文还原为明文的过程。这样的加密和解密过程通常依赖于密钥（或密码），作为辅助数据来执行加密和解密操作。

密钥在加密和解密中起着关键的作用，因为只有拥有正确密钥的人或实体才能够成功解密密文，获得原始的明文信息。加密的目的通常是确保数据的保密性（防止未经授权的访问）、完整性（防止数据被篡改）和认证性（确保数据来自可信的源）。

不同的加密算法和协议使用不同的方法来执行加密和解密操作，以确保数据的安全性。在网络通信和数据存储中，加密是一种重要的安全实践，它用于保护用户的隐私信息和敏感数据。

让我们更详细地了解下：

加密 (Encryption)：
- 过程：将明文信息转化为无法直接阅读的密文信息。
- 目的：确保数据的隐私，使其在传输或存储时不被轻易解读。
解密 (Decryption)：
- 过程：将密文信息还原为其原始的明文形式。
- 目的：使经过授权的用户能够访问和理解原始数据。
密钥 (Key)：
- 定义：在加密和解密过程中使用的一段随机数据。密钥的选择和保护至关重要，因为它决定了加密的强度和安全性。
- 类型：通常分为两种，私钥和公钥。
  - 私钥：在对称加密中使用的密钥，加密和解密使用同一密钥。
  - 公钥：在非对称加密中使用的一对密钥中的一个，与之配对的另一个称为私钥。公钥用于加密，私钥用于解密。
加密算法：
- 这是进行加密和解密的方法。常见的加密算法包括AES、DES、RSA等。

使用正确的加密技术可以确保数据的机密性和完整性，防止未经授权的访问。在今天的数字化世界中，加密已经成为数据安全的基石，无论是在线交易、密码存储还是保护机密信息，加密都起到了关键的作用。

HTTPS 的工作过程

既然要保证数据安全, 就需要进行 "加密"。

网络传输中不再直接传输明文了，而是加密之后的 "密文"。加密的方式有很多，但是整体可以分成两大类：对称加密和非对称加密。

以下是HTTPS的工作过程的简要描述：

建立连接：当客户端（如浏览器）发起一个HTTPS请求时，它首先与服务器建立一个TCP连接。
开始TLS/SSL握手：这个握手过程主要是为了在客户端和服务器之间协商一个共同的加密协议和加密算法，并且为接下来的通信创建一个安全的加密通道。
服务器证书：在握手的过程中，服务器会提供一个公钥证书。这个证书由一个公认的证书颁发机构（CA）签名，并且包含了服务器的公钥。
非对称加密：客户端验证服务器证书的有效性和真实性。如果证书有效，客户端会生成一个随机的对称加密的密钥（通常称为会话密钥）。然后，客户端使用服务器的公钥对这个会话密钥进行加密，并将其发送给服务器。
密钥解密：服务器接收到加密的会话密钥后，使用自己的私钥进行解密，从而获得会话密钥。
对称加密通信：此时，客户端和服务器都拥有相同的会话密钥。他们开始使用该对称密钥进行通信，所有发送的数据都用此密钥加密，接收到的数据也用此密钥解密。因为对称加密相对于非对称加密在速度上更快，所以适合用于大量数据的加密和解密。
结束通信：当通信结束时，会话密钥被丢弃，确保即使有攻击者窃取了会话密钥，也不能用它来解密其他会话中的数据。

简而言之，HTTPS使用非对称加密来安全地交换对称加密的密钥，然后使用对称加密进行数据通信，这样结合了两种加密方式的优点，即非对称加密的安全性和对称加密的效率。

引入对称加密

对称加密是一种加密技术，它使用相同的密钥来加密和解密数据。这意味着用于加密数据的密钥必须与用于解密数据的密钥相同。

对称加密算法非常快速，因此在许多应用中被广泛使用。

以下是对称加密的一些重要概念和特点：

密钥：对称加密使用相同的密钥来加密和解密数据。这意味着保护密钥的安全非常重要，因为任何人拥有该密钥都可以解密加密的数据。
加密过程：在加密过程中，明文数据和密钥一起传递给加密算法，产生密文。这个密文只能使用相同的密钥才能解密。
解密过程：在解密过程中，密文和相同的密钥一起传递给解密算法，以恢复原始的明文数据。
速度：对称加密算法通常非常快速，适合加密和解密大量数据。这使得它们在许多应用中非常有用。
常见的对称加密算法：一些常见的对称加密算法包括AES（高级加密标准）、DES（数据加密标准）、3DES（三重DES）等。
密钥管理：由于密钥的安全性至关重要，密钥管理是使用对称加密的关键问题。密钥必须安全存储，并且只有合法的用户能够访问它。

对称加密非常适用于需要高性能和快速加密/解密的情况，但它也有一个主要的缺点，即密钥管理的挑战。如果密钥不安全，那么整个系统的安全性就会受到威胁。因此，在一些情况下，公钥加密和对称加密结合使用，以解决密钥分发和管理的问题，这就是混合加密系统的概念。

总结一下就是：对称加密其实就是通过同一个 "密钥" ，把明文加密成密文，并且也能把密文解密成明文。

设密钥为key，明文+key => 密文；密文+key => 明文。

一个简单的对称加密，按位异或：

假设明文 a = 1234，密钥 key = 8888

则加密 a ^ key 得到的密文 b 为 9834。

然后针对密文 9834 再次进行运算 b ^ key，得到的就是原来的明文 1234。

(对于字符串的对称加密也是同理, 每一个字符都可以表示成一个数字)

当然，按位异或只是最简单的对称加密。 HTTPS 中并不是使用按位异或。

引入对称加密之后，即使数据被截获，由于黑客不知道密钥是啥，因此就无法进行解密，也就不知道请求的真实内容是啥了。

但事情没这么简单。

服务器同一时刻其实是给很多客户端提供服务的！这么多客户端，每个人用的秘钥都必须是不同的（如果是相同那密钥就太容易扩散了, 黑客就也能拿到了）。

于是就需要每个客户端在和服务器建立连接的时候就把密钥生成出来（涉及到一些随机数机制，保证每次生成的客户端密钥都不一样），客户端再把自己的密钥传输给服务器。

同时，服务器就需要维护每个客户端和每个密钥之间的关联关系，这也是个很麻烦的事情。

刚刚我们说，比较理想的做法，就是能在客户端和服务器建立连接的时候，双方协商确定这次的密钥是啥。

服务器需要记录，客户1的密钥是A，客户2的密钥是B，客户3……

但是如果直接把密钥明文传输，那么黑客也就能获得密钥了。此时后续的加密操作就形同虚设了。因此密钥的传输也必须加密传输！

但是要想对密钥进行对称加密，就仍然需要先协商确定一个 “密钥的密钥”。这就成了 “先有鸡还是先有蛋” 的问题了……

此时密钥的传输再用对称加密就行不通了，就需要引入非对称加密。

引入非对称加密

非对称加密，也被称为公钥加密，是一种加密技术，与对称加密不同，它使用一对密钥，一个称为公钥，另一个称为私钥。这两个密钥是配对的，且加密和解密过程使用不同的密钥。以下是非对称加密的一些重要概念和特点：

公钥和私钥：非对称加密使用一对密钥，公钥和私钥。公钥是可公开的，任何人都可以使用它来加密数据。私钥必须保持机密，只有密钥的拥有者可以使用它来解密数据。
加密过程：如果使用公钥加密数据，只有拥有相应私钥的实体才能解密它。这使得公钥可用于安全地传递数据，因为即使公钥被泄露，数据仍然安全。
解密过程：解密过程使用私钥，只有拥有私钥的实体能够解密数据。
速度：相对于对称加密，非对称加密的速度通常较慢，因此在大量数据的加密和解密方面可能效率较低。
常见的非对称加密算法：一些常见的非对称加密算法包括RSA（Rivest-Shamir-Adleman）、DSA（数字签名算法）和ECC（椭圆曲线加密）等。

非对称加密的加密过程背后的数学原理涉及数论和复杂的数学算法。最常见的非对称加密算法之一是RSA（Rivest-Shamir-Adleman），以下是RSA加密的简要数学原理：

生成密钥对：首先，密钥生成过程包括生成一对密钥，即公钥和私钥。这是通过选择两个大素数（通常为 p 和 q）来实现的。

计算模数 n：计算一个大的合成模数 n，它等于 p 和 q 的乘积，即 n = p * q。这个模数 n 在整个加密和解密过程中都会使用。

计算欧拉函数 φ(n)：计算 n 的欧拉函数（φ函数），它表示小于 n 且与 n 互质的正整数的数量。φ(n) = (p-1) * (q-1)。

选择公钥：选择一个公钥（e），它必须满足以下条件：1 < e < φ(n) 且 e 与 φ(n) 互质。通常，e 被设置为较小的质数，如 65537，因为它加速了加密操作。

计算私钥：计算私钥（d），它是 e 模 φ(n) 的模反元素。即 (e * d) mod φ(n) = 1。

加密过程：发送方使用接收方的公钥 (e, n) 来加密消息 M。加密操作是通过执行 M^e mod n 计算得到的。

解密过程：接收方使用自己的私钥 (d, n) 来解密消息。解密操作是通过执行 C^d mod n 计算得到的，其中 C 是加密后的消息。

RSA算法的安全性建立在大整数因式分解问题的困难性上，即从 n 中分解出 p 和 q。如果 n 较小，分解 n 就相对容易，但如果 n 很大，这个问题变得非常困难，因此保护好私钥是至关重要的。其他非对称加密算法如椭圆曲线加密（ECC）使用了不同的数学原理，但也追求相似的安全性原则。

服务器生成一对公钥私钥，服务器把公钥返回给客户端，服务器自身把私钥藏好。

与此同时，黑客也可能拿到公钥。

客户端仍然生成对称密钥，使用服务器的公钥对对称密钥进行加密，得到密钥的密文。

但是即使黑客拿到客户端加密后的对称密钥，也是无能为力的，因为公钥加密需要私钥解密，而私钥只有服务器才有！

服务器手里持有私钥，就很容易的解密出对称密钥，得到原始的对称密钥。

接下来客户端和服务器就使用这个对称密钥加密即可。

理论上来说，黑客拿到公钥之后也是有可能推算出私钥是什么。但是实际上这个推算过程计算成本极高，计算量非常大，至少需要好几年（不久的将来，量子计算机，那就不好说了~~~）。所以还不如想办法黑掉服务器呢。

非对称加密的最大优势在于其密钥管理和安全性。由于公钥是可公开的，数据可以被安全地传递给任何人，只有私钥的拥有者能够解密。这使得非对称加密在数字签名、密钥交换、身份验证和安全通信等领域非常有用。在实际应用中，通常会结合对称加密和非对称加密以取得各自的优势。

非对称加密最大的缺点就是运算速度非常慢，比对称加密要慢很多。

它通过公钥对明文加密, 变成密文通过私钥对密文解密，变成明文。

也可以反着用：

通过私钥对明文加密，变成密文；通过公钥对密文解密，变成明文。

非对称加密的数学原理比较复杂，涉及到一些数论相关的知识。这里我来举一个简单的生活上的例子简单说明：

A想要安全地传递文件给B，但由于B可能不在，他们需要一种安全的方法。
B提供了一个公共容器，即桌子上的盒子，这个盒子可以被任何人访问。这个公共容器相当于公钥。
B提供了一把锁，这个锁是公开的，就像公钥一样。任何人都可以使用这个锁来锁住文件，但只有B能够打开它。
A持有一个私钥，即钥匙，这是唯一能够打开B的锁的东西。只有A持有这把私钥，因此只有A能够锁住文件。
A使用B的提供的锁（即公钥）将文件放入盒子中并锁上，以确保只有B能够解锁盒子并访问文件。
B只有他独有的私钥，即钥匙，能够打开锁，解锁盒子，并获取文件。

在这个例子中，公钥是公共的，任何人都可以使用它来锁住文件，但只有持有私钥的B才能够解锁文件。这模拟了非对称加密，其中公钥用于加密，私钥用于解密，确保只有私钥的拥有者能够访问加密的数据。

客户端在本地生成对称密钥，通过公钥加密，发送给服务器。
由于中间的网络设备没有私钥，即使截获了数据，也无法还原出内部的原文，也就无法获取到对称密钥。
服务器通过私钥解密，还原出客户端发送的对称密钥。并且使用这个对称密钥加密给客户端返回的响应数据。
明文+公钥=>密文；密文+私钥=>明文。
或者反过来：明文+私钥=>密文；密文+公钥=>明文。
后续客户端和服务器的通信都只用对称加密即可。由于该密钥只有客户端和服务器两个主机知道，其他主机/设备不知道密钥即使截获数据也没有意义。

由于对称加密的效率比非对称加密高很多，因此只是在开始阶段协商密钥的时候使用非对称加密，后续的传输仍然使用对称加密。

你可能会疑惑，既然已经引入了非对称加密，为什么还要保留对称加密？直接使用非对称加密来完成所有业务数据的加密传输不就好了？

进行非对称加密/解密运算成本是非常高度，运算速度也比较低下。而对称加密运算成本低，速度快。

引入安全性、引入加密，势必就会影响效率，我们当然也希望这样的影响能尽可能降到最低。

所以我们就使用非对称加密只是用来进行关键环节（传输密钥）（一次性的工作、体积也不大），成本就比较可控。如果业务数据都使用非对称加密，整体的传输效率就会大打折扣。

接下来问题又来了：客户端如何获取到公钥？客户端如何确定这个公钥不是黑客伪造的？

这也是所谓的“中间人攻击”。

"中间人攻击"（Man-in-the-Middle Attack，缩写为MitM攻击）是一种网络安全攻击，其中攻击者插入自己在两个通信方之间，拦截、篡改或窃取它们之间的通信数据。这种攻击通常发生在客户端和服务器之间的通信中，攻击者伪装成服务器对客户端进行通信，同时伪装成客户端与服务器进行通信。中间人攻击的目标是窃取敏感信息、篡改数据或植入恶意软件，而通信的两个方都认为它们在与合法的对方通信。

中间人攻击的工作原理如下：

监听通信：攻击者监控通信渠道，通常通过网络嗅探技术来实现。他们可以在客户端和服务器之间的通信路径上或网络上的某个位置进行监听。

伪装服务器：当客户端尝试与服务器建立连接时，攻击者伪装成服务器与客户端通信，同时伪装成客户端与服务器通信。客户端和服务器都认为它们在与合法的对方通信。

数据篡改：攻击者可以查看、篡改或窃取通信的数据。他们可以修改传输的数据，以实现攻击目标，例如截取登录凭证、修改数据包或注入恶意软件。

隐蔽攻击：中间人攻击通常是隐蔽的，受害者通常不会察觉到它们正在受到攻击。

啧啧，简直和碟中谍一样……

之所以能进行中间人攻击，关键要点就在于客户端没有分辨能力。

确保客户端获得合法且未被篡改的公钥是非对称加密中的一个关键问题，以下是一些常见的方法：

数字证书颁发机构（CA）：CA是第三方机构，其任务是验证并签发公钥证书。在这种情况下，客户端可以信任CA，并相信CA签发的证书中包含的公钥是合法的。Web浏览器和服务器之间的SSL/TLS通信通常使用CA颁发的证书来确保通信的安全性。
指纹或哈希值：在某些情况下，公钥可以通过其他安全的方式传递给客户端，例如面对面会议或通过可靠的通信渠道。在这种情况下，客户端可以检查公钥的指纹或哈希值，以确保它没有被篡改。指纹或哈希值是公钥的短字符串表示，即使公钥被篡改，这些值也会改变。
公共密钥基础设施（PKI）：PKI是一组安全策略和技术，用于确保数字通信的安全性。PKI包括CA、数字证书、证书撤销列表（CRL）等，以确保公钥的合法性和完整性。
密钥钉住（Key Pinning）：密钥钉住是在客户端应用程序中硬编码或配置公钥的方法。这确保了客户端只信任特定的公钥，从而防止中间人攻击。客户端可以实施公钥钉住策略，指定服务器公钥的固定哈希值。这样，只有当服务器返回的公钥的哈希与预期的哈希匹配时，客户端才会信任它。这提供了额外的安全性。
去中心化验证：在某些情况下，没有CA的情况下，例如在某些区块链或分布式系统中，去中心化验证方法可能更适用。在这种情况下，公钥的合法性由多个节点验证，而不依赖于单一的中央授权机构。

无论采用哪种方法，验证公钥的合法性都是确保非对称加密的关键，客户端必须能够确信它们使用的公钥是真实的，没有被篡改，并且只属于合法的实体。

我们下面就来主要看看证书：

引入证书

1. 生成公私钥对

当开发人员准备搭建一个安全的网站或应用程序时，首先要生成一对密钥：公钥和私钥。
这对密钥是用于加密和解密数据的，其中私钥必须始终保持私有，而公钥可以公开。

2. 提交证书申请

开发人员使用公钥以及其他一些信息（如域名、公钥、公司信息等）向一个受信任的第三方（称为证书颁发机构或CA）提交申请，希望获得一个数字证书。
这个数字证书是公钥的公开表现形式，但它有CA的签名，证明其有效性。

3. 证书审核

证书颁发机构会对提交的信息进行审核。
审核的目的是确保申请者有权为指定的域名或应用程序使用该证书，并确保提供的其他信息是准确的。

4. 校验和与数字签名

CA在核准证书后，会为证书内容计算一个哈希值，称为“校验和”。这确保了数据的完整性。
CA随后使用其私钥对这个校验和进行签名，得到一个“数字签名”。

1. 校验和：

校验和是一个在数据传输过程中用于验证数据完整性的数字值。
它是通过将数据中的每个字节输入到特定的校验和算法（如MD5或SHA-256）中计算得出的。
这个算法会将每个字节映射成一个数字，并对它们进行数学运算以生成校验和。
最终，校验和是一个特定长度的数字，它表示了原始数据的内容。
如果数据在传输中发生任何改变，无论是由于意外的数据损坏还是恶意篡改，校验和都会发生变化。

2. 数字签名：

数字签名是一个用于验证数据完整性和来源的加密数据。
它是通过使用非对称加密算法生成的，通常涉及公钥和私钥。
数字签名是对原始数据的哈希值，经过私钥的加密后生成的。
当接收方收到数据和数字签名时，它可以使用发送方的公钥来解密数字签名，得到原始哈希值。
接收方然后对接收到的数据执行相同的哈希计算，得到一个新的哈希值。
如果两个哈希值匹配，说明数据在传输过程中没有被篡改，并且数据的来源是可信的。
如果数字签名无法成功解密或哈希值不匹配，说明数据可能已经被篡改或来源不可信。

5. 证书的颁发和使用

有了数字签名后，CA将其与公钥、证书的有效期、证书持有者信息等一同打包，形成一个SSL/TLS证书，然后发给申请者。
服务器配置了该证书后，当客户端（如浏览器）刚与服务器建立连接时，服务器就会给客户端返回一个证书。这个证书包含了刚才的公钥，也包含了网站的身份信息。

SSL (Secure Sockets Layer) 和 TLS (Transport Layer Security) 是用于加密通信的安全协议。SSL 早期版本用于安全地传输数据，但由于一些安全漏洞，后来被 TLS 取代。TLS 1.0 是 SSL 3.1 的升级版本。这些协议提供了数据加密、认证和数据完整性验证的功能，用于保护信息在网络上的传输。

SSL/TLS 证书是用于建立安全通信的重要组成部分。它们通常由第三方机构（Certificate Authorities，CA）颁发，用于验证服务器的身份。这些证书包括以下信息：

服务器的公钥：用于加密客户端和服务器之间的通信，确保数据在传输过程中不会被窃取。

服务器的标识信息：证书包含服务器的标识信息，通常是服务器的域名，以便客户端确认它正在连接到正确的服务器。

证书的数字签名：证书由 CA 颁发，并用 CA 的私钥进行数字签名。客户端可以使用 CA 的公钥来验证证书的有效性。

SSL/TLS 证书不仅用于 HTTPS（用于安全的网页传输），还可以用于其他安全通信协议，如 SMTP（用于安全的电子邮件传输）、IMAP（用于安全的电子邮件访问）、POP3（用于安全的电子邮件接收）、FTP（用于安全的文件传输）等。它们还在虚拟专用网络 (VPN)、VoIP（语音通信）、远程桌面和其他许多网络通信场景中使用。

总之，SSL/TLS 证书是网络通信安全的重要工具，它们用于确保数据的隐私性和完整性，以及验证服务器的身份，适用于多种网络应用和协议。

你是否还记得我们JDBC里面的

"jdbc:mysql://127.0.0.1.3306/java?characterEncode=utf8&useSSL=false"？

当在 JDBC 连接字符串中设置useSSL=false时，它意味着关闭了 MySQL 客户端与服务器之间的加密连接。这可以对于一些测试环境或者在安全性不是首要考虑因素的情况下使用。

正常情况下，MySQL 的连接通常是通过 SSL（Secure Sockets Layer）或 TLS（Transport Layer Security）加密来保护数据传输的安全性。这意味着数据在客户端和服务器之间的传输是加密的，以防止未经授权的访问和数据泄露。

6. 客户端的证书验证

客户端收到证书后，也就拿到了证书中的公钥。它首先会使用内置的CA公钥（存储在操作系统或浏览器中）对数字签名进行解密，得到原始的校验和，以此验证这个公钥是否是服务器最初的公钥（是否被黑客篡改过？）这个过程就称为“证书的校验和”。
客户端然后会对证书计算一个新的校验和，并与解密得到的校验和进行对比。如果两者匹配，说明证书是有效的且未被篡改。
如何进行校验？核心机制就是“数字签名”，也就是被加密后的校验和。
拿着你数据的每个字节，带入公式，就能算出一个结果数字，称为校验和。把这个数据和校验和一起发送给对方，对方再按照同样的方式再算一遍校验和，如果对方自己算的校验和和收到的校验和一致，就认为数据在传输过程中没有改变过。
转换过来也就是：此时客户端拿到了数字签名就可以通过系统内置的公证机构的公钥进行解密，得到最初的校验和。客户端再重新计算一边校验和，和解密出来的校验和进行对比。如果一致就可以认为证书没有被篡改过，公钥就是可信的（服务器的）。

在上述机制下，黑客就无法对证书内容进行篡改，即使篡改了也很容易被发现。当黑客收到证书之后，如果直接修改里面的公钥，替换成自己的，客户端在进行证书校验的时候就会发现校验和不一致，就会被认为被篡改过（存在安全风险，弹出提示窗口）。

那么黑客替换公钥之后，能否自己替换掉数字签名，自己再算一个呢？

不能！校验和好计算，但是针对校验和加密需要使用公证机构的私钥才能进行。黑客是没有这个私钥的，如果黑客拿自己的私钥加密，客户端也就无法使用公证机构的公钥解密了。而公证机构的公钥又是客户端系统自带的，黑客也无法替换……

综上所述，证书就是可信的，通过了校验，就说明公钥是服务器原始的公钥了。

那么黑客是否能自己也申请一个证书，完全替换掉服务器的证书呢？

不行！申请证书需要提交资料，其中就有网站的主域名，认证机构回去认证的。

证书的作用

证书是用于建立安全通信的关键组件。
证书包含了公钥以及服务器身份信息，用于保障通信的安全性。

证书内容

证书是一个结构化的数据文件，包含多个字段，包括：
- 证书发布机构（Certificate Authority, CA）： 证书的发行者，通常是一个受信任的第三方机构，负责验证证书请求者的身份和颁发SSL证书。
- 证书有效期： 证书的生效和过期日期，确保证书的使用在合理的时间范围内。
- 公钥： 证书中包含服务器的公钥，用于加密和验证通信，确保通信的机密性和完整性。
- 证书所有者信息： 包括网站域名、组织信息、所在国家等，用于确认证书的拥有者身份。
- 数字签名： 用于验证证书的完整性和合法性的重要部分。数字签名是公证机构使用其私钥对证书内容的哈希值进行签名，客户端使用公证机构的公钥来验证这个签名。

在Chrome浏览器中，我们可以按照以下步骤查看受信任的证书发布机构：

打开Chrome浏览器。
点击右上角的菜单图标（三个竖直点）以打开菜单。
在菜单中，选择“设置”选项。
在设置页面的左侧，可以看到“隐私和安全性”部分。在此部分，选择“更多”以展开更多选项。
滚动到“安全性”部分，在那里你将看到“管理证书”选项。单击“管理证书”。
单击“查看证书”按钮，这将打开证书管理器。
在证书管理器中，可以切换到“受信任的根证书颁发机构”选项卡。这里列出了浏览器信任的所有根CA。

在“受信任的根证书颁发机构”选项卡中，我们可以查看受信任的CA列表，这些CA对于浏览器的证书验证过程至关重要。这是Chrome浏览器用于验证网站证书的一部分，以确保安全的HTTPS通信。

证书验证过程

校验证书有效期：客户端首先检查证书的有效期，确保它没有过期。证书包括有效开始日期和截止日期。
检查证书发布机构：客户端验证证书的发布机构是否受信任。通常，操作系统内置一组受信任的根证书颁发机构。
验证证书签名：客户端使用CA的公钥验证证书上的签名。签名是CA使用其私钥对整个证书内容生成的，客户端使用CA的公钥验证签名的合法性。
验证证书完整性：客户端计算整个证书的哈希值，通常使用哈希算法（如SHA-256）。然后，客户端使用CA的公钥对签名进行解密，获得原始的哈希值。
比较哈希值：客户端比较计算的哈希值和从证书中提取的哈希值。如果它们匹配，证明证书未被篡改。

安全通信保障

证书验证机制用于确保客户端与服务器之间的通信是安全的，防止中间人攻击和确保数据的完整性和隐私。

这些步骤和概念构成了SSL/TLS通信中证书验证的关键部分，确保通信的安全性和合法性。

在工作和计算领域中，理解数据摘要和签名的概念非常重要。

理解数据摘要和签名

数据摘要和签名是用于保障数据完整性和验证身份的关键工具。

签名的概念
- 在工作场景中，签名用于批准和确认事物。
- 领导的签名代表他们的意见和认可，使文件有效。
- 不同人的签名独特，可用于区分个体。
数据签名的应用
- 对于数据（例如文档、交易等），数字签名也可以用来验证数据的完整性和来源。
- 数据签名算法通过特定算法生成一个固定长度的签名。
数据摘要
- 数据摘要是一种生成数据的短、固定长度摘要或哈希值的过程。
- 常见的数据摘要算法包括MD5和SHA系列。
- 数据摘要有三个主要特点：
  - 定长：无论输入数据多长，输出的摘要都是固定长度。
  - 分散：微小的数据变化会导致显著不同的摘要。
  - 不可逆：从摘要还原原始数据理论上是不可能的。
MD5（Message Digest 5）
- MD5是一种常见的数据摘要算法。
- MD5生成128位（16字节）的摘要。
- 如果两个数据的MD5值相同，可以认为这两个数据相同。
SHA（Secure Hash Algorithm）系列
- SHA算法系列包括SHA-1、SHA-256、SHA-512等。
- SHA-256生成256位（32字节）的摘要，SHA-512生成512位（64字节）的摘要。
- 较长的摘要长度增加了数据完整性验证的安全性。

数据摘要和签名在网络通信、数据存储、数据完整性验证等方面发挥着关键作用。它们可用于确保数据的完整性、安全性和真实性，是信息安全的基础。

理解判定证书篡改的过程类似于判定身份证是否伪造，而数据摘要（如MD5）在这个过程中起到关键作用。

理解判定证书篡改的过程

证书篡改检测过程类似于检测数据的完整性，它使用数据摘要（哈希值）来验证数据是否被篡改。

证书摘要和完整性验证
- 证书（例如字符串“hello”）通过数据摘要算法（如MD5）生成哈希值（例如BC4B2A76B9719D91）。
篡改后的证书
- 如果证书中的任何部分被篡改，例如“hello”被更改为“hella”，哈希值将发生显著变化（例如BDBD6F9CF51F2FD8）。
客户端验证
- 服务器将原始证书“hello”和其哈希值BC4B2A76B9719D91返回给客户端。
验证证书是否被篡改
- 客户端接收到证书和哈希值后，使用相同的数据摘要算法（MD5）对证书重新计算哈希值。
- 客户端计算的哈希值与服务器返回的哈希值进行比较。
- 如果两个哈希值相同（例如BC4B2A76B9719D91），则说明证书未被篡改。如果哈希值不匹配，说明证书已被篡改。
完整性验证的作用
- 这个过程可以确保数据的完整性，即使数据在传输或存储过程中被篡改，也能被客户端检测到。
- 数据摘要（哈希值）作为一种数据指纹，用于验证数据的真实性和完整性。

通过比较计算的哈希值和原始数据的哈希值，客户端可以确定数据是否在传输过程中被篡改，从而提高了数据的安全性和可信度。这一过程在信息安全和数据完整性验证中非常重要。

完整过程

Tomcat

Tomcat 是什么

Apache Tomcat（通常简称为 Tomcat）是一个开源的Java Servlet容器和JavaServer Pages（JSP）容器。它是由Apache软件基金会开发和维护的。Tomcat的主要作用是为Java应用程序提供一个运行环境，使这些应用程序能够处理HTTP请求、生成动态网页内容和执行Java Servlet。

前面我们已经学习了 HTTP 协议，知道了 HTTP 协议就是 HTTP 客户端和 HTTP 服务器之间的交互数据的格式。同时我们也通过 ajax 和 Java Socket 分别构造了 HTTP 客户端。

HTTP 服务器的基本原理： HTTP 服务器监听来自客户端的 HTTP 请求，并根据这些请求执行相应的操作。这可能包括返回网页、数据或其他资源。我们当然可以选择自己写代码实现（基于TCP socket）
HTTP 客户端： 客户端可以是 Web 浏览器、Postman（用于 API 测试）或爬虫程序。这些客户端生成 HTTP 请求并发送到服务器，然后接收服务器的响应。

我们当然可以选择自己写代码实现（基于TCP socket）HTTP 服务器，但是实际上，一般来说，在日常开发工作中不需要我们从头写。

大佬们已经写好了现成的HTTP服务器，我们只需要去使用或者基于这些HTTP服务器进行二次开发即可，人家的代码已经把如何处理HTTP请求，如何构造HTTP响应都封装好了，我们可以直接调用这些API来构造我们自己的业务逻辑。

Tomcat就是一个基于 Java 实现的开源免费的HTTP服务器，也是被广泛使用的 HTTP 服务器，广泛用于部署Java Web应用程序。它实现了Servlet和JavaServer Pages（JSP）规范，允许开发者构建和运行基于Java的Web应用。

下载安装

下载地址：Apache Tomcat® - Apache Tomcat 8 Software Downloads

关于Tomcat的安装，大家可以参考一下这篇博客，写的蛮清楚的：

CSDN编程社区

目录结构

针对 tomcat 目录解压缩之后，可以看到如下结构：

绿色软件，无需安装，即可使用。

但是有前提，Tomcat是使用Java写的，要求你的电脑上必须得有JDK(至少得有JRE)。

webapps：这是存放 web 应用程序的目录，也就是你的网站项目所在的地方。你可以将你的网站项目文件放在这里，Tomcat 会根据项目的配置自动部署和运行它们。
bin：Tomcat的一些相关可执行脚本，包含启动和停止 Tomcat 服务器的脚本文件，如 startup.bat 用于启动服务器。在不同操作系统上，你可以使用不同的脚本文件。
conf：包含 Tomcat 的配置文件，用于配置服务器的各种参数和行为。通常，这里存放了 server.xml 等重要配置文件。
lib：包含 Tomcat 运行所需的类库文件，一般情况下，你不需要直接操作这个目录。
logs：这个目录包含 Tomcat 运行时生成的日志文件，可以用于排查问题和了解服务器运行情况，是调试一个服务器程序最重要的手段，后续我们写的程序、代码中打印的日志，就可以在这个目录中看到。
temp：临时文件夹，Tomcat 用于存放一些临时文件，不需要用户直接管理。
work：Tomcat 内部使用的工作目录，用于存放一些编译后的文件，对于普通用户来说，不需要关心。

这些目录的理解和管理对于部署和运行 web 应用程序非常重要。通过配置 webapps 目录，我们可以轻松部署和运行自己的 web 应用，而通过查看 logs 目录中的日志文件，我们可以监控服务器的行为和排除问题。

其他目录通常由 Tomcat 自身维护和使用，对于一般用户来说不需要太多关注。

上面目录结构中的 logs，你会不会疑惑——什么是日志？为啥不用调试器？

I. 什么是日志？

日志是一种记录应用程序运行时活动的方法，通常以文本形式记录到文件或数据库中。
日志包含了程序的状态信息、错误消息、警告以及其他相关信息，以便在需要时进行排查和分析。

II. 为什么不使用调试器？

不适合服务器使用：调试器不适合给服务器使用。
- 调试器通常用于本地开发和单步调试，不适合在生产服务器上使用。在服务器上使用调试器可能导致服务器停顿，影响其他客户端的请求响应，造成不可接受的延迟。
断点会导致服务器停止：
- 调试器常常使用断点，当程序执行到断点处时会停止执行。在服务器环境下，这会导致服务器停止响应请求，对生产环境不利。
概率问题：
- 一些问题在服务器端可能涉及到概率或随机性，不容易通过调试器的单步调试解决。
- 通过日志记录，可以捕获各种条件下的数据和状态，用于后续分析。
性能开销：
- 使用调试器会引入额外的性能开销，而在服务器环境中，性能通常是至关重要的。日志记录通常对性能开销更为友好。
实时监控：
- 日志允许实时监控应用程序的运行情况，而调试器通常是单步调试的工具。

III. 日志的优势和缺点

优势：

更好的理解程序执行结果：通过查看日志，可以深入了解应用程序的实际执行情况，包括输入、输出、中间状态等。
关注临时结果和中间值：日志记录可以帮助开发人员关注到临时结果和中间状态，有助于问题诊断。
概率问题的解决：通过记录各种条件下的信息，日志有助于解决概率性问题，提供更多的数据来分析和诊断问题。
实时监控和追踪：日志可以在生产环境中实时监控应用程序的运行情况，帮助发现和解决问题，而不会影响应用程序的正常运行。

缺点：

需要重新编译运行：使用日志调试时，每次添加或更改日志输出语句后，通常需要重新编译和运行程序，以查看日志的变化。
不适合即时调试：日志记录通常是一种事后分析工具，不适合实时调试或追踪问题，因为需要等到日志生成后才能查看。
日志管理开销：维护和管理大量日志数据可能会占用存储空间，需要谨慎配置，以免过度使用磁盘空间。
日志安全性：敏感信息可能会被记录在日志中，需要谨慎处理，以确保日志不泄露敏感数据。

总的来说，日志记录是一种更适合生产服务器环境的工具，它可以提供详尽的信息，帮助开发人员排查问题，而不会对性能和服务器稳定性造成负面影响。

其实上面的目录结构中，我们最关注的目录就是 webapps 目录。

webapps 是 web applications 的简称，意思是用来存放 web 应用的文件夹。每个目录都是一个 webapps（包含了一个网站的前端代码和后端代码）。

这个目录中我们还能见到.war 压缩包文件.war包，即使用tomcat发布程序的一种方式，写好的一个网站就可以打包成拷贝到tomcat的 webapp 里，tomcat就会自动对war进行解压缩，从而完成网站的部署和加载。

I. webapps目录

webapps（Web Applications的缩写）是Tomcat中的重要目录，用于存放Web应用程序文件。
每个子目录代表一个独立的Web应用程序，其中包含前端和后端代码。

II. WAR文件（Web Application Archive）

WAR文件是一种Web应用程序的打包文件格式，通常用于将Web应用程序部署到Tomcat服务器。
WAR文件包含了Web应用程序的所有文件和目录，可以轻松地在不同的Tomcat服务器上部署和共享。
当将WAR文件复制到Tomcat的webapps目录中时，Tomcat会自动解压缩WAR文件，并将Web应用程序部署到服务器中。

III. Web应用程序

一个Web应用程序是一个具有独立完整功能的网站或Web应用，例如搜索引擎或电子商务网站。
Tomcat服务器可以同时部署多个这样的Web应用程序，它们以各自的目录形式存放在webapps目录中。

IV. 示例webapps目录结构

进入webapps目录后，您可能会看到类似以下的子目录：
- docs：包含Tomcat文档的Web应用程序。
- examples：包含Tomcat示例应用程序。
- host-manager：用于管理Tomcat虚拟主机的应用程序。
- manager：用于管理Web应用程序部署的应用程序。
- ROOT：这是默认的Web应用程序根目录，通常对应Tomcat服务器的首页。

每个子目录代表一个独立的Web应用程序，您可以通过浏览器访问每个Web应用程序，以查看其内容和功能。 Tomcat允许您部署自定义Web应用程序，将其放置在webapps目录中，以提供各种Web服务和功能。

启动服务器

.bat就是Windows上的批处理程序，.sh 就是Linux上的shell脚本。

双击上述 startup.bat 就可以启动Tomcat，最终的 Tomcat 就是一个控制台程序。

在 Windows 上通过命令行方式启动 Tomcat 时出现的乱码问题是由于字符编码方式不匹配引起的，具体来说是由于 Tomcat 默认使用 UTF-8 编码处理中文字符，而 Windows 的命令提示符（cmd）默认使用 GBK 编码。

所以要么把tomcat改成GDK，要么把CMD改成UTF8。但是后者在Windows上是非常困难的，CMD本身没有提供编码的设置，可能需要修改注册表……而前者虽然好搞，但是UTF8才是主流，GDK用的更少了。

那我们咋办？？？凉拌！

虽然乱码问题在启动 Tomcat时会出现在控制台输出中，但并不会影响 Tomcat 服务器的正常运行。这个问题通常在命令行界面输出中出现，而不会对 web 应用程序的功能和性能产生负面影响。

当然，还有别的方式，如果你在 Linux 操作系统或使用集成开发环境（如IntelliJ IDEA）的终端来启动 Tomcat，或者在Linux中使用，那么通常不会出现这种乱码问题，因为这些环境默认使用 UTF-8 编码。

如果闪退，最关键的是要看到“报错信息”。

把 startup.bat 拖到CMD中运行，如果闪退，大概率CMD中就能显示出错信息。

1. 端口问题

端口被占用
- Tomcat默认绑定8080和8005端口，其他进程占用这两个端口会导致Tomcat无法启动。
- 使用命令行：netstat -ano | findstr 8080 来查看8080端口是否被其他进程占用。
- 如果被占用，需要终止对应进程，然后重新启动Tomcat。
其他程序占用8080端口
- 有可能电脑上安装了其他程序占用了8080端口，例如Windows自带的HTTP服务器或IIS。
- 确认并关闭其他程序，释放8080端口，然后尝试重新启动Tomcat。

2. 环境变量问题

Tomcat可能无法找到JDK或自身所在的目录，导致启动失败。
在这种情况下，系统会提示缺少特定环境变量。
解决方法是配置所需的环境变量，确保Tomcat能够正常访问JDK和其所在的目录。

启动成功之后，就可以在浏览器中输入 127.0.0.1:8080 即可看到 Tomcat 的默认欢迎页面。

部署静态页面

1. 静态页面概念

静态页面是指页面内容始终保持不变，不受用户、时间、或参数的不同影响。
静态页面的内容只有在网站的开发人员修改源代码时才会发生变化。

2. 静态页面特点

内容固定性：无论用户、时间或输入参数如何变化，页面内容保持不变。
缺乏互动性：用户无法与静态页面进行互动，因为内容不会动态更新。
快速加载：静态页面通常加载速度快，因为不需要服务器端处理或数据库查询。

3. 静态页面与动态页面对比

静态页面：内容不变，加载快，适合不经常变化的信息展示。
动态页面：内容根据用户、时间、或输入参数的不同而变化，通常需要服务器端处理和数据库查询。
动态页面提供了更多互动性和个性化内容，但可能加载较慢。

4. 部署静态页面

创建静态HTML文件：编写静态页面的HTML代码，包括文本、图像和其他媒体。
储存在Web服务器：将静态HTML文件储存在Web服务器的目录中。
可通过浏览器访问：用户可以通过浏览器直接访问静态页面的URL。
更新静态页面：需要修改内容时，编辑HTML文件并重新上传到服务器。

V. 应用领域

静态页面适用于展示不频繁变化的内容，如企业主页、产品目录、新闻通告等。
静态页面的简单性和速度使其在某些情况下成为合适的选择。

1. 部署单个 HTML

我们可以把自己写好的 HTML 部署到 Tomcat 中。

部署单个HTML文件到Tomcat非常简单，只需将HTML文件放入Tomcat的webapps目录中。

以下是一些简单的步骤：

1、创建 hello.html：

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, 
maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>hello</title>
</head>
<body>
    <div>hello</div>
</body>
</html>

2. 把 hello.html 拷贝到 Tomcat 的 webapps/ROOT 目录中：

3. 在浏览器中通过 URL http://127.0.0.1:8080/hello.html 来访问：

具体来说：

创建或准备HTML文件：首先，确保你已经创建了要部署的HTML文件，或者有一个HTML文件准备好部署。
找到Tomcat的webapps目录：通常，Tomcat的webapps目录位于Tomcat服务器的安装目录下。在这个目录中，你会看到像webapps、docs、examples等子目录。将HTML文件复制或移动到webapps目录。
访问HTML文件：一旦HTML文件位于webapps目录中，你可以通过浏览器来访问它。通常，Tomcat会自动识别HTML文件并使其可通过URL访问。
- 如果你的HTML文件名为example.html，你可以在浏览器中输入Tomcat服务器的URL地址，后跟/example.html来访问该文件。例如：http://localhost:8080/yourwebapp/example.html。
Tomcat默认部署：如果你的HTML文件位于Tomcat的webapps目录中的根目录，那么你可以通过以下方式来访问它：
如果HTML文件名为index.html，你可以直接输入Tomcat服务器的URL地址来访问它，例如：http://localhost:8080/yourwebapp/。

注意事项：

确保Tomcat服务器已经启动。
确保你在浏览器中输入了正确的URL路径。
如果你需要在HTML文件中包含其他资源，如CSS文件、JavaScript文件或图像，确保这些资源也在同一目录或子目录中，并在HTML文件中正确引用它们。我们马上就说。
请注意，Tomcat默认的端口是8080，如果你的Tomcat使用不同的端口，请相应地修改URL地址。

tomcat的一个重要作用就是：可以让浏览器通过网络来访问一个HTML页面。

目前，我用tomcat在电脑上部署的网页无法让你直接访问到，因为现在我们不在同一个局域网里。

我只需要把我的网页放到云服务器上，你就可以访问了。

你可以把Tomcat理解为一个底座，我们所编写的网站，都是要架构到这个底座上的，然后才能够被外面的用户顺利访问。（这里仅仅针对Java）

2. 部署带有 CSS / JavaScript / 图片的 HTML

实际开发时我们的 HTML 不仅仅是单一文件，还需要依赖一些其他的资源： CSS、JavaScript、图片等。这些资源也要一起部署过去。

1. 创建 hello2.html：

<!DOCTYPE html>
<html lang="en">

<head>
     <meta charset="UTF-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>静态页面</title>
      <link rel="stylesheet" href="style.css">
</head> 

<body>
     <img src="doge.jpg" alt="">
     <script src="app.js"></script>
</body>

</html>

2. 创建 style.css：

img {
   width: 500px;
   height: 500px;
}

3. 创建 app.js：

console.log("hello");

4. 准备一个 doge.jpg文件：

5. 把以上四个文件都拷贝到 Tomcat 的 webapps/ROOT 中：

6. 在浏览器中通过 http://127.0.0.1:8080/hello2.html 来访问页面。

当需要部署带有CSS、JavaScript和图像等资源的HTML页面时，你可以将这些资源文件一同放在Tomcat的webapps目录中，并在HTML文件中使用相对路径来引用它们。以下是部署带有附加资源的HTML页面的步骤：

准备HTML文件及相关资源：
- 确保你已经创建了包含HTML文件的文件夹，并在该文件夹中包括CSS文件、JavaScript文件和图像等资源。
找到Tomcat的webapps目录：
- 寻找Tomcat服务器的安装目录，并进入webapps目录。
创建一个文件夹（可选）：
- 为你的Web应用程序创建一个文件夹，这是为了将所有文件组织在一起，以便管理和维护。
复制文件：
- 将HTML文件和相关资源文件（CSS、JavaScript、图像等）复制到Tomcat的webapps目录中，或者复制到你为Web应用程序创建的文件夹中。
访问HTML文件：
- 使用浏览器，通过URL来访问HTML文件。如果你创建了一个文件夹，确保URL路径中包括文件夹名称。
- 如果HTML文件名为example.html，你可以在浏览器中输入Tomcat服务器的URL地址，后跟/yourwebapp/example.html来访问它。
相对路径引用资源：
- 在HTML文件中，使用相对路径来引用CSS、JavaScript和图像等资源。相对路径是相对于HTML文件所在位置的路径。
- 例如，如果你的CSS文件在同一文件夹中，可以使用以下方式在HTML文件中引用它：
```
<link rel="stylesheet" type="text/css" href="styles.css">
```
  如果资源在子文件夹中，可以使用相对路径访问子文件夹：
```
<script src="js/script.js"></script>
```
  你也可以在HTML文件中使用相对路径引用图像：
```
<img src="images/pic.jpg" alt="My Image">
```
Tomcat默认部署（可选）：
- 如果HTML文件及相关资源位于Tomcat的webapps目录中的根目录或Web应用程序文件夹中，你可以通过直接输入Tomcat服务器的URL来访问HTML文件及其资源。
- 例如，如果HTML文件名为index.html，你可以在浏览器中输入Tomcat服务器的URL地址来访问它，例如：http://localhost:8080/yourwebapp/。

确保所有的资源文件都正确放置，相对路径正确配置，这样HTML页面才能正确加载和显示相关资源。

3. 部署 HTML 到单独的目录中

实际开发中我们的 HTML 可能不止一个，依赖的 CSS / JavaScript 文件也可能比较多。这个时候就不适合全都拷贝到 webapps/ROOT 目录中了(这就会显的比较乱)。

当你需要部署多个HTML页面以及它们依赖的CSS、JavaScript文件等资源时，可以创建一个单独的目录，与Tomcat的ROOT目录并列，来存放这些内容。

以下是部署HTML页面到单独目录的步骤：

1. 在 webapps 中创建目录 HelloApp, 和 ROOT 目录并列：

2. 把刚才创建的 hello2.html, style.css， doge.jpg， app.js 拷贝到 HelloApp 目录中。

为了结构更清楚，我们在 HelloApp 中又创建了一些子目录，css ， img ，js 来分别放 css 、图片、JavaScript 文件：

3. 调整 hello2.html 的代码, 把引用 css、 js、图片的路径进行微调：

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>静态页面</title>
    <link rel="stylesheet" href="css/style.css">
</head>

<body>
    <img src="img/doge.jpg" alt="">
    <script src="js/app.js"></script>
</body>

</html>

形如 img/doge.jpg 这样的路径为相对路径，相对路径需要向确定当前路径，然后再找到目标路径。其中 "当前路径" 是根据当前的 HTML 文件确定的. hello2.html 这个文件和 js/css/img 这些目录处在统计目录中，就直接通过 img/doge.jpg 这样的方式来进行访问了。

4. 在浏览器中通过 http://127.0.0.1:8080/HelloApp/hello2.html。

具体一点：

创建一个新的目录：
- 在Tomcat的webapps目录下，创建一个新的目录，用于存放你的HTML页面和相关资源。例如，你可以创建一个名为mywebsite的目录。
放置HTML文件和资源：
- 将你的HTML文件、CSS、JavaScript文件以及其他依赖的资源放入新创建的目录中。确保文件和目录结构清晰，使你的网站内容易于管理。
访问HTML文件：
- 通过浏览器来访问HTML文件。你可以在浏览器中输入Tomcat服务器的URL地址，后跟新创建的目录和HTML文件名。
- 例如，如果你创建了一个名为mywebsite的目录，并在该目录中有一个HTML文件名为index.html，你可以通过以下URL来访问它：http://localhost:8080/mywebsite/index.html。
相对路径引用资源：
- 在HTML文件中，使用相对路径来引用CSS、JavaScript和图像等资源。相对路径是相对于HTML文件所在位置的路径。
- 例如，如果你的CSS文件在同一目录中，可以使用以下方式在HTML文件中引用它：
```
<link rel="stylesheet" type="text/css" href="styles.css">
```
  如果资源在子文件夹中，可以使用相对路径访问子文件夹：
```
<script src="js/script.js"></script>
```
  你也可以在HTML文件中使用相对路径引用图像：
```
<img src="images/pic.jpg" alt="My Image">
```
Tomcat默认部署（可选）：
- 如果HTML文件及相关资源位于Tomcat的webapps目录中的根目录或创建的新目录中，你可以通过直接输入Tomcat服务器的URL来访问HTML文件及其资源。
- 例如，如果HTML文件名为index.html，你可以在浏览器中输入Tomcat服务器的URL地址来访问它，例如：http://localhost:8080/mywebsite/。

这种方法使得多个HTML页面和相关资源能够组织得更加清晰，同时确保相对路径引用资源时路径正确。这是一个更好的方式来管理多个网页和它们的相关文件。

相对路径 vs. 绝对路径

在Web开发中，相对路径和绝对路径是两种不同的路径表示方式，用于定位资源文件（如图像、CSS、JavaScript等）。它们有不同的用途和特点：

1. 相对路径：

相对路径是相对于当前文档的位置来定位资源的路径。
它通常不以斜杠（/）开头，而是以相对于当前文档的位置的路径来表示。
相对路径便于代码的可移植性，因为它们不依赖于服务器或网站的根目录。

示例：<img src="img/doge.jpg" alt="">

在这个示例中，src属性使用相对路径，指示浏览器在当前文档的位置（假设是/HelloApp）查找img文件夹中的doge.jpg图像。

2. 绝对路径：

绝对路径是从网站的根目录或服务器的根目录开始的完整路径。
它通常以斜杠（/）开头，以确保资源的确切位置，不受当前文档的位置影响。
绝对路径可以确保资源的准确加载，但如果根目录或路径结构发生更改，可能需要手动更新路径。

示例：<img src="/HelloApp/img/doge.jpg" alt="">

在这个示例中，src属性使用绝对路径，指示浏览器从网站的根目录（/HelloApp）开始查找img文件夹中的doge.jpg图像。

建议：

通常情况下，建议使用相对路径，因为它们更具可移植性。如果项目的上下文路径（Context Path）发生更改，相对路径会自动适应。
使用绝对路径可能更确切，但如果需要移动或部署代码到不同的上下文路径，可能需要手动更改路径。

选择相对路径或绝对路径通常取决于项目的具体需求和预期的可移植性。在大多数情况下，相对路径是更好的选择，因为它们更具弹性和可维护性。

Tomcat可以支持静态页面，也可以支持动态页面。提供了一组API，封装了HTTP协议，让程序员更方便的去编写动态页面，即Servlet：

1. 静态页面：

静态页面通常是单纯的HTML页面，它们的内容在每次请求时都保持不变。
这些页面不包含动态内容或交互，它们的显示是固定的。
静态页面可以包括文本、图像、链接等内容，而不需要后端代码的介入。
Tomcat可以轻松地提供这些静态页面，只需将HTML文件放入webapps目录即可。

一个静态页面就是单纯的HTML，动态页面就要复杂一些，背后需要通过大量代码、复杂逻辑来描述实现。这也是后端开发的核心工作。

2. 动态页面：

动态页面通常需要在后端编写一些代码来处理逻辑、数据和交互。
这些页面的内容可能随着用户请求、输入或其他因素而发生变化。
为了实现动态页面，Tomcat提供了一组API，其中最重要的是Servlet。
Servlet是Java编写的服务器端程序，用于处理HTTP请求和生成动态内容。
Servlet能够与数据库、其他服务器和服务进行通信，以生成个性化的响应。

3. Tomcat和Servlet：

Tomcat作为一个Java Servlet容器，提供了Servlet容器的支持，使开发者能够轻松创建和部署Servlet程序。
Servlet程序可以响应HTTP请求，生成动态内容，访问数据库，处理表单提交等。
Tomcat还支持JavaServer Pages（JSP），这是一种用于生成动态网页的Java技术，它允许将Java代码嵌入到HTML中，使动态内容的创建更加方便。

总之，Tomcat是一个强大的Web服务器，能够同时支持静态页面和动态页面。它为开发者提供了Servlet和JSP等工具，用于创建复杂的动态Web应用程序，实现前后端交互和逻辑处理。这使得Tomcat成为后端开发的重要工具之一。

Servlet

Servlet是Java EE（Enterprise Edition）的一部分，它是一种用于开发基于Web的应用程序的Java技术。Servlet提供了一组API，用于处理HTTP请求、生成动态Web内容以及与Web服务器进行交互。

Servlet是一个比较古老的编写网站方式，2010年之前，Java编写网站主要使用Servlet的方式。后来Java中有大佬又编了一套框架——Spring，现在使用Java进行商业级别的开发基本都是以Spring为主。Spring就是基于Servlet来实现的，里面的某些功能仍然要通过原生的Servlet的方式来触发。

所以如果咱们真的能把Servlet理解的很好，对于后续学习 Spring 肯定还是有帮助的~~

Servlet 主要做的工作：

就是让程序猿自己写一些类，然后把这些类给加载到 Tomcat中。后续 Tomcat收到 HTTP 请求(来自于浏览器)，就会执行到咱们上面写的代码。从而通过这些代码,完成一定的业务逻辑。

以下是Servlet的重要概念和工作原理：

Servlet 是 Java Web 开发中的核心技术。当我们谈论 Servlet 时，我们通常指的是用 Java 语言编写的服务器端程序。

以下是 Servlet 在应用中主要完成的工作：

处理请求：Servlet 可以接收来自客户端（如浏览器）的请求，这些请求可以是 GET、POST 或其他 HTTP 方法。
业务逻辑处理：程序员可以在 Servlet 中编写代码，执行各种业务逻辑，如数据库查询、数据处理、API 调用等。
生成响应：Servlet 可以生成并返回响应到客户端。响应可能是 HTML、JSON、XML 或其他格式的数据。
状态管理：虽然 HTTP 是无状态的，但 Servlet 提供了多种方式（如 cookies、sessions）来跟踪用户的状态。
与 JSP 集成：Servlet 通常与 JSP（Java Server Pages）一起使用，允许开发人员以声明的方式编写动态生成的 HTML 页面。Servlet 可以处理业务逻辑，然后将数据转发给 JSP 进行显示。
生命周期管理：Servlet 有自己的生命周期，它可以被初始化（init 方法）、处理多个请求（service 或 doGet/doPost 方法）和销毁（destroy 方法）。容器（如 Tomcat）管理 Servlet 的生命周期。
与过滤器和监听器交互：在 Java Web 开发中，除了 Servlet 外，还有过滤器（Filter）和监听器（Listener）。Servlet 可以与它们互动，执行诸如请求和响应的预处理、资源的初始化和清理等任务。
安全和权限：Servlet 可以与容器的安全机制集成，确保只有合适的用户可以访问特定的资源。
与数据库交互：虽然 Servlet 本身不直接处理数据库操作，但它可以调用其他 Java 类来查询、更新或删除数据库中的数据。

总的来说，Servlet 是 Java Web 开发的基础，它为处理 HTTP 请求、执行业务逻辑和生成响应提供了一个中央位置。虽然现代的 Java Web 框架（如 Spring MVC）为开发提供了更高级的抽象，但它们在底层仍然使用 Servlet 技术。

Servlet的概念：

Servlet是服务器端程序，用于接收、处理和响应客户端（通常是浏览器）发送的HTTP请求。
Servlet是Java类，它扩展了Java Servlet API并实现了特定的Servlet接口。
Servlet通常用于生成动态Web页面，与数据库、后端逻辑和其他资源进行交互。

Servlet的工作原理：

注册和映射：开发者编写Servlet类，并将其注册到Web应用程序中。Servlet可以通过URL映射或其他规则与特定的HTTP请求关联。
接收请求：当客户端发出HTTP请求时，Web服务器（如Tomcat）会将请求路由到适当的Servlet，根据URL映射或其他规则。
处理请求：Servlet接收HTTP请求，并可以访问请求参数、请求头、会话信息等。它可以执行任何必要的逻辑，包括数据库查询、计算和生成响应内容。
生成响应：Servlet生成HTTP响应，包括响应头和响应体。响应体通常包含HTML、XML、JSON或其他格式的Web页面或数据。
发送响应：Servlet将生成的HTTP响应发送回客户端，通常是浏览器。浏览器会根据响应显示Web页面或处理数据。

Servlet的作用：

允许开发者编写Java类，以处理HTTP请求并生成动态内容。
简化了与Web服务器的交互，包括请求解析、响应构建和会话管理。
支持处理不同HTTP方法，如GET、POST等。
可以与JSP等其他Web技术协同工作，构建复杂的Web应用程序。

总之，Servlet是一种用于构建动态Web应用程序的Java技术，它通过提供API和抽象层简化了与Web服务器的交互。Servlet使开发者能够专注于业务逻辑而不必关注底层HTTP协议和网络细节，从而提高了Web应用程序的开发效率。

第一个 Servlet 程序

1. 创建Maven项目：

使用IntelliJ IDEA或其他IDE，创建一个Maven项目。指定项目的存储目录。

Maven 是Java世界中一个知名的构建工具，帮助你编译/打包的代码。

你可能会问，javac才是Java的编译工具，IDEA直接自动调用javac不就好了？为啥还要使用别的工具？

那是因为我们以前写的都是比较简单的代码，一个项目中也没有几个文件，怎么搞都可以。以后涉及到的项目可能会非常复杂，尤其可能会有一系列的依赖关系，Maven就可以解决上述问题，帮我们把依赖管理好。它的打包功能也十分强大，方便集成到自动化环境中。

要想使用Maven不需要额外下载安装，因为IDEA已经集成了Maven。

菜单 -> 文件 -> 新建项目 -> Maven：

首次创建Maven的时候，会自动从Maven网站上下载一些以来的组件，如果你的网络不稳定就会出错，可能会影响后续对Maven的使用。

生成了一系列目录结构：

main：放的是业务代码；test：是测试代码；

pom.xml：maven项目入口配置文件。

后续我们还需要修改这个文件、添加更多的内容，以完成一些效果。

Maven 是一个强大的构建工具和项目管理工具，虽然它最初设计用于构建 Java 项目，但实际上它可以用于管理和构建几乎任何类型的项目，不仅仅是 Java。

以下是一些常见的项目类型，可以使用 Maven 进行管理：

Java 项目：Maven 最初是为 Java 项目设计的，它能够管理 Java 源代码、编译、运行测试、打包 JAR 文件和 WAR 文件等。
Web 应用程序：Maven 可以用于管理和构建 Web 应用程序，包括基于 Java 的 Web 应用（如 Servlet 和 JSP）以及其他 Web 技术，例如 HTML、CSS 和 JavaScript。你可以使用 Maven 插件来构建 WAR 文件，部署到应用服务器。
Android 项目：虽然 Android 开发通常使用 Gradle 构建工具，但你也可以使用 Maven 来管理 Android 项目。有一些第三方插件和工具可以将 Maven 与 Android 开发集成。
C/C++ 项目：Maven 不仅适用于 Java，你可以使用 Maven 为 C/C++ 项目创建构建脚本，管理依赖项，以及构建可执行文件和库。
Python 项目：尽管 Python 通常使用 pip 或其他包管理工具，但你可以使用 Maven 来管理 Python 项目的构建和依赖项。
.NET 项目：虽然 .NET 生态系统通常使用 Visual Studio 和 NuGet 来管理项目，但也有一些 Maven 插件可以用于构建和管理 .NET 项目。
前端项目：Maven 可以与前端构建工具（如 Webpack、Grunt、Gulp）结合使用，以管理前端项目的依赖项和构建过程。
数据库项目：你可以使用 Maven 来管理数据库项目，包括数据库脚本、迁移脚本和测试数据的版本控制。
任何需要自动化构建和依赖管理的项目：无论项目类型如何，如果你需要自动化构建、测试和部署，以及管理项目依赖关系，Maven 都可以作为一个通用工具使用。

虽然 Maven 可以应用于各种项目类型，但在某些情况下，可能会有更适合的工具。例如，对于纯粹的前端项目，通常更适合使用专门的前端构建工具，如Webpack。对于.NET项目，Visual Studio和MSBuild可能更适合。选择工具应根据项目的特定需求和生态系统来决定。

2. 引入Servlet API依赖：

项目创建完毕后, 会自动生成一个 pom.xml 文件。

接下来要写的程序会使用servlet，这个API是Tomcat提供的，不是JDK提供的，是一个第三方库，需要手动安装导入。

可以手动下载导入依赖，但是比较麻烦，涉及的项目多，依赖内容非常多，手动管理就很麻烦，使用maven就可以非常方便的解决上述问题。

我们需要在 pom.xml 中引入 Servlet API 依赖的 jar 包。

1. 在中央仓库 https://mvnrepository.com/ 中搜索 "servlet"，一般第一个结果就是。

中央仓库：大佬们把市面上的第三方库都收集起来搞了个网站~~

2. 选择版本. 一般我们使用 3.1.0 版本：

这是Servlet程序所需的核心库。

Servlet 的版本必须要和Tomcat 版本匹配。根据你的Tomcat版本，选择相应的Servlet API版本。

通常情况下，如果使用Tomcat 8.5，可以选择Servlet 3.1.0版本。

以前我们手动下载：

现在可以借助Maven自动下载：

    <dependencies>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

刚才 .jar 包是被下载到哪里了呢?maven 本地仓库maven 就会在你的机器上搞一个目录这个目录就会保存你这边下载好的这些 .jar包：

3. 创建目录

当项目创建好了之后, IDEA 会帮我们自动创建出一些目录：

src：通常代表源代码所在的根目录。在 Maven 项目中，你将在 src 下找到 main 和 test 两个子目录，分别用于主要的源代码和测试代码。
main/java：这是主要的源代码根目录。你应该将你的Java源代码文件（.java文件）放在这个目录中。这是项目的核心代码。
main/resources：这个目录通常用于存储项目的资源文件，如配置文件、静态资源、XML 文件等。这些资源可以在项目中被访问和使用。资源文件在类路径中也是可用的。
test/java：这是用于存储测试代码的根目录。你可以编写单元测试、集成测试或功能测试，并将测试类放在这个目录中。

根据需求，我们可能需要创建更多的目录和文件。一些常见的附加目录包括：

main/webapp：用于存储Web应用程序的Web内容，如HTML、JSP、CSS和JavaScript文件。
main/resources/static：在Spring Boot等框架中，这是用于存储静态资源文件的目录，例如图片、CSS、JavaScript等。
main/resources/templates：用于存储模板文件，例如Thymeleaf或FreeMarker模板，用于生成动态Web页面。
main/resources/config：存储应用程序配置文件，如Spring Boot的application.properties或application.yml。
main/resources/i18n：存储国际化和本地化资源文件。
main/java/com/example：你的主要包结构。这是你自己定义的，用于组织你的Java类。

我们可以根据项目的需求自定义目录结构，但上述结构是一种常见和推荐的方式，特别是对于Maven项目。这有助于项目的组织和维护。

1、创建 webapp 目录在 main 目录下，和 java 目录并列，创建一个 webapp 目录 (注意，不是 webapps)。

2、创建 web.xml 然后在 webapp 目录内部创建一个 WEB-INF 目录，并创建一个 web.xml 文件。

这组目录结构是Tomcat要求的目录结构，我们后面写的代码会放到Tomcat上，我们必须要遵守它的要求，否则它识别不了也就无法执行了。

这里面的内容不能空着，但是这里怎么写，我们只用复制粘贴以下模板：

3、编写 web.xml

webapp目录通常是在Java Web应用程序中使用的一个重要目录。这是一个部署到Tomcat或其他Java Web服务器的Web应用程序的根目录，通常包含以下内容：

静态资源：webapp目录通常包含用于前端呈现的静态资源，例如HTML文件、CSS文件、JavaScript文件、图像等。这些资源可以直接由浏览器请求并加载，而不需要任何特殊处理。
WEB-INF目录：在webapp目录中，通常还包含一个WEB-INF目录，其中包含了一些重要的配置和资源文件。在WEB-INF目录下，通常会包含以下文件和目录：
- web.xml：这是一个XML配置文件，用于配置Web应用程序的Servlet、过滤器和其他组件。它告诉Tomcat如何处理动态资源请求和应用程序的行为。
- classes目录：这个目录通常包含Java类文件和其他资源文件，这些文件用于支持Web应用程序的后端逻辑。这些类通常由Servlet和其他组件使用。
- lib目录：这个目录通常包含用于Web应用程序的Java库（JAR文件）。这些库可以包含第三方库、框架或其他依赖项。
动态资源：除了静态资源，webapp目录还可以包含动态资源，如JSP文件、Servlet文件以及其他生成动态内容的文件。这些文件通常由Web服务器根据客户端请求动态生成内容。

在这个目录中还有一个重要的文件 web.xml. Tomcat 找到这个文件才能正确处理 webapp 中的动态资源。

在部署Web应用程序时，将整个webapp目录打包成WAR文件（Web Application Archive），然后将WAR文件部署到Tomcat中。Tomcat会根据web.xml文件中的配置和Web应用程序的结构来处理请求和执行相应的动态逻辑。这使得开发和部署Java Web应用程序变得相对容易和标准化。

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <display-name>Archetype Created Web Application</display-name>
</web-app>

IDEA 针对 Java 来说可以做到非常精准的报错提示可能会让你误以为 IDEA 针对其他语言也一样精准，但是事实上，IDEA 之于 Java 是整个编程圈子中独一档的存在！
IDEA 对于其他语言 .xml，html，js，sql，都无法做到同样精准。而这里就是 XML文件！
其他开发工具（即使同样是 JetBrains 公司搞的 clion，在C++ 上也无法做到精准）
更不用说VS 这种了.表现的就更差了。

4. 编写代码

1. 创建 HelloServlet 类

创建一个Java类，命名为 HelloServlet ，以处理HTTP请求。

2. 使用 @WebServlet 注解

在 HelloServlet 类的上方使用 @WebServlet("/hello") 注解。
这表示只有当Tomcat收到路径为 /hello 的请求时，才会调用 HelloServlet 类的代码。这个路径不包含Context Path。

3. 重写 doGet 方法

重写 doGet 方法以处理GET请求。doGet 方法的参数包括收到的HTTP请求和要构造的HTTP响应。

4. HttpServletRequest 和 HttpServletResponse

HttpServletRequest 表示HTTP请求，Tomcat将HTTP请求的字符串格式转换为HttpServletRequest对象。
后续可以使用HttpServletRequest对象获取请求中的信息，如请求方法、URL、请求头、请求体等。
HttpServletResponse 表示HTTP响应。在doGet方法中，您需要使用HttpServletResponse对象构造响应，包括响应的状态码、头信息和响应体。

5. 使用 resp.getWriter()

使用resp.getWriter()方法获取响应的输出流。
通过输出流，可以将数据写入响应体，这些数据将构成HTTP响应的主体部分。
Tomcat将整个响应转化为字符串，并通过套接字将其发送回浏览器，完成HTTP响应的过程。

6. 总结

在这种模式下，代码不再通过main方法作为入口点，而是由Tomcat调用，Tomcat已经包含了main方法，你的代码是Tomcat程序的一部分逻辑。
为了使一个类能够被Tomcat调用，需要满足以下三个主要条件：

a) 类需要继承自HttpServlet。

b) 使用@WebServlet注解将类与一个HTTP路径关联。

c) 实现doXXX方法（例如，doGet）来处理HTTP请求。只要这三个条件都满足，Tomcat就可以找到该类并在适当的时机进行调用。

继承不是目的，我们真正想要的是重写父类的方法：

这里面还自动生成了一个方法，它是调用了父类的 doGet 方法，实际上，我们自己写方法的时候，要把这一行代码删除：

super.doGet(req,resp);

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 这个打印是显示在 tomcat 的控制台上 (服务器端)
        System.out.println("hello world");
        // 把内容显示到页面上. 把 "hello world" 字符串作为 http 响应的 body 部分.
        // 这个部分就会被浏览器显示到页面上.
        resp.getWriter().write("hello world");
    }
}

5、打包Java Web应用程序

在Java Web应用程序开发中，打包是将项目准备好以便部署到Java Web服务器（如Tomcat）的关键步骤。

通常，开发人员使用构建工具如Maven来执行这个任务。

以下是关于在Java Web应用程序开发中的打包的一些重要信息：

构建工具：Maven是一个常用的构建工具，用于管理Java项目的依赖关系、构建过程和打包。Maven使用项目描述文件（通常是pom.xml）来配置项目，并通过命令行或集成开发环境（IDE）插件执行构建和打包操作。
依赖管理：Maven能够管理项目所依赖的库和组件，这些依赖关系通常被列在项目的pom.xml文件中。Maven会自动下载并包含这些依赖项，以确保项目能够正常编译和运行。
打包：在Java Web应用程序开发中，通常需要将项目的源代码、资源文件和依赖项打包成一个部署包，以便在Web服务器上部署和运行。这个打包通常是一个WAR（Web Archive）文件，其中包含了所有必要的文件和配置来运行Web应用程序。
打包步骤：为了打包一个Java Web应用程序，你需要配置Maven的pom.xml文件以指定项目的类型为"war"，然后运行Maven的打包命令。执行以下命令来构建并打包项目：
```
mvn clean package
```
这将编译代码、处理资源文件，并生成一个WAR文件，通常位于项目目录的"target"文件夹下。
部署：一旦项目被成功打包成WAR文件，你可以将该WAR文件部署到支持Java Web应用程序的Web服务器（如Tomcat、Jetty等）。部署通常涉及将WAR文件复制到Web服务器的适当目录，然后启动服务器以运行应用程序。

总之，打包是Java Web应用程序开发中的一个关键步骤，通过使用构建工具如Maven，可以方便地将项目准备好以便部署到Java Web服务器，从而使Web应用程序可以在生产环境中运行。

打包Java Web应用程序为WAR文件

WAR文件和JAR文件的区别

WAR（Web Archive）文件是用于打包和部署Java Web应用程序的文件，包括Web应用程序的类文件、配置文件和前端资源。
JAR（Java Archive）文件通常用于打包Java类和库，其中最重要的内容是.class文件。

Tomcat要求的WAR包

Tomcat是一种Java Web服务器，要求Java Web应用程序以WAR格式打包才能部署和运行。
WAR文件包含了整个Web应用程序的内容，以确保它可以在Tomcat上正确运行。

Java Web应用程序结构

Java Web应用程序的目录结构包括：
WEB-INF/classes目录：包含Java类文件。
WEB-INF目录：包含Web应用程序的配置文件，如web.xml。
前端资源：如HTML、CSS、JavaScript等文件。

打包Java Web应用程序为WAR文件的步骤
项目结构：确保项目的目录结构符合标准，包括类文件、配置文件和前端资源的正确位置。

配置文件：项目的web.xml文件用于配置Servlet、过滤器、URL映射等信息，必须位于WEB-INF目录下。
使用构建工具：如果使用Maven或其他构建工具，确保在pom.xml中将项目类型指定为WAR，以正确打包项目为WAR文件。
<packaging>war</packaging>
打包操作：使用构建工具执行打包操作，通常使用以下命令：
mvn clean package
部署到Tomcat：将生成的WAR文件复制到Tomcat服务器的webapps目录中。Tomcat会自动解压WAR文件并部署应用程序。
总结

打包Java Web应用程序为WAR文件是将应用程序准备好以在Tomcat等Java Web服务器上部署和运行的关键步骤。WAR文件包含了应用程序的所有必要文件，包括类文件、配置文件和前端资源，以确保它可以在生产环境中正确运行。与JAR文件不同，WAR文件是专门为Web应用程序的部署设计的。

以下是一些关键步骤和知识点的总结：

1. 使用Maven进行打包

使用Maven来管理项目并进行打包操作。

修改 pom.xml ，来设置打包的类型和包的名字，里面输入代码：

    <packaging>war</packaging>
    <build>
        <finalName>java1</finalName>
    </build>

2. 打包命令

打开Maven窗口，通常在IDEA的右侧。
展开"Lifecycle"，双击"package"以执行打包操作。
成功的情况下，你将看到"SUCCESS"的提示，如果有问题，可能会显示"BUILD FAILED"，你可以根据错误信息解决问题。

你可以看到，我一开始就是有问题，所以只能一步步的根据报错信息去寻找答案。

当在控制台中执行打包操作时，如果出现打包失败，通常会显示一些出错原因或错误消息，以帮助你定位和解决问题：

编译错误：如果你的Java代码包含编译错误，Maven将无法成功编译项目并打包。错误消息通常包括有关编译错误的详细信息，如缺少的分号、未找到的符号等。
依赖问题：如果你的项目依赖于库或组件，但它们未正确配置或未能下载，Maven将报告依赖解析错误。错误消息可能包括依赖无法解析或下载的信息。
配置错误：项目的配置文件（如pom.xml或web.xml）中的错误配置也可能导致打包失败。错误消息通常会指出配置文件中的问题。
文件丢失：如果项目需要的文件丢失或被放置在错误的位置，打包可能会失败。错误消息将指出缺失的文件或目录。
内存不足：在大型项目中，Maven可能需要更多的内存来执行打包操作。如果内存不足，可能会导致OutOfMemoryError。你可以通过调整Maven的内存设置来解决这个问题。
依赖冲突：如果项目依赖的不同库之间存在冲突，Maven可能无法解决依赖关系。错误消息通常会报告依赖冲突的详细信息。
文件路径问题：如果文件路径包含非法字符或不符合项目结构的要求，可能导致打包失败。错误消息将指出路径问题。
网络问题：如果Maven无法连接到远程存储库以下载依赖项，可能会出现网络问题。错误消息通常会指示连接问题。

其中最常见的就是以下两种：

1、打包操作依赖了一些第三方的JAR包，Maven会自动下载，如果下载过程中网络不太顺利就容易出问题；

2、代码里面有问题（配置完就，pom.xml）。

首次打包确实容易出问题，因为里面涉及到一些下载依赖的问题。但是一旦你下载好了，后续就不必重新下载。

这里确实比较麻烦，建议如果出错课以把相关错误信息复制粘贴去网上查一下，一般都会有相应的解决办法，不要急，也算是积累学习经验的过程。

解决好之后大概就这样：

3. 打包后的结果

打包成功后，你将在target目录下看到生成的一个JAR文件。

4. 区分WAR和JAR包

默认情况下打的是JAR包，JAR包是普通的Java程序打包的结果，其中包含一些.class文件。但是Tomcat要求的是 WAR包。JAR包是JAVA中更加通用的发布方式，任何程序都可以打成JAR包，JAR里面最重要的就是.calss文件。
WAR包是Java Web应用程序的打包结果，除了.class文件外，还包括HTML、CSS、JavaScript等一些前端代码，还有图片和其他JAR包。只有将项目打成WAR包格式才能被Tomcat等Java Web服务器识别。

5. WAR包命名

WAR包的名称通常可以更简单，便于识别。你可以根据需要自定义WAR包的名称。

6. 修改pom.xml

在pom.xml文件中，需要进行一些配置更改以生成WAR包。

<packaging>war</packaging> <!-- 表示打包方式为WAR包 --> <build> <finalName>ServletHelloWorld</finalName> <!-- WAR包的名称 --> </build>

7. 完整的pom.xml示例

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>ServletHelloWorld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <packaging>war</packaging> <!-- 打包方式为WAR包 -->
    <build>
        <finalName>ServletHelloWorld</finalName> <!-- WAR包的名称 -->
    </build>
</project>

这些步骤和配置更改将使我们能够成功打包Java Web应用程序为WAR包，并准备部署到Tomcat或其他Java Web服务器中。 WAR包包含了Web应用程序的所有内容，可以直接部署在服务器上。

6. 部署程序

拷贝WAR包到Tomcat：
- 将生成的ServletHelloWorld.war文件拷贝到Tomcat的webapps目录下。
启动Tomcat：
- 启动Tomcat服务器。你可以通过执行Tomcat的bin/startup.sh（Linux）或bin/startup.bat（Windows）来实现。
- Tomcat会自动识别webapps目录下的WAR文件，并进行解压缩部署。
- 查看Tomcat的日志（通常位于logs/catalina.out），确认ServletHelloWorld应用已被正确加载和部署。

7. 验证程序

通过浏览器访问应用：
- 打开Web浏览器。
- 输入URL http://127.0.0.1:8080/java1/hello。
- 这里的日志也会更新：
- 或者我们也可以本地IDEA运行：
- 你应该能够看到应用的输出或结果页面。此处的hello world就是servlet代码中返回的内容了。
理解URL结构：
- URL的路径通常分为两部分：
  - ServletHelloWorld：这是Context Path，代表部署在Tomcat上的应用名称。
  - hello：这是Servlet Path，代表具体的Servlet映射路径。

当你看到应用的预期输出或结果时，这意味着你已经成功地部署并验证了Java Web应用程序。之后，你可以根据需要进行更多的测试和验证，以确保应用的所有功能都按预期工作。

现在，如果我么想要把“hello world”改成“hello java”该怎么操作呢？这个过程其实还比较麻烦。

1、首先要修改代码：

但是只是简单的修改代码并不能生效！

2、重新打包：一般来说，只要把WAR包更新之后，Tomcat就会自动识别到变化，自动重新部署。但是Windows上可能会有bug，需要你手动重启一下Tomcat。

3、重新部署。

所以你会发现这整个过程非常的麻烦，毕竟我么写代码的时候修改是非常频繁的。

还有没有别的办法捏？？？

当然有~~但是这个内容我们放到下一次的博客来讲。

di-Dora

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaEE初阶（12）HTTPS（“加密“ 、对称加密、非对称加密、所谓证书、Tomcat内容介绍和下载安装、部署静态页面、初识Servlet、第一个 Servlet 程序）

JavaEE初阶（12）HTTPS（"加密"是什么、HTTPS 的工作过程——对称加密、非对称加密、所谓证书、Tomcat内容介绍和下载安装、部署静态页面、初识Servlet、第一个 Servlet 程序）
复制链接

扫一扫