【JAVA】手写简易服务器(深刻理解Tomcat)

最新推荐文章于 2021-05-31 13:34:52 发布
最新推荐文章于 2021-05-31 13:34:52 发布
阅读量243 收藏 3
点赞数 3
分类专栏： JAVA 文章标签： java servlet http 后端 tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oNew_Lifeo/article/details/114639457
版权

一、知识体系

1、面向对象

特点：概括为封装性、继承性和多态性

2、IO流

用于获取请求协议和发送响应信息

3、多线程

使得服务器能够并发访问

4、xml解析

解析web.xml配置文件

5、反射

概念：把java类中的各种结构（方法、属性、构造器、类名）映射成一个个的java对象

目标：通过用户访问的url解析成类名并获取相应的servlet对象，以此来返回不同的页面

6、http协议

HTTP是一个应用层协议，由请求和响应构成，是一个标准的客户端服务器模型。HTTP是一个无状态的协议。

底层是基于socket的短链接实现。

目标：
1、使用ServerSocket建立与浏览器的连接, 获取请求协议
2、返回响应协议 （封装响应信息）

二、获取请求协议及封装

1、获取请求协议
//1、创建ServerSocket
ServerSocket serverSocket = new ServerSocket(8888);
//2、建立连接获取Socket
Socket client = serverSocket.accept();
System.out.println("一个客户端建立了连接...");
//3、通过输入流获取请求协议
InputStream is = client.getInputStream();
paramMap = new HashMap<>();
byte[] datas = new byte[1024*1024];
int len = 0;
try {
    len = is.read(datas);
    String requestInfo = new String(datas,0,len);
} catch (IOException e) {
    e.printStackTrace();
}

请求协议格式:
GET请求:
在这里插入图片描述

POST请求:
在这里插入图片描述

2、封装request

目的：
1、获取用户访问的url和请求参数

根据获取的请求协议，并通过分割字符串获取请求方法、请求url和请求参数（需要注意的是get请求参数是通过?直接跟在url后面，post请求在最后一行，与请求体之间有一个空行）

下面通过封装request并对请求协议进行处理

package com.swust.java.practice.http;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.util.*;

/**
 * 封装请求协议
 *  1、获取  method uri 请求参数
 *  2、封装请求参数为map
 */
public class Request {
    // 请求协议信息
    private String requestInfo;
    // 请求方式
    private String method;
    // 请求url
    private String url;
    // 请求参数
    private String queryParam;
    // 处理请求参数
    private Map<String, List<String>> paramMap;

    private final String CRLF = "\r\n";

    public Request() {}

    public Request(Socket client) throws IOException {
        this(client.getInputStream());
    }

    public Request(InputStream is) {
        paramMap = new HashMap<>();
        byte[] data = new byte[1024*1024];
        int len = 0;
        try {
            len = is.read(data);
            requestInfo = new String(data,0,len - 1);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 解析字符串
        parseRequestInfo();
    }

    private void parseRequestInfo(){
        System.out.println("--解析数据--");
        //System.out.println(requestInfo);
        // 1、获取请求方式
        method = requestInfo.substring(0,requestInfo.indexOf("/")).trim().toLowerCase();

        // 2、获取请求路径  路径中可能包含参数
        url = requestInfo.substring(requestInfo.indexOf("/")+1,requestInfo.indexOf("HTTP/")).trim();
        if(url.contains("?")){
            String[] array = url.split("\\?");
            queryParam = array[1].trim();
            url = array[0].trim();
        }
        // 3、获取请求参数  空行之后 请求体
        if(method.equals("post")){
            String param = requestInfo.substring(requestInfo.lastIndexOf(CRLF)).trim();
            if(null == queryParam){
                queryParam = param;
            }else{
                queryParam += "&" + param;
            }
        }
        queryParam = null == queryParam ? "" : queryParam;// 避免get请求无参数时为空
        System.out.println("请求方法:"+method);
        System.out.println("请求路径:"+url);
        System.out.println("请求参数:"+queryParam);
        paramConvertToMap(queryParam);
    }
    // 将请求参数由字符串转成map  name=bob&pwd=123&age=23&age=18
    private void paramConvertToMap(String queryParam){
        //1、分割字符串
        String[] array = queryParam.split("&");
        for(String kv : array){
            String[] s = kv.trim().split("=");
            s = Arrays.copyOf(s,2);// 防止出现无参数值的情况
            String key = s[0];
            String value = s[1] == null ? null : decode(s[1],"UTF-8");
            // 2、存储
            if(!paramMap.containsKey(key)){// 当map中不包含key
                paramMap.put(key,new ArrayList<>());
            }
            paramMap.get(key).add(value);
        }
    }
    // 处理中文乱码问题
    private String decode(String value,String enc){
        try {
            return java.net.URLDecoder.decode(value,enc);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }
    // 获取指定key的所有参数值
    public String[] getParamValues(String key){
        List<String> values = paramMap.get(key);
        if(null == values || values.size() < 1){
            return null;
        }
        return values.toArray(new String[0]);
    }
    // 获取指定key的一个参数值
    public String getParam(String key){
        String[] values = getParamValues(key);
        return values == null ? null : values[0];
    }

    public String getMethod() {
        return method;
    }

    public String getUrl() {
        return url;
    }

    public String getQueryParam() {
        return queryParam;
    }
}

三、返回响应协议及封装

1、返回响应协议
final String BLANK = "";
final String CRLF = "\r\n";
//1、准备内容	
StringBuilder content = new StringBuilder();
content.append("<html>");
content.append("<html>");
content.append("<head>");
content.append("<title>");
content.append("response success (*^▽^*)");
content.append("</title>");
content.append("</head>");
content.append("<body>");
content.append("<h2>登录页面->服务器响应成功!!!</h2>");
content.append("</body>");
content.append("</html>");
//2、获取字节数
int size = content.toString().getBytes().length;
//3、拼接响应协议
StringBuilder headInfo = new StringBuilder();
headInfo.append("HTTP/1.1").append(BLANK)
                .append(statusCode).append(BLANK)
                .append("OK").append(CRLF);// 响应行
headInfo.append("Date:").append(new Date()).append(CRLF)
                .append("Server:").append("hqf Server/0.0.1").append(CRLF)
                .append("Content-type:text/html;charset=UTF-8").append(CRLF)
                .append("Content-length:").append(len).append(CRLF)
                .append(CRLF);// 响应头
//4、使用输出流输出到browser
try {
	BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
   	bw.append(headInfo).append(content).flush();
} catch (IOException e) {
   e.printStackTrace();
}
2、封装响应协议

目的：
1、能够动态添加内容
2、根据状态码拼接头信息

package com.swust.java.practice.http;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Date;

/**
 * 封装响应信息
 *  1、动态添加内容
 *  2、根据状态码拼接头信息
 */
public class Response {

    BufferedWriter bw;
    // 协议头信息
    private StringBuilder headInfo;
    // 正文
    private StringBuilder content;
    // 正文字节数
    private int len;

    private final String BLANK = " ";
    private final String CRLF = "\r\n";


    private Response() {
        headInfo = new StringBuilder();
        content = new StringBuilder();
        len = 0;
    }

    public Response(Socket client){
        this();
        try {
            bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
        } catch (IOException e) {
            e.printStackTrace();
            headInfo = null;
        }
    }

    public Response(OutputStream os){
        this();
        bw = new BufferedWriter(new OutputStreamWriter(os));
    }

    // 构建头信息 （状态码）
    private void createHeadInfo(int statusCode){
        // 1、响应行
        headInfo.append("HTTP/1.1").append(BLANK)
                .append(statusCode).append(BLANK);
        switch (statusCode){
            case 200:
                headInfo.append("OK").append(CRLF);
                break;
            case 404:
                headInfo.append("Not Found").append(CRLF);
                break;
            case 500:
                headInfo.append("Server Error").append(CRLF);
                break;
        }
        // 2、响应头
        headInfo.append("Date:").append(new Date()).append(CRLF)
                .append("Server:").append("hqf Server/0.0.1").append(CRLF)
                .append("Content-type:text/html;charset=UTF-8").append(CRLF)
                .append("Content-length:").append(len).append(CRLF)
                .append(CRLF);
    }

    // 动态添加Response内容
    public Response print(String info){
        content.append(info);
        len += info.getBytes().length;
        return this;
    }

    public Response println(String info){
        content.append(info).append(CRLF);
        len += (info + CRLF).getBytes().length;
        return this;
    }

    // 返回响应信息
    public void pushToBrowser(int statusCode){
        if(null == headInfo){
            statusCode = 500;
        }
        createHeadInfo(statusCode);
        try {
            bw.append(headInfo).append(content).flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四、引入Servlet

通过引入servlet来处理不同的业务代码

通过接口中的service方法来构建不同的返回内容，response.pushToBrowser来返回不同的状态码

示例：

接口Servlet.java

package com.swust.java.practice.servlet;

import com.swust.java.practice.http.Request;
import com.swust.java.practice.http.Response;

/**
 * 服务器脚本接口
 */
public interface Servlet {

    void service(Request request, Response response);

    void doGet(Request request, Response response);

    void doPost(Request request, Response response);
}

LoginServlet.java

package com.swust.java.practice.servlet;

import com.swust.java.practice.http.Request;
import com.swust.java.practice.http.Response;

public class LoginServlet implements Servlet {

    @Override
    public void service(Request request, Response response) {
        response.print("<html>");
        response.print("<html>");
        response.print("<head>");
        response.print("<title>");
        response.print("response success (*^▽^*)");
        response.print("</title>");
        response.print("</head>");
        response.print("<body>");
        response.print("<h2>登录页面->服务器响应成功!!!</h2>"+request.getParam("name"));
        response.print("</body>");
        response.print("</html>");

    }

    @Override
    public void doGet(Request request, Response response) {

    }

    @Override
    public void doPost(Request request, Response response) {

    }
}

五、解析web.xml配置文件

目标：
1、通过servlet-mapping中的url-pattern获取servlet中的servlet-class（之后使用该类名并通过反射获取对应的servlet对象）
web.xml文件
在这里插入图片描述

//一、通过sax解析文件获取servlet对象和servlet-mapping对象并分别保存到一个列表中
//SAX解析
//1、获取解析工厂
SAXParserFactory factory = SAXParserFactory.newInstance();
//2、从解析工厂获取解析器
SAXParser parser = factory.newSAXParser();
//3、加载文档Document注册处理器
WebHandler handler = new WebHandler();
//4、编写处理器
//5、解析  使用当前类加载器获取xml资源
parser.parse(Thread.currentThread().
                getContextClassLoader().
                getResourceAsStream("com/swust/java/practice/web.xml"),
        handler);
// 获取数据
List<Entity> entities = handler.getEntities();
List<Mapping> mappings = handler.getMappings();
//二、上下文处理
WebContext webContext = new WebContext(entities,mappings);
String name = webContext.getClz(url); // 通过url获取对应类名
//三、根据反射获取Servlet对象
try {
   // 获取类对象
   Class clz = Class.forName(name);
   // 实例化对象
   com.swust.java.practice.servlet.Servlet servlet = (com.swust.java.practice.servlet.Servlet) clz.getConstructor().newInstance();
} catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
   e.printStackTrace();
}

六、封装分发器

目的：
通过多线程实现并发访问

package com.swust.java.practice.dispatcher;

import com.swust.java.practice.http.Request;
import com.swust.java.practice.http.Response;
import com.swust.java.practice.servlet.Servlet;
import com.swust.java.practice.web.WebApp;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

/**
 * 分发器
 */
public class Dispatcher implements Runnable{

    private Socket client;
    private Request request;
    private Response response;

    public Dispatcher(Socket client) {
        this.client = client;
        try {
            /**
             * 获取请求协议
             */
            this.request = new Request(client);
            /**
             * 返回响应协议
             */
            this.response = new Response(client);
        } catch (IOException e) {
            e.printStackTrace();
            this.release();
        }

    }

    @Override
    public void run() {
        try{
            if(null == request.getUrl() || request.getUrl().equals("")){// 首页
                loadResource("index");
                response.pushToBrowser(200);
                return;
            }
            Servlet servlet = WebApp.getServletFromUrl(request.getUrl());
            if(null != servlet){// 找到了对应的servlet
                servlet.service(request,response);
                // 返回状态码
                response.pushToBrowser(200);
            }else{// 404
                loadResource("404");
                response.pushToBrowser(404);
            }
        }catch (Exception e){
            loadResource("500");
            response.pushToBrowser(500);
        }
        release();// 短链接 提高性能
    }

    // 根据页面名称加载资源
    private void loadResource(String pageName){
        try {
            // 通过类加载器查找资源
            InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/swust/java/practice/views/"+pageName+".html");
            byte[] bytes = new byte[1024 * 1024];
            is.read(bytes);
            response.print(new String(bytes));
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 释放资源
    private void release(){
        try {
            this.client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7、完结

Server.java
开启服务、关闭服务和接收请求协议

package com.swust.java.practice;

import com.swust.java.practice.dispatcher.Dispatcher;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 目标：
 *      1、使用ServerSocket建立与浏览器的连接, 获取请求协议
 *      2、返回响应协议 （封装响应信息）
 */
public class Server {

    private ServerSocket serverSocket;

    private boolean isRunning;

    // 开启服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
            isRunning = true;
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败...");
        }
    }

    // 接受连接并进行处理
    public void receive(){
        while (isRunning){
            try {
                // 多线程处理
                Socket client = serverSocket.accept();
                System.out.println("一个客户端建立了连接...");
                new Thread(new Dispatcher(client)).start();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("客户端连接异常...");
                this.stop();
            }
        }
    }

    // 停止服务
    public void stop(){
        isRunning = false;
        try {
            serverSocket.close();
            System.out.println("服务器已停止");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.start();
        server.receive();
    }

}

项目结构:
在这里插入图片描述

在线打码
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java手写仿Tomcat的服务器过程详解
结庐境的博客
05-01 1380
基础知识整理 手写一个仿Tomcat的服务器需要一些基本的基础知识，不需要掌握的有多高深，但是需要知道如何使用，最基础的Java语法这里就不再赘述，只大略的列举一下一些高级的知识点。 1、计算机网络知识：TCP、http tcp是一种需要保持连接的网络协议，http是在建立了tcp连接的基础上，按照一定的语法书写相关的内容，可以理解为http就是一种模板，大家都按照这个模板书写要传输的信息，那样处...
如何在Java中创建一个简单的HTTP服务器
很酷的站长的博客
09-17 1619
在Java中创建一个简单的HTTP服务器可以通过利用Java内置的com.sun.net.httpserver.HttpServer类来完成。以下将会对此进行详细的介绍。
自己手写一个简单的tomcat服务器
baidu_24545901的博客
01-21 5181
Tomcat服务器本质上就是一个 Server的程序，所以这里我们先写一个Server的程序和一个Socket程序，然后在对其进行改装 Server服务端的程序见下文所示 public class Server { /* Tomcat其实就是一个socket编程 下面的流程中 有两个流程, 第一个流程是 客户端请求浏览器的流程 第二个业务流程是 服务器给客户
JAVA简易WEB服务器（二）
weixin_34416649的博客
02-23 95
在上一篇博客中《JAVA简易WEB服务器（一）》我们了解了浏览器与服务端之间的通信数据的格式。这一篇博客开始，我们会一步一步的完成一个简易的WEB服务器的开发，需要注意的是，这里介绍的只是一种思路，毕竟开发一个服务器的工作量是很大的，而且需要考虑的事情很多，这里面我们只是简单的实现其部分功能，有兴趣可以自己进行扩展，深入研究。 言归正...
Java 创建简单HTTP服务器
allway2的博客
05-31 1802
Java 标准版附带了一个HTTP 服务器API，可以用它来创建一个简单、能工作的嵌入式 HTTP 服务器。下面的程序不需要任何外部依赖。它监听8000 端口，对进来的请求返回一 个成功的HTTP 响应（200），响应内容为如下的JSON 对象： {"testResponse":"Hello World"} 这里需要一个Java 源文件，包含一个定义了main 方法的类。在main 方法中，创建了一个 服务器实例，该服务器实例根据URL 将请求委托给一个静态处理器（这里被定义为一个 静态内部类）： i
基于Java的MiniCat手写Http服务器设计源码
最新发布
04-15
基于Java的MiniCat手写Http服务器设计源码，该项目包含52个文件，主要文件类型有48个java源文件。此外，还包括1个gitignore文件用于版本控制，1个LICENSE许可文件，以及1个Markdown文档用于项目说明。该项目是一个...
java基础实现手写服务器
10-25
手写服务器的核心是理解网络通信的基本原理，包括TCP/IP协议和Socket编程。TCP是一种面向连接的、可靠的传输层协议，而Socket则是TCP/IP协议族中的应用接口，允许两个网络应用进行全双工通信。在Java中，我们可以...
Java手写简易版HashMap的使用（存储+查找）
08-25
Java手写简易版HashMap的使用（存储+查找） Java手写简易版HashMap是Java中的一种常用的数据结构，它提供了高效的存储和查找键值对的功能。下面我们将详细介绍Java手写简易版HashMap的使用，包括存储和查找键值对的...
java手写识别超级准确
11-30
Java手写识别技术是一种在Java平台上实现的图像处理与机器学习技术，主要用于识别手写数字或字符。在本项目中，"java手写识别超级准确" 提示我们这是一个高效的识别系统，具有高度的准确率，并且它采用了Swing库来...
手写仿Tomcat服务器代码
05-01
【标题】"手写仿Tomcat服务器代码"揭示了这个项目的核心目标——通过编写Java代码来模拟Tomcat服务器的关键功能。Tomcat是一个流行的开源应用服务器，尤其用于部署和运行Java Servlet和JavaServer Pages (JSP)。 ...
基于Java手写web服务器(简易版)
三十年后的星光的博客
12-21 4608
本人尚在java 学习阶段，不是技术大咖， 自认是技术宅， 有一点写东西的能力，因最近学习了java网络编程，决定手写一个web服务器，不喜勿喷，大神也请高抬贵手，不足之处还望指点一二，不胜感激！ 目录结构 项目文件目录，是基于Maven的标准文件夹目录，src内包含7个类和一个接口，user包下的类为使用类。一个config文件夹用于存放服务器配置文件，webapps文件夹为服务器站点目录。...
手写一个Tomcat服务器
yechengchao的博客
05-15 1907
作为java开发者，都知道Tomcat是一个家户喻晓的Web服务器。手写一个Tomcat对我们理解Tomcat的工作原理，还有servlet的执行流程有很大的帮助，下面是我手写一个简要版Tomcat的总结和收获！ 首先，先还原Tomcat的本质： 相信大家之前在开发的时候，虽然已经能上手开发web程序，但是对于Servlet的执行流程以及项目还会存在很多疑问，下面是我总结的我之前的疑问也给出相应...
java 编写简易的http服务器
一小生，名大白
06-05 8772
java 编写简易的http服务器 想要写一个http服务器，首先得了解http协议。这里仅介绍一下相关的知识。 1、http协议 HTTP请求报文 在请求中，HTTP报文由方法、URI、HTTP版本、HTTP首部字段等部分构成。其中方法、URI、HTTP版本作为首行，然后每个HTTP首部字段为一行，以上内容简称为请求头，如下请求头： GET /favicon.ico HTTP/1.1...
手写一个简单服务器
qq_36336898的博客
10-31 717
今天来手写一个简单服务器！让你知道例如像tomcat之类的服务器是如何处理浏览器请求响应网页滴！ 1.HTTP http 是 超文本传输协议，有请求，有响应。协议嘛，肯定是一种规定，要传什么什么样的数据。 请求格式是这样滴： 例如： 请求行：GET /index.html HTTP/1.1\n 请求头：HOST:www.baidu.com\n\n \n 请求体：bulalallalallal 响应格式是这样滴： 例如： 响应行：HTTP/1.1 200 OK\n 响应头：Content-Type:text/
从零开始手写Tomcat，一文彻底搞懂Tomcat运行流程（附源码）
Java鱼仔的博客
10-23 6580
一：理论铺垫 tomcat的功能是什么？ tomcat是java的一个中间件，浏览器发出HTTP请求后经过tomcat中间件，转发到目的服务器，目的服务器返回响应消息，通过tomcat返回给浏览器。tomcat的使用很简单，但是作为合格的程序员，光会用可不行，接下来就通过手写一个tomcat彻底搞懂tomcat。 在手写Tomcat之前，首先重温一下http和servlet，http协议...
使用java NIO编写简易的服务器
qq_40120190的博客
08-16 267
学了两天NIO,很多地方还不是很透彻,所以以下代码仅做参考… 可直接运行,通过浏览器直接就可以访问,打印原生socket,更好学习http协议,并发访问没测,有兴趣的可以自己写客户端测试 package com.ideal.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.B...
手写Tomcat服务器 （一）
knight20160302的博客
03-30 374
纯手写Tomcat服务器，实现简易版的HttpServer 话不多说，上图： 是不是很简单啊？ 其实实现步骤也很简单。 一、建立连接 因为HTTP(Hypertext Transport Protocol)是一个基于TCP/IP通信协议来传递数据，所以首先得通过TCP Socket建立浏览器与服务器之间的连接。 二、发送请求 在建立连接后，浏览器通过Get/POST向服务器发送请求，服...
java实战---手写简易Tomcat
王雪亮
09-17 182
文章改自：https://my.oschina.net/liughDevelop/blog/1790893 package com.ruoyi.common.enums; import java.io.*; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; class Response { public static final int BUFFER_SIZE = 2048;
java手写tomcat
08-05
Java手写Tomcat的过程可以分为以下几个步骤： ... 2. 循环接受客户端的连接...如果只是为了学习和了解Tomcat的工作原理，可以尝试手写一个简化版的Tomcat，但如果是为了实际生产使用，建议使用已经成熟的Tomcat服务器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值