• Tomcat常见报错以及手动实现Tomcat

    一.Tomcat的简单启动

    1.安装Tomcat

    2.Tomcat启动

    1. 双击 bin 目录下的 startup.bat 文件

    2. 输入 http://localhost:8080/，显示如下界面代表安装成功, 默认在 8080 端口

    3. 注意，不要关闭黑窗口，关闭了，tomcat 服务就停止了.

    3.曾经的启动失败案例

    3.1Tomcat停止时报错（java.net.ConnectException: 拒绝连接 (Connection refused)）

    问题：没有关闭之前的Tomcat服务

    解决办法：pkill -9 java的方式强制关闭tomcat服务，然后重新启动。

    3.2启动Tomcat时终端显示乱码

    ...\conf\logging.properties配置文件中默认设置的UTF-8改为GBK

    3.3Tomcat无法启动:

    • 问题: Tomcat启动失败，通常会在启动脚本或日志中显示错误消息。
    • 解决办法:
      • 检查端口冲突，确保Tomcat所需的端口没有被其他进程占用。
      • 检查server.xml配置文件，确保没有错误配置。
      • 检查Java环境变量（如JAVA_HOME）是否正确设置。
      • 查看Tomcat的日志文件以获取详细错误信息。

    3.4内存溢出错误（OutOfMemoryError）:

    • 问题: 应用程序使用的内存超出了可用内存限制。
    • 解决办法:
      • 增加Tomcat的JVM堆内存大小，通过修改catalina.sh或catalina.bat中的-Xmx参数来实现。
      • 使用内存分析工具（如VisualVM）来查找内存泄漏问题。
      • 当然还可以优化代码，减少内存。嘿嘿嘿

    3.5无法连接到数据库:

    • 问题: 应用程序无法连接到数据库。
    • 解决办法:
      • 检查数据库服务器是否正在运行。
      • 检查数据库连接字符串和凭据是否正确。
      • 确保数据库驱动程序JAR文件已正确放置在Tomcat的lib目录中。

    4.解决问题大致思路：

    4.1运行之后报错：

    打开...\logs日志文件查看日志，查看出错的地方并对症下药。

    4.2无法运行报错：

    当我们点击startup.bat之后，黑屏一闪而逝，那么我们可以在startup.bat的末尾敲击pause之后，报错，当我们再次点击之后就会出现对应的错误。没有问题就会出现你的对应的配置文件，jdk之类的。如果还无法解决，看看server.xml中的具体配置是不是缺少某个文件或者文件位置安装错误。

    二.Tomcat简单介绍

    Tomcat 目录结构

    1. server.xml 用于配置 tomcat 的基本设置(启动端口，关闭端口, 主机名)

    2. wex.xml 用于指定 tomcat 运行时配置(比如 servlet 等..)

    3. webapps 目录是存放 web 应用，就是网站，通常在我们的url后面添加/.....即可。

    例如：localhost：8080/web/text.txt就是访问webapps的text.txt文件

    三.Tomcat 服务中部署 WEB 应用

    1.什么是Web应用

    1.1 WEB应用是多个web资源的集合。简单的说，可以把web应用理解为硬盘上的一个目录， 这个目录用于管理多个web资源。

    1.2 Web应用通常也称之为web应用程序，或web工程，通俗的说 就是网站

    2.WEb应用组成

    一个 WEB 应用由多个 WEB 资源或其它文件组成，包括 html 文件、css 文件、js 文件、动 态 web 页面、java 程序、支持 jar 包、配置文件等。开发人员在开发 web 应用时，按照规 定目录结构存放这些文件。否则，在把 web 应用交给 web 服务器管理时，不仅可能会使 web 应用无法访问，还会导致 web 服务器启动报错

    3.JavaWeb程序/应用/工程目录结构

    4.部署方式

    4.1将 web 工程的目录拷贝到 Tomcat 的 webapps 目录

    1. news Web工程(目前都是静态资源 html, 图片)

    2. 将该news目录/文件夹 拷贝到 Tomcat 的webapps目录下

    3. 浏览器输入： http://ip[域名]:port/news/子目录../文件名

    4.2通过配置文件来部署

    1.在Tomcat 下的 conf 目录\Catalina\localhost\ 下,配置文件，比如hong.xml(提醒：知道 Tomcat通过配置，可以把一个web应用，映射到指定的目录，可以解决磁盘空间分配

    2.访问web工程: http://ip[域名]:port/hong/index.html 就表示访问 D:\album 目录下的 index.html

    4.3ROOT 的工程的访问

    1. 在浏览器地址栏中输入访问地址如下：http://ip[域名]:port，没有Web工程/应用名时，默认访问的是 ROOT 工程

    2. 在浏览器地址栏中输入的访问地址如下： http://ip[域名]:port/工程名/ ，没有资源名， 默认访问 index.jsp 页面

    4.4maven

    我们可以通过package打包成war格式或者jar格式返给webapps里面进行编译

    四.底层逻辑实现

    思考问题: Tomcat 底层实现 和 调用到 Servlet 流程？

    1.Tomcat 整体架构分析

    Tomcat 有三种运行模式（BIO, NIO, APR）, 因为准备要说的是 Tomcat 如何接收客户端请求，解析请求, 调用 Servlet , 并返回结果的机制流程, 采用 BIO 线程模型来模拟.

    2.手动实现Tomcat 底层机制+ 自己设计 Servlet

    1.编写自己 Tomcat, 能给浏览器返回 Hi, Hong

    1.1分析

    1.2代码实现
    1. import java.io.*;
    2. import java.net.ServerSocket;
    3. import java.net.Socket;
    4.  
    5. /**
    6.  * @author hong
    7.  * @version 1.0
    8.  * 这是第一个版本的tomcat ,可以完成，接收浏览器的请求，并返回信息
    9.  */
    10. public class HspTomcatV1 {
    11.     public static void main(String[] args) throws IOException {
    12.  
    13.         //1. 创建ServerSocket, 在 8080端口监听
    14.         ServerSocket serverSocket = new ServerSocket(8080);
    15.         System.out.println("=======mytomcat在8080端口监听======");
    16.         while (!serverSocket.isClosed()) {
    17.  
    18.             //等待浏览器/客户端的连接
    19.             //如果有连接来，就创建一个socket
    20.             //这个socket就是服务端和浏览器端的连接/通道
    21.             Socket socket = serverSocket.accept();
    22.  
    23.             //先接收浏览器发送的数据
    24.             //inputStream 是字节流=> BufferedReader(字符流)
    25.  
    26.             InputStream inputStream = socket.getInputStream();
    27.             BufferedReader bufferedReader =
    28.                     new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
    29.  
    30.             String mes = null;
    31.             System.out.println("=======接收到浏览器发送的数据=======");
    32.             //循环的读取
    33.             while ((mes = bufferedReader.readLine()) != null) {
    34.                 //判断mes的长度是否为0
    35.                 if (mes.length() == 0) {
    36.                     break;//退出while
    37.                 }
    38.                 System.out.println(mes);
    39.             }
    40.  
    41.             //我们的tomcat会送-http响应方式
    42.             OutputStream outputStream = socket.getOutputStream();
    43.             //构建一个http响应的头
    44.             //\r\n 表示换行
    45.             //http响应体，需要前面有两个换行 \r\n\r\n
    46.             String respHeader = "HTTP/1.1 200 OK\r\n" +
    47.                     "Content-Type: text/html;charset=utf-8\r\n\r\n";
    48.             String resp = respHeader + "hi, hong";
    49.  
    50.             System.out.println("========我们的tomcat 给浏览器会送的数据======");
    51.             System.out.println(resp);
    52.  
    53.             outputStream.write(resp.getBytes());//将resp字符串以byte[] 方式返回
    54.  
    55.             outputStream.flush();
    56.             outputStream.close();
    57.             inputStream.close();
    58.             socket.close();
    59.             // //等会
    60.             // inputStream.close();
    61.             // socket.close();
    62.         }
    63.     }
    64. }

    2.使用 BIO 线程模型，支持多线程

    2.1BIO 线程模型介绍

    2.2分析

    2.3代码实现
    1. /**
    2.  * @author hong
    3.  * @version 1.0
    4.  */
    5. public class HspTomcatV2 {
    6.     public static void main(String[] args) throws IOException {
    7.         //在8080端口监听
    8.         ServerSocket serverSocket = new ServerSocket(8080);
    9.         System.out.println("=======hongtomcatV2 在8080监听=======");
    10.         //只要 serverSocket没有关闭，就一直等待浏览器/客户端的连接
    11.         while (!serverSocket.isClosed()) {
    12.             //1. 接收到浏览器的连接后，如果成功，就会得到socket
    13.             //2. 这个socket 就是 服务器和 浏览器的数据通道
    14.             Socket socket = serverSocket.accept();
    15.             //3. 创建一个线程对象，并且把socket给该线程
    16.             //  这个是java线程基础
    17.             HspRequestHandler hspRequestHandler =
    18.                     new HspRequestHandler(socket);
    19.             new Thread(hspRequestHandler).start();
    20.  
    21.         }
    22.     }
    23. }

    3.处理 Servlet

    3.1Servlet 生命周期-回顾

    3.2分析

    浏览器请求 http://localhost:8080/hongCalServlet, 提交数据，完成计算 任务，如果 servlet 不存在，返回 404

    3.3代码
    1. package com.hspedu.tomcat;
    2.  
    3. import com.hspedu.tomcat.handler.HspRequestHandler;
    4. import com.hspedu.tomcat.servlet.HspHttpServlet;
    5. import org.dom4j.Document;
    6. import org.dom4j.DocumentException;
    7. import org.dom4j.Element;
    8. import org.dom4j.io.SAXReader;
    9.  
    10. import javax.servlet.Filter;
    11. import javax.servlet.http.HttpSession;
    12. import java.io.File;
    13. import java.io.IOException;
    14. import java.net.MalformedURLException;
    15. import java.net.ServerSocket;
    16. import java.net.Socket;
    17. import java.util.List;
    18. import java.util.concurrent.ConcurrentHashMap;
    19.  
    20. /**
    21.  * @author hong
    22.  * @version 1.0
    23.  * 第3版的Tomcat, 实现通过xml+反射来初始化容器
    24.  */
    25. public class HspTomcatV3 {
    26.  
    27.     //1. 存放容器 servletMapping
    28.     // -ConcurrentHashMap
    29.     // -HashMap
    30.     // key            - value
    31.     // ServletName    对应的实例
    32.  
    33.     public static final ConcurrentHashMap
    34.             servletMapping = new ConcurrentHashMap<>();
    35.  
    36.  
    37.     //2容器 servletUrlMapping
    38.     // -ConcurrentHashMap
    39.     // -HashMap
    40.     // key                    - value
    41.     // url-pattern       ServletName
    42.  
    43.     public static final ConcurrentHashMap
    44.             servletUrlMapping = new ConcurrentHashMap<>();
    45.  
    46.  
    47.     //你可以这里理解session, tomcat还维护一个容器
    48.     public static final ConcurrentHashMap
    49.             sessionMapping = new ConcurrentHashMap<>();
    50.     
    51.  
    52.     //你可以这里理解filter, tomcat还维护了filter的容器
    53.     public static final ConcurrentHashMap
    54.             filterUrlMapping = new ConcurrentHashMap<>();
    55.  
    56.     public static final ConcurrentHashMap
    57.             filterMapping = new ConcurrentHashMap<>();
    58.     //变强..
    59.     public static void main(String[] args) {
    60.         HspTomcatV3 hspTomcatV3 = new HspTomcatV3();
    61.         hspTomcatV3.init();
    62.         //启动hsptomcat容器
    63.         hspTomcatV3.run();
    64.     }
    65.  
    66.  
    67.     //启动HspTomcatV3容器
    68.     public void run() {
    69.  
    70.         try {
    71.             ServerSocket serverSocket = new ServerSocket(8080);
    72.             System.out.println("=====hongtomcatv3在8080监听======");
    73.             while (!serverSocket.isClosed()) {
    74.                 Socket socket = serverSocket.accept();
    75.                 HspRequestHandler hspRequestHandler =
    76.                         new HspRequestHandler(socket);
    77.                 new Thread(hspRequestHandler).start();
    78.             }
    79.         } catch (IOException e) {
    80.             e.printStackTrace();
    81.         }
    82.  
    83.     }
    84.  
    85.     //直接对两个容器进行初始化
    86.     public void init() {
    87.         //读取web.xml => dom4j =>
    88.         //得到web.xml文件的路径 => 拷贝一份.
    89.         String path = HspTomcatV3.class.getResource("/").getPath();
    90.         //System.out.println("path= " + path);
    91.         //使用dom4j技术完成读取
    92.         SAXReader saxReader = new SAXReader();
    93.         //困难->真的掌握
    94.         try {
    95.             Document document = saxReader.read(new File(path + "web.xml"));
    96.             System.out.println("document= " + document);
    97.             //得到根元素
    98.             Element rootElement = document.getRootElement();
    99.             //得到根元素下面的所有元素
    100.             List elements = rootElement.elements();
    101.             //遍历并过滤到 servlet servlet-mapping
    102.             for (Element element : elements) {
    103.                 if ("servlet".equalsIgnoreCase(element.getName())) {
    104.                     //这是一个servlet配置
    105.                     //System.out.println("发现 servlet");
    106.                     //使用反射将该servlet实例放入到servletMapping
    107.                     Element servletName = element.element("servlet-name");
    108.                     Element servletClass = element.element("servlet-class");
    109.                     servletMapping.put(servletName.getText(),
    110.                             (HspHttpServlet) Class.forName(servletClass.getText().trim()).newInstance());
    111.                 } else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {
    112.                     //这是一个servlet-mapping
    113.                     //System.out.println("发现 servlet-mapping");
    114.  
    115.                     Element servletName = element.element("servlet-name");
    116.                     Element urlPatter = element.element("url-pattern");
    117.                     servletUrlMapping.put(urlPatter.getText(), servletName.getText());
    118.  
    119.                 }
    120.             }
    121.         } catch (Exception e) {
    122.             e.printStackTrace();
    123.         }
    124.  
    125.         //验证，这两个容器是否初始化成功
    126.         System.out.println("servletMapping= " + servletMapping);
    127.         System.out.println("servletUrlMapping= " + servletUrlMapping);
    128.     }
    129. }
    3.4测试
     

     

  • 相关阅读:
    入行测试一年半的心得体会
    LeetCode Cookbook 数组习题（2）
    OpenCV--图像的分割与融合方法
    陕西直销系统开发如何让别人听你讲？
    SQL 撤销索引、表以及数据库||SQL CREATE DATABASE 语句||SQL CREATE TABLE 语句
    一起来学Kotlin：概念：14. Kotlin List 的使用 1：filter，map，count，first，last，any，find
    github Release 下载加速，绿色合法，遥遥领先
    JS中计算时数据有误差解决方案
    Java面试题07
    编译添加了ALPHA开发板的NXP官方uboot
  • 原文地址：https://blog.csdn.net/weixin_54107527/article/details/133002342