tomcat原理解析(一)：一个简单的实现

一 概述

       前段时间去面试，被人问到了tomcat实现原理。由于平时没怎么关注容器的实现细节，这个问题基本没回答上来。所以最近花了很多时间一直在网上找资料和看tomcat的源码来研究里面处理一个HTTP请求的流程。网上讲tomcat的帖子比较多，大多都是直接切入主题看其源码，从我个人感受来说直接研究其源码实现比较难理解和非常枯燥，需要由简到难，慢慢深入。

二  一个简单tomcat服务器实现

        tomat是一个servlet容器，来处理http请求。在平时的使用中我们都会再浏览器中输入http地址来访问服务资源，比如格式http://host[":"port][abs_path]。从浏览器到服务端的一次请求都遵循http协议，在网络上其实走仍然是tcp协议，即我们常使用的socket来处理客户端和服务器的交互。根据输入的http地址可以知道服务器的IP地址和端口，根据这两个参数就可以定位到服务器的唯一地址。tomcat根据http地址端口后面的资源路径就可以知道反馈什么样的资源给浏览器。下面给出了一个非常简单的代码模拟了tomcat的简单实现

[html] view plain copy
  1. package com;  
  2.   
  3. import java.io.*;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6. import java.net.URLDecoder;  
  7. import java.util.StringTokenizer;  
  8.   
  9. public class TomcatServer {  
  10.   
  11.     private final static int PORT = 8080;  
  12.   
  13.     public static void main(String[] args) {  
  14.   
  15.         try {  
  16.             ServerSocket server = new ServerSocket(PORT);//根据端口号启动一个serverSocket  
  17.             ServletHandler servletHandler=new ServletHandler(server);  
  18.             servletHandler.start();  
  19.         } catch (Exception e) {  
  20.             e.printStackTrace();  
  21.         }  
  22.   
  23.     }  
  24.   
  25.   
  26.   
  27.     private static class ServletHandler extends Thread{  
  28.         ServerSocket server=null;  
  29.         public ServletHandler(ServerSocket server){  
  30.             this.server=server;  
  31.         }  
  32.   
  33.   
  34.         @Override  
  35.         public void run() {  
  36.             while (true) {  
  37.                 try {  
  38.                     Socket client = null;  
  39.                     client = server.accept();//ServerSocket阻塞等待客户端请求数据  
  40.                     if (client != null) {  
  41.                         try {  
  42.                             System.out.println("接收到一个客户端的请求");  
  43.   
  44.                             //根据客户端的Socket对象获取输入流对象。  
  45.                             //封装字节流到字符流  
  46.                             BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));  
  47.   
  48.                             // GET /test.jpg /HTTP1.1  
  49.                             //http请求由三部分组成，分别是：请求行、消息报头、请求正文。  
  50.                             //这里取的第一行数据就是请求行。http协议详解可以参考http://www.cnblogs.com/li0803/archive/2008/11/03/1324746.html说的很详细  
  51.                             String line = reader.readLine();  
  52.   
  53.                             System.out.println("line: " + line);  
  54.   
  55.                             //拆分http请求路径，取http需要请求的资源完整路径  
  56.                             String resource = line.substring(line.indexOf('/'),line.lastIndexOf('/') - 5);  
  57.   
  58.                             System.out.println("the resource you request is: "+ resource);  
  59.   
  60.                             resource = URLDecoder.decode(resource, "UTF-8");  
  61.   
  62.                             //获取到这次请求的方法类型，比如get或post请求  
  63.                             String method = new StringTokenizer(line).nextElement().toString();  
  64.   
  65.                             System.out.println("the request method you send is: "+ method);  
  66.   
  67.                             //继续循环读取浏览器客户端发出的一行一行的数据  
  68.                             while ((line = reader.readLine()) != null) {  
  69.                                 if (line.equals("")) {//当line等于空行的时候标志Header消息结束  
  70.                                     break;  
  71.                                 }  
  72.                                 System.out.println("the Http Header is : " + line);  
  73.                             }  
  74.   
  75.                             //如果是POST的请求，直接打印POST提交上来的数据  
  76.                             if ("post".equals(method.toLowerCase())) {  
  77.                                 System.out.println("the post request body is: "  
  78.                                         + reader.readLine());  
  79.                             }else if("get".equals(method.toLowerCase())){  
  80.                                 //判断是get类型的http请求处理  
  81.                                 //根据http请求的资源后缀名来确定返回数据  
  82.   
  83.                                 //比如下载一个图片文件，我这里直接给定一个图片路径来模拟下载的情况  
  84.                                 if (resource.endsWith(".jpg")) {  
  85.                                     transferFileHandle("d://123.jpg", client);  
  86.                                     closeSocket(client);  
  87.                                     continue;  
  88.   
  89.                                 } else {  
  90.   
  91.                              //直接返回一个网页数据  
  92.                              //其实就是将html的代码以字节流的形式写到IO中反馈给客户端浏览器。  
  93.                              //浏览器会根据http报文“Content-Type”来知道反馈给浏览器的数据是什么格式的，并进行什么样的处理  
  94.   
  95.                              PrintStream writer = new PrintStream(client.getOutputStream(), true);  
  96.                              writer.println("HTTP/1.0 200 OK");// 返回应答消息,并结束应答  
  97.                              writer.println("Content-Type:text/html;charset=utf-8");  
  98.                              writer.println();  
  99.                              //writer.println("Content-Length:" + html.getBytes().length);// 返回内容字节数  
  100.                              writer.println("<html><body>");  
  101.                              writer.println("<a href='www.baidu.com'>百度</a>");  
  102.                              writer.println("<img src='https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superman/img/logo/bd_logo1_31bdc765.png'></img>");  
  103.                              writer.println("</html></body>");  
  104.   
  105.   
  106.                              //writer.println("HTTP/1.0 404 Not found");// 返回应答消息,并结束应答  
  107.                              writer.println();// 根据 HTTP 协议, 空行将结束头信息  
  108.                              writer.close();  
  109.                              closeSocket(client);//请求资源处理完毕，关闭socket链接  
  110.                              continue;  
  111.                                 }  
  112.                             }  
  113.   
  114.   
  115.   
  116.                         } catch (Exception e) {  
  117.                             System.out.println("HTTP服务器错误:"  
  118.                                     + e.getLocalizedMessage());  
  119.                         }  
  120.                     }  
  121.                 } catch (Exception e) {  
  122.                     e.printStackTrace();  
  123.                 }  
  124.             }  
  125.         }  
  126.   
  127.         private void closeSocket(Socket socket) {  
  128.             try {  
  129.                 socket.close();  
  130.             } catch (IOException ex) {  
  131.                 ex.printStackTrace();  
  132.             }  
  133.             System.out.println(socket + "离开了HTTP服务器");  
  134.         }  
  135.   
  136.         private void transferFileHandle(String path, Socket client) {  
  137.   
  138.             File fileToSend = new File(path);  
  139.   
  140.             if (fileToSend.exists() && !fileToSend.isDirectory()) {  
  141.                 try {  
  142.                     //根据Socket获取输出流对象，将访问的资源数据写入到输出流中  
  143.                     PrintStream writer = new PrintStream(client.getOutputStream());  
  144.                     writer.println("HTTP/1.0 200 OK");// 返回应答消息,并结束应答  
  145.                     writer.println("Content-Type:application/binary");  
  146.                     writer.println("Content-Length:" + fileToSend.length());// 返回内容字节数  
  147.                     writer.println();// 根据 HTTP 协议, 空行将结束头信息  
  148.   
  149.                     FileInputStream fis = new FileInputStream(fileToSend);  
  150.                     byte[] buf = new byte[fis.available()];  
  151.                     fis.read(buf);  
  152.                     writer.write(buf);  
  153.                     writer.close();  
  154.                     fis.close();  
  155.                 } catch (IOException e) {  
  156.                     e.printStackTrace();  
  157.                 }  
  158.             }  
  159.         }  
  160.   
  161.     }  
  162.   
  163. }  

三  实践

    1.在浏览器中输入http://localhost:8080/123.jpg 链接，可以看到浏览器里面就将123.jpg下载到本地了。

    2.在浏览器中输入一个服务器不能识别的请求后缀比如http://localhost:8080/123.jpg1，可以看到浏览器打开了一个网页。如下图：点击里面的百度链接可以跳转

    3.后台tomcat服务器打印的http请求报文

      接收到一个客户端的请求
line: GET /123.jpg1 HTTP/1.1
the resource you request is: /123.jpg1
the request method you send is: GET
the Http Header is : Host: localhost:8080
the Http Header is : Connection: keep-alive
the Http Header is : Pragma: no-cache
the Http Header is : Cache-Control: no-cache
the Http Header is : Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
the Http Header is : Upgrade-Insecure-Requests: 1
the Http Header is : User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36
the Http Header is : Accept-Encoding: gzip, deflate, sdch
the Http Header is : Accept-Language: zh-CN,zh;q=0.8
Socket[addr=/0:0:0:0:0:0:0:1,port=57864,localport=8080]离开了HTTP服务器

四  总结

从整个代码和测试情况来看，一次http请求其实就是一次socket套接字的处理。浏览器发起scoket的请求，tomcat服务器接受请求，并根据请求的路径定位客户端需要访问的资源。  只是socket客户端和服务器数据在交互时，都遵守着http协议规范。当然真正的tomcat容器比这个demo实现要复杂的很多，这个简易的tomcat服务器能够帮我们更好的理解tomcat源码。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/csguo/p/7499395.html