Tomcat入门

1.什么是tomcat

• Apache Tomcat 是一个开源软件，实现了对 Java Servlet 和 JSP（JavaServer Pages）技术的支持。

• tomcat是一个开源而且免费的jsp服务器，可实现JavaWeb程序的装载，是配置JSP（Java Server Page）和JAVA系统必备的一款环境。它是apache软件基金会的jakarta项目中的一个核心项目，因为tomcat技术先进性能稳定和监督易用性已成为最为广泛的jsp服务器。

  Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。

  对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。

• Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。

• Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。

• 对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。

• 实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。

• 另外，Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache服务器。

2.tomcat下载、安装、配置

1.下载

• 下载地址

2.安装

• tomcat需要安装jdk和jre，对于tomcat5及以前的版本，要求必须安装jdk，而tomcat6及以后的版本只需要安装jre。这里怎么安装jdk和jre就不讲了。
• 只需要在系统环境变量中设置JAVA_HOME后，将其java的bin目录添加到path变量即可。
• 下载可以下载zip格式或exe格式的，其中zip格式的只要解压缩再配置下环境变量就可以使用了

3.配置

• 安装成功在浏览器输入http://localhost:8080/，出现官方界面则成功
• 打开bin目录下的startup.bat即可启动，打开shutdown.bat即可关闭

• 如果java环境变量没有正确配置，则可能出现闪退情况，请按要求正确配置java环境变量即可
• 如遇控制台中文乱码情况，9版本以下的在tomcat中conf里面的server.xml，在Connector中加上

URIEncoding="UTF-8"

或者在idea的vm options里添加上面的代码，或者更改idea的file encodings为UTF-8，最后重启idea

还是不行的在tomcat的bin目录下的catalina.bat加如下一条语句

set JAVA_OPTS=-Xms512m -Xmx1024m -XX:MaxPermSize=1024m -Dfile.encoding=UTF-8

• tomocat默认关闭端口改-1为8005
• 在idea中配置本地tomcat：
  • 。。。。。。。
  • 。。。。
  • 。。。。。

4.手工创建和打包web工程

1. 创建一个文件，比如MyFirstWebProject, 此为web工程的根目录

2. 在其下建立WEN-INF文件夹，必须注意的是要大写， 因为这是规范，方便WEB容器的读取。

3. 在WEB-INF下建立两个文件夹和一个文件，分别叫做：lib、classes文件夹和web.xml文件。 lib用于存放需要用到的jar包等，包括mysql驱动等；classes文件夹用于存放编译好了的java文件，它们是以class文件存在在这个目录下的；最后是web.xml文件，它必须以作为该xml文件的根标签。

4. 在工程MyFirstWebProject目录下建一个文件夹pages（这不是必须的）用于存在index.html等页面，把需要的页面写好放在该文件夹下面就可以了。

5. 将整个工程打成war包，放入tomcat或jboss等web容器的webapp目录下，启动容器，则通过http://localhost:8080/MyFirstWebProject/pages/index.html就可正常访问html页面了。 打war可以在进入工程MyWebProject中，用"jar -cvf MyFirstWebProject.war ."即可。

   jar -cvf d:\xxx\xxx.war .				
   cvf是命令参数，表示生成一个文档、显示生成过程、指定生成的文件名，xxx为打包后要存放的路径和打包后的文件名，根据自己需求修改，注意，最后需输入一个空格在加一个‘.‘，代表打包该目录下所有文件。			
   

6. 在Tomcat6.0上经过测试，以上的做法是正确的。 同时注意， 如果没有配置JAVA_HOME的环境变量，直接点击Tomcat6.0会迅速消失， 此时应该用命令行启动。

5.tomcat核心

• Tomcat的核心配置
  • tomcat的核心配置都在conf\server.xml文件中
• 一个server服务器可以有多个service服务，每个服务都是由engine引擎提供的，每个引擎中可以多台主机或者虚拟主机，如localhost和virtual host，localhost中又可以包含多个context应用，engine引擎通过connector连接器使得浏览器可以访问服务器。

6.tomcat源码分析

。。。。。。。。。。。。。。。。。。。。。。。。。

3.Http协议

1.什么是http协议

1. HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。。

   HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。

2. HTTP协议工作于客户端-服务端架构上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。

   Web服务器有：Apache服务器，IIS服务器（Internet Information Services）等。

   Web服务器根据接收到的请求后，向客户端发送响应信息。

   HTTP默认端口号为80，但是你也可以改为8080或者其他端口。

   HTTP三点注意事项：

   • HTTP是无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
   • HTTP是媒体独立的：这意味着，只要客户端和服务器知道如何处理的数据内容，任何类型的数据都可以通过HTTP发送。客户端以及服务器指定使用适合的MIME-type内容类型。
   • HTTP是无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。
   • 

2.http结构

1. 结构概述

HTTP是基于客户端/服务端（C/S）的架构模型，通过一个可靠的链接来交换信息，是一个无状态的请求/响应协议。

一个HTTP"客户端"是一个应用程序（Web浏览器或其他任何客户端），通过连接到服务器达到向服务器发送一个或多个HTTP的请求的目的。

一个HTTP"服务器"同样也是一个应用程序（通常是一个Web服务，如Apache Web服务器或IIS服务器等），通过接收客户端的请求并向客户端发送HTTP响应数据。

HTTP使用统一资源标识符（Uniform Resource Identifiers, URI）来传输数据和建立连接。

一旦建立连接后，数据消息就通过类似Internet邮件所使用的格式[RFC5322]和多用途Internet邮件扩展（MIME）[RFC2045]来传送。

2. 请求报文结构：

• HTTP1.0 定义了三种请求方法： GET, POST 和 HEAD方法。

  HTTP1.1 新增了六种请求方法：OPTIONS、PUT、PATCH、DELETE、TRACE 和 CONNECT 方法。

• HTTP 协议的 8 种请求类型介绍

  HTTP 协议中共定义了八种方法或者叫“动作”来表明对 Request-URI 指定的资源的不同操作方式，具体介绍如下：

  • OPTIONS：返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送的请求来测试服务器的功能性。
  • HEAD：向服务器索要与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以在不必传输整个响应内容的情况下，就可以获取包含在响应消息头中的元信息。
  • GET：向特定的资源发出请求。
  • POST：向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的创建和/或已有资源的修改。
  • PUT：向指定资源位置上传其最新内容。
  • DELETE：请求服务器删除 Request-URI 所标识的资源。
  • TRACE：回显服务器收到的请求，主要用于测试或诊断。
  • CONNECT：HTTP/1.1 协议中预留给能够将连接改为管道方式的代理服务器。
  • PATCH：是对 PUT 方法的补充，用来对已知资源进行局部更新 。

  虽然 HTTP 的请求方式有 8 种，但是我们在实际应用中常用的也就是 get 和 post，其他请求方式也都可以通过这两种方式间接的来实现。

• 客户端发送一个HTTP请求到服务器的请求消息包括以下格式：请求行（request line）、请求头部（header）、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。

• 

• //举例
  GET /hello.txt HTTP/1.1
  User-Agent: curl/7.16.3 libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3
  Host: www.example.com
  Accept-Language: en, mi
  

3. 响应报文结构：

• HTTP响应也由四个部分组成，分别是：状态行、消息报头、空行和响应正文。

• 

• //举例
  HTTP/1.1 200 OK
  Date: Mon, 27 Jul 2009 12:28:53 GMT
  Server: Apache
  Last-Modified: Wed, 22 Jul 2009 19:15:56 GMT
  ETag: "34aa387-d-1568eb00"
  Accept-Ranges: bytes
  Content-Length: 51
  Vary: Accept-Encoding
  Content-Type: text/plain
  

• http响应头相关信息：

• 应答头	说明
  Allow	服务器支持哪些请求方法（如GET、POST等）。
  Content-Encoding	文档的编码（Encode）方法。只有在解码之后才可以得到Content-Type头指定的内容类型。利用gzip压缩文档能够显著地减少HTML文档的下载时间。Java的GZIPOutputStream可以很方便地进行gzip压缩，但只有Unix上的Netscape和Windows上的IE 4、IE 5才支持它。因此，Servlet应该通过查看Accept-Encoding头（即request.getHeader("Accept-Encoding")）检查浏览器是否支持gzip，为支持gzip的浏览器返回经gzip压缩的HTML页面，为其他浏览器返回普通页面。
  Content-Length	表示内容长度。只有当浏览器使用持久HTTP连接时才需要这个数据。如果你想要利用持久连接的优势，可以把输出文档写入 ByteArrayOutputStream，完成后查看其大小，然后把该值放入Content-Length头，最后通过byteArrayStream.writeTo(response.getOutputStream()发送内容。
  Content-Type	表示后面的文档属于什么MIME类型。Servlet默认为text/plain，但通常需要显式地指定为text/html。由于经常要设置Content-Type，因此HttpServletResponse提供了一个专用的方法setContentType。
  Date	当前的GMT时间。你可以用setDateHeader来设置这个头以避免转换时间格式的麻烦。
  Expires	应该在什么时候认为文档已经过期，从而不再缓存它？
  Last-Modified	文档的最后改动时间。客户可以通过If-Modified-Since请求头提供一个日期，该请求将被视为一个条件GET，只有改动时间迟于指定时间的文档才会返回，否则返回一个304（Not Modified）状态。Last-Modified也可用setDateHeader方法来设置。
  Location	表示客户应当到哪里去提取文档。Location通常不是直接设置的，而是通过HttpServletResponse的sendRedirect方法，该方法同时设置状态代码为302。
  Refresh	表示浏览器应该在多少时间之后刷新文档，以秒计。除了刷新当前文档之外，你还可以通过setHeader("Refresh", "5; URL=http://host/path")让浏览器读取指定的页面。 注意这种功能通常是通过设置HTML页面HEAD区的＜META HTTP-EQUIV="Refresh" CONTENT="5;URL=http://host/path"＞实现，这是因为，自动刷新或重定向对于那些不能使用CGI或Servlet的HTML编写者十分重要。但是，对于Servlet来说，直接设置Refresh头更加方便。 注意Refresh的意义是"N秒之后刷新本页面或访问指定页面"，而不是"每隔N秒刷新本页面或访问指定页面"。因此，连续刷新要求每次都发送一个Refresh头，而发送204状态代码则可以阻止浏览器继续刷新，不管是使用Refresh头还是＜META HTTP-EQUIV="Refresh" ...＞。 注意Refresh头不属于HTTP 1.1正式规范的一部分，而是一个扩展，但Netscape和IE都支持它。
  Server	服务器名字。Servlet一般不设置这个值，而是由Web服务器自己设置。
  Set-Cookie	设置和页面关联的Cookie。Servlet不应使用response.setHeader("Set-Cookie", ...)，而是应使用HttpServletResponse提供的专用方法addCookie。参见下文有关Cookie设置的讨论。
  WWW-Authenticate	客户应该在Authorization头中提供什么类型的授权信息？在包含401（Unauthorized）状态行的应答中这个头是必需的。例如，response.setHeader("WWW-Authenticate", "BASIC realm=＼"executives＼"")。 注意Servlet一般不进行这方面的处理，而是让Web服务器的专门机制来控制受密码保护页面的访问（例如.htaccess）。

• http状态码：**

• 下面是常见的HTTP状态码：

  • 200 - 请求成功
  • 301 - 资源（网页等）被永久转移到其它URL
  • 404 - 请求的资源（网页等）不存在
  • 500 - 内部服务器错误

• 分类	分类描述
  1**	信息，服务器收到请求，需要请求者继续执行操作
  2**	成功，操作被成功接收并处理
  3**	重定向，需要进一步的操作以完成请求
  4**	客户端错误，请求包含语法错误或无法完成请求
  5**	服务器错误，服务器在处理请求的过程中发生了错误

• 状态码	状态码英文名称	中文描述
  100	Continue	继续。客户端应继续其请求
  101	Switching Protocols	切换协议。服务器根据客户端的请求切换协议。只能切换到更高级的协议，例如，切换到HTTP的新版本协议
  200	OK	请求成功。一般用于GET与POST请求
  201	Created	已创建。成功请求并创建了新的资源
  202	Accepted	已接受。已经接受请求，但未处理完成
  203	Non-Authoritative Information	非授权信息。请求成功。但返回的meta信息不在原始的服务器，而是一个副本
  204	No Content	无内容。服务器成功处理，但未返回内容。在未更新网页的情况下，可确保浏览器继续显示当前文档
  205	Reset Content	重置内容。服务器处理成功，用户终端（例如：浏览器）应重置文档视图。可通过此返回码清除浏览器的表单域
  206	Partial Content	部分内容。服务器成功处理了部分GET请求
  300	Multiple Choices	多种选择。请求的资源可包括多个位置，相应可返回一个资源特征与地址的列表用于用户终端（例如：浏览器）选择
  301	Moved Permanently	永久移动。请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替
  302	Found	临时移动。与301类似。但资源只是临时被移动。客户端应继续使用原有URI
  303	See Other	查看其它地址。与301类似。使用GET和POST请求查看
  304	Not Modified	未修改。所请求的资源未修改，服务器返回此状态码时，不会返回任何资源。客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源
  305	Use Proxy	使用代理。所请求的资源必须通过代理访问
  306	Unused	已经被废弃的HTTP状态码
  307	Temporary Redirect	临时重定向。与302类似。使用GET请求重定向
  400	Bad Request	客户端请求的语法错误，服务器无法理解
  401	Unauthorized	请求要求用户的身份认证
  402	Payment Required	保留，将来使用
  403	Forbidden	服务器理解请求客户端的请求，但是拒绝执行此请求
  404	Not Found	服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面
  405	Method Not Allowed	客户端请求中的方法被禁止
  406	Not Acceptable	服务器无法根据客户端请求的内容特性完成请求
  407	Proxy Authentication Required	请求要求代理的身份认证，与401类似，但请求者应当使用代理进行授权
  408	Request Time-out	服务器等待客户端发送的请求时间过长，超时
  409	Conflict	服务器完成客户端的 PUT 请求时可能返回此代码，服务器处理请求时发生了冲突
  410	Gone	客户端请求的资源已经不存在。410不同于404，如果资源以前有现在被永久删除了可使用410代码，网站设计人员可通过301代码指定资源的新位置
  411	Length Required	服务器无法处理客户端发送的不带Content-Length的请求信息
  412	Precondition Failed	客户端请求信息的先决条件错误
  413	Request Entity Too Large	由于请求的实体过大，服务器无法处理，因此拒绝请求。为防止客户端的连续请求，服务器可能会关闭连接。如果只是服务器暂时无法处理，则会包含一个Retry-After的响应信息
  414	Request-URI Too Large	请求的URI过长（URI通常为网址），服务器无法处理
  415	Unsupported Media Type	服务器无法处理请求附带的媒体格式
  416	Requested range not satisfiable	客户端请求的范围无效
  417	Expectation Failed	服务器无法满足Expect的请求头信息
  500	Internal Server Error	服务器内部错误，无法完成请求
  501	Not Implemented	服务器不支持请求的功能，无法完成请求
  502	Bad Gateway	作为网关或者代理工作的服务器尝试执行请求时，从远程服务器接收到了一个无效的响应
  503	Service Unavailable	由于超载或系统维护，服务器暂时的无法处理客户端的请求。延时的长度可包含在服务器的Retry-After头信息中
  504	Gateway Time-out	充当网关或代理的服务器，未及时从远端服务器获取请求
  505	HTTP Version not supported	服务器不支持请求的HTTP协议的版本，无法完成处理

4. Content-Type

Content-Type: text/html; charset=utf-8

常见的媒体格式类型如下：

• text/html ： HTML格式
• text/plain ：纯文本格式
• text/xml ： XML格式
• image/gif ：gif图片格式
• image/jpeg ：jpg图片格式
• image/png：png图片格式

以application开头的媒体格式类型：

• application/xhtml+xml ：XHTML格式
• application/xml： XML数据格式
• application/atom+xml ：Atom XML聚合格式
• application/json： JSON数据格式
• application/pdf：pdf格式
• application/msword ： Word文档格式
• application/octet-stream ： 二进制流数据（如常见的文件下载）
• application/x-www-form-urlencoded ：
  中默认的encType，form表单数据被编码为key/value格式发送到服务器（表单默认的提交数据的格式）

另外一种常见的媒体格式是上传文件之时使用的：

• multipart/form-data ： 需要在表单中进行文件上传时，就需要使用该格式

5. Content-Type对照表

4.编写自己的tomcat

1. 思路：

   • 基于socket

2. 代码：

   • 项目结构

   • 

   • package tomcat.demo;
     
     import java.io.IOException;
     import java.io.InputStream;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:21
      * @Description:
      */
     public class MyRequest {
         //请求的url
         private String url;
         //请求的方法类型
         private String method;
     
         //构造函数 传入一个输入流
         public MyRequest(InputStream inputStream) throws IOException {
             //用于存放http请求内容的容器
             StringBuilder httpRequest=new StringBuilder();
             //用于从输入流中读取数据的字节数组
             byte[]httpRequestByte=new byte[1024];
             int length=0;
             //将输入流中的内容读到字节数组中，并且对长度进行判断
             if((length=inputStream.read(httpRequestByte))>0) {
                 //证明输入流中有内容，则将字节数组添加到容器中
                 httpRequest.append(new String(httpRequestByte,0,length));
             }
             //将容器中的内容打印出来
             System.out.println("httpRequest = [ "+httpRequest+" ]");
     
     
             //从httpRequest中获取url，method存储到myRequest中
             String httpHead=httpRequest.toString().split("\n")[0];
             url=httpHead.split("\\s")[1];
             System.out.println("url:"+url);
             method=httpHead.split("\\s")[0];
             System.out.println("method:"+method);
             System.out.println("MyRequests = [ "+this+" ]");
         }
     
         public String getUrl() {
             return url;
         }
     
         public void setUrl(String url) {
             this.url = url;
         }
     
         public String getMethod() {
             return method;
         }
     
         public void setMethod(String method) {
             this.method = method;
         }
     
     }
     
     

   • package tomcat.demo;
     
     import java.io.IOException;
     import java.io.OutputStream;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:22
      * @Description:
      */
     public class MyResponse {
         //定义输出流
         private OutputStream outputStream;
     
         //构造函数 传入输出流
         public MyResponse(OutputStream outputStream) {
             this.outputStream=outputStream;
         }
     
         //创建写出方法
         public void write(String content)throws IOException {
             //用来存放要写出数据的容器
             StringBuffer stringBuffer=new StringBuffer();
             stringBuffer.append("HTTP/1.1 200 OK\r\n")
                     .append("Content-type:text/html\r\n")
                     .append("\r\n")
                     .append("<html><head><title>Hello World</title></head><body>")
                     .append(content)
                     .append("</body><html>");
     
             //转换成字节数组 并进行写出
             outputStream.write(stringBuffer.toString().getBytes());
             //System.out.println("sss");
             outputStream.close();
         }
     }
     
     

   • package tomcat.demo;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:24
      * @Description:
      */
     //写一个抽象类作为servlet的父类
     public abstract class MyServlet {
         //需要子类实现的抽象方法
         protected abstract void doGet(MyRequest request,MyResponse response);
         protected abstract void doPost(MyRequest request,MyResponse response);
     
         //父类自己的方法
         //父类的service方法对传入的request以及response
         //的方法类型进行判断，由此调用doGet或doPost方法
         public void service(MyRequest request,MyResponse response) throws NoSuchMethodException {
             if(request.getMethod().equalsIgnoreCase("POST")) {
                 doPost(request, response);
             }else if(request.getMethod().equalsIgnoreCase("GET")) {
                 doGet(request, response);
             }else {
                 throw new NoSuchMethodException("not support");
             }
         }
     }
     
     

   • package tomcat.demo;
     
     import java.io.IOException;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:25
      * @Description:
      */
     public class StudentServlet extends MyServlet{
     
         @Override
         protected void doGet(MyRequest request, MyResponse response) {
             //利用response中的输出流 写出内容
             try {
                 //System.out.println("!!!!!!!!!!!!!!!!!!");
                 response.write("I am a student.");
                 //System.out.println("9999999999999999");
             }catch(IOException e) {
                 e.printStackTrace();
             }
         }
     
         @Override
         protected void doPost(MyRequest request, MyResponse response) {
             //利用response中的输出流 写出内容
             try {
                 response.write("I am a student.");
             }catch(IOException e) {
                 e.printStackTrace();
             }
         }
     }
     
     

   • package tomcat.demo;
     
     import java.io.IOException;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:27
      * @Description:
      */
     public class TeacherServlet extends MyServlet{
         @Override
         protected void doGet(MyRequest request, MyResponse response) {
             //利用response中的输出流 写出内容
             try {
                 response.write("I am a teacher.");
             }catch(IOException e) {
                 e.printStackTrace();
             }
         }
     
         @Override
         protected void doPost(MyRequest request, MyResponse response) {
             //利用response中的输出流 写出内容
             try {
                 response.write("I am a teacher.");
             }catch(IOException e) {
                 e.printStackTrace();
             }
         }
     }
     
     

   • package tomcat.demo;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:28
      * @Description:
      */
     public class ServletMapping {
         //servlet的名字
         private String servletName;
         //请求的url
         private String url;
         //servlet类
         private String clazz;
         public String getServletName() {
             return servletName;
         }
         public void setServletName(String servletName) {
             this.servletName = servletName;
         }
         public String getUrl() {
             return url;
         }
         public void setUrl(String url) {
             this.url = url;
         }
         public String getClazz() {
             return clazz;
         }
         public void setClazz(String clazz) {
             this.clazz = clazz;
         }
         public ServletMapping(String servletName, String url, String clazz) {
             super();
             this.servletName = servletName;
             this.url = url;
             this.clazz = clazz;
         }
     }
     
     

   • package tomcat.demo;
     
     import java.util.ArrayList;
     import java.util.List;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:29
      * @Description:
      */
     public class ServletMappingConfig {
         //使用一个list类型 里面存储的是映射关系类Mapping
         public static List<ServletMapping> servletMappings=new ArrayList<>(16);
     
         //向其中添加映射关系
         static {
             servletMappings.add(new ServletMapping("student","/student", "tomcat.demo.StudentServlet"));
             servletMappings.add(new ServletMapping("teacher","/teacher", "tomcat.demo.TeacherServlet"));
         }
     }
     
     

   • package tomcat.demo;
     
     import java.io.IOException;
     import java.io.InputStream;
     import java.io.OutputStream;
     import java.net.ServerSocket;
     import java.net.Socket;
     import java.util.HashMap;
     import java.util.Map;
     
     /**
      * @Author: 
      * @Date: 2021/4/1 13:29
      * @Description:
      */
     //Tomcat服务器类 编写对请求做分发处理的相关逻辑
     public class MyTomcat {
         //端口号
         private int port=8080;
         //用于存放请求路径与对应的servlet类的请求映射关系的map
         //相应的信息从配置类中获取
         private Map<String, String> urlServletMap=new HashMap<>(16);
         //构造方法
         public MyTomcat(int port) {
             this.port=port;
         }
     
         //tomcat服务器的启动方法
         public void start() {
             //初始化请求映射关系
             initServletMapping();
             boolean flag = true;
             //服务端的套接字
             ServerSocket serverSocket=null;
             try {
                 //创建绑定到某个端口的服务端套接字
                 serverSocket=new ServerSocket(port);
                 System.out.println("MyTomcat begin start...");
                 //循环 用于接收客户端
                 while(flag) {
                     //接收到的客户端的套接字
                     Socket socket=serverSocket.accept();
                     //获取客户端的输入输出流
                     InputStream inputStream=socket.getInputStream();
                     OutputStream outputStream=socket.getOutputStream();
                     //通过输入输出流创建请求与响应对象
                     MyRequest request=new MyRequest(inputStream);
                     MyResponse response=new MyResponse(outputStream);
     
                     //根据请求对象的method分发请求 调用相应的方法
                     dispatch(request, response);
                     //关闭客户端套接字
                     socket.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     
         //初始化请求映射关系，相关信息从配置类中获取
         private void initServletMapping() {
             for(ServletMapping servletMapping:ServletMappingConfig.servletMappings) {
                 urlServletMap.put(servletMapping.getUrl(), servletMapping.getClazz());
             }
         }
     
         //通过当前的request以及response对象分发请求
         private void dispatch(MyRequest request,MyResponse response) {
             //根据请求的url获取对应的servlet类的string
             String clazz=urlServletMap.get(request.getUrl());
             System.out.println("============================="+clazz);
             try {
                 //通过类的string将其转化为对象
                 Class servletClass=Class.forName(clazz);
                 //实例化一个对象
                 MyServlet myServlet=(MyServlet)servletClass.newInstance();
     
                 //调用父类方法，根据request的method对调用方法进行判断
                 //完成对myServlet中doGet与doPost方法的调用
                 myServlet.service(request, response);
             } catch (ClassNotFoundException e) {
                 e.printStackTrace();
             } catch (IllegalAccessException e) {
                 e.printStackTrace();
             } catch (InstantiationException e) {
                 e.printStackTrace();
             } catch (NoSuchMethodException e) {
                 e.printStackTrace();
             }
         }
     
         //main方法  直接启动tomcat服务器
         public static void main(String[] args) {
             new MyTomcat(8080).start();
         }
     }
     
     

   • 运行结果

   • 

   • 之所以会报错，是因为tomcat在循环监听，当处理完一次请求后，下一次无请求内容，但仍在接收socket的端口内容

Tomcat入门

原文：https://www.cnblogs.com/namusangga/p/14613297.html