简单实现"Tomcat"

Tomcat的主要功能就是接收客户端的Http请求，然后将请求分发，并且将请求封装，最后返回资源给到客户端。话不多说，开干。

 

一、实现设计图

 

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　            （禁止盗图，除非先转支付宝！！！）

 

二、代码

1、工程结构目录图

新建java project 即可，目录图如下：

 

2、工程描述

 a、dispatcher是用来处理请求信息的，并且分发到静态处理器还是动态处理器。

 b、HttpEntity则是实体类，包括request以及response。

c、process包括StaticServletProcess以及DynamicServletProcessor，去构造实际处理的servlet对象以及构建静态资源路径等等。

d、server则是模拟的整个http容器。

e、servlet下则存放实际处理的servlet

 

三、代码

1、server（http容器类）

package com.ty.server;

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

import com.ty.dispatcher.ProcessDispatcher;

/**
 * @author Taoyong
 * @date 2018年5月23日
 * 天下没有难敲的代码！
 */

/*
 * 此类主要是为了模拟一个http服务器，并且简单起便，使用main方法来启动整个http容器
 */
public class Server {

    private static boolean shutDown = false;
    
    /*
     * 为了简单实现，这里直接使用main方法启动
     * 
     */
    public static void main(String[] args) throws IOException {
        Server server = new Server();
        server.startServer();
    }

    public void startServer() throws IOException {
        ServerSocket serverSocket = null;
        try {
            /*
             * 创建一个serverSocket，并且绑定本地端口
             */
            serverSocket = new ServerSocket(8088);        
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
        
        while(!shutDown) {
            Socket socket = null;
            InputStream input = null;
            OutputStream output = null;
            try {
                /*
                 * socket是对TCP/IP的封装，提供给程序员对TCP/IP传输层进行操作
                 * 服务端监听客户端是否有请求过来
                 */                
                socket = serverSocket.accept();                
                
                //从socket中获取客户端传输内容
                input = socket.getInputStream();
                
                //从socket中获取传输给客户端的输出流对象
                output = socket.getOutputStream();
                
                ProcessDispatcher processDispatcher = new ProcessDispatcher(input, output);
                processDispatcher.service();
                
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(socket != null) {
                    socket.close();
                }
                
                if(input != null) {
                    input.close();
                }
                
                if(output != null) {
                    output.close();
                }
            }
        }
    }
}

 

 2、ProcessDispatcher（分发静态请求or动态请求）

package com.ty.dispatcher;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import com.ty.httpEntity.Request;
import com.ty.httpEntity.Response;
import com.ty.process.Processor;
import com.ty.process.impl.DynamicServletProcessor;
import com.ty.process.impl.StaticServletProcessor;

/**
 * @author Taoyong
 * @date 2018年5月23日
 * 天下没有难敲的代码！
 */

/*
 * 此类作为一个请求处理分发器，根据客户端请求url的类型(包括静态资源以及动态资源请求)，去初始化不同的processor
 * 并且在此时初始化request以及response对象，request、response、processor构成整个处理逻辑与数据传输
 */
public class ProcessDispatcher {

    private Request request;
    
    private Response response;
    
    private Processor processor;
    
    public ProcessDispatcher(InputStream input, OutputStream output) {
        init(input, output);
    }

    /**
     * 根据input以及output对象对Request、Response以及processor进行初始化
     */
    private void init(InputStream input, OutputStream output) {
        Request request = new Request(input);
        request.resolve();        
        this.request = request;

        Response response = new Response(output);
        this.response = response;
        
        initProcessor(request);
    }
    
    private void initProcessor(Request request) {
        if(request.getUrl() != null && -1 != request.getUrl().indexOf("dynamic")) {
            DynamicServletProcessor dynamicProcessor = new DynamicServletProcessor();
            this.processor = dynamicProcessor;
            return ;
        }
        
        if(request.getUrl() != null && -1 != request.getUrl().indexOf("static")) {
            StaticServletProcessor staticProcessor = new StaticServletProcessor();
            this.processor = staticProcessor;
            return ;
        }
        
        return ;
    }

    /**
     * processor的主要作用就是分发请求到底是由动态servlet处理，还是直接找静态资源
     * @throws IOException 
     */
    public void service() throws IOException {
        if(processor == null) {
            return ;
        }
        
        //根据url获取处理的servletName
        request.setServletName(resolveServletName(request.getUrl()));
        processor.process(request, response);
    }

    private String resolveServletName(String url) {
        String[] arr = url.split("/");
        for(String s: arr) {
            if(s.equals("") || s.equals("dynamic") || s.equals("static")) {
                continue;
            }
            
            return s;
        }
        return "";
    }
}

 

3、Request

package com.ty.httpEntity;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * @author Taoyong
 * @date 2018年5月23日
 * 天下没有难敲的代码！
 */

/*
 * 此类主要是对请求的封装
 */
public class Request {

    private InputStream input;
    
    private String url;    

    private String servletName;
    
    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 Request(InputStream input) {
        this.input = input;
    }
    
    /*
     * 此方法主要包括两个作用
     *         1、获取客户端请求的相关数据
     *         2、解析出请求url，并且根据具体url去找到对应的processor
     */
    public void resolve() {
        String requestStr = resolveInput(input);
        if(requestStr == null || requestStr.length() == 0) {
            return;
        }
        resolveURL(requestStr);
    }
    
    /*
     * 从客户端获取请求相关数据，数据样式如下：
     * GET /static/tomcatProTest HTTP/1.1
     * Host: localhost:8088
     * Connection: keep-alive
     * Upgrade-Insecure-Requests: 1
     * User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36
     * Accept: text/html,application/xhtml+xml,application/xml;
     * Accept-Encoding: gzip, deflate, sdch, br
     * Accept-Language: zh-CN,zh;
     */
    private String resolveInput(InputStream input) {        
        StringBuilder stringBuilder = new StringBuilder();
        String data = null;
        try {
            /*
             * 关于BufferedReader有个注意项，当读取到的数据为""，会存在阻塞现象，因此这里判断长度是否为0
             */
            BufferedReader reader = new BufferedReader(new InputStreamReader(input, "utf-8"));    
            while((data = reader.readLine()) != null && data.length() != 0) {
                stringBuilder.append(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return stringBuilder.toString();
    }
    
    /*
     * HTTP请求头第一行一般为GET /dynamic/helloServlet HTTP/1.1
     * 由于实现的只是简单的Tomcat功能，不实现解析页面传参，另外对于请求url定义如下：
     *         1、动态请求 /dynamic/对应的servlet名称
     *        2、静态资源请求 /static/静态资源名称
     * resolveURL方法是用于切割出/dynamic/helloServlet
     */
    private void resolveURL(String requestStr) {
        int firstSpaceIndex = requestStr.indexOf(" ");
        int secondSpaceIndex = requestStr.indexOf(" ", firstSpaceIndex + 1);
        String url = requestStr.substring(firstSpaceIndex + 1, secondSpaceIndex);
        setUrl(url);
    }
}

 

4、Response

package com.ty.httpEntity;

import java.io.OutputStream;

/**
 * @author Taoyong
 * @date 2018年5月23日
 * 天下没有难敲的代码！
 */
public class Response {

    private OutputStream output;
    
    public OutputStream getOutput() {
        return output;
    }

    public void setOutput(OutputStream output) {
        this.output = output;
    }

    public Response(OutputStream output) {
        this.output = output;
    }

}

 

5、DynamicServletProcessor（动态请求处理器）

package com.ty.process.impl;

import com.ty.httpEntity.Request;
import com.ty.httpEntity.Response;
import com.ty.process.Processor;
import com.ty.servlet.Servlet;
import com.ty.servlet.impl.ErrorServlet;

/**
 * @author Taoyong
 * @date 2018年5月23日
 * 天下没有难敲的代码！
 */
public class DynamicServletProcessor implements Processor {

    /*
     * 所有相关处理的servlet都放在这个包下
     */
    private static final String PACKAGE_NAME = "com.ty.servlet.impl.";
    
    @Override
    public void process(Request request, Response response) {
        String servletName = request.getServletName();
        Class<?> clazz = null;
        Servlet servlet = null;
        try {
            clazz = Class.forName(PACKAGE_NAME + servletName);
            servlet = (Servlet) clazz.newInstance();
        } catch (Exception e) {            
            servlet = new ErrorServlet();
        } 
        servlet.process(request, response);
    }
}

 

 6、StaticServletProcessor（静态请求处理器）

package com.ty.process.impl;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

import com.ty.httpEntity.Request;
import com.ty.httpEntity.Response;
import com.ty.process.Processor;

/**
 * @author Taoyong
 * @date 2018年5月23日 天下没有难敲的代码！
 */
public class StaticServletProcessor implements Processor {

    @Override
    public void process(Request request, Response response) {
        //为了省事，默认都是取txt文件
        File file = new File(Processor.prefix, request.getServletName() + ".txt");
        FileInputStream fis = null;
        BufferedReader reader = null;
        String data = null;
        StringBuilder stringBuilder = new StringBuilder();
        OutputStream output = response.getOutput();
        try {
            if (file.exists()) {
                fis = new FileInputStream(file);
                reader = new BufferedReader(new InputStreamReader(fis, "utf-8"));
                /*
                 * 由于返回数据要符合http响应头的格式，所以会存在一个空行，因此这里不能判断data.length != 0的条件
                 */
                while((data = reader.readLine()) != null) {
                    stringBuilder.append(data + "
");
                }

                output.write(stringBuilder.toString().getBytes("utf-8"));
                output.flush();
            } else {
                String errorMessage = "HTTP/1.1 404 File Not Found
" + "Content-Type: text/html
"
                        + "Content-Length: 23
" + "
" + "<h1>File Not Found</h1>";

                output.write(errorMessage.getBytes());
                output.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

 

7、TestServlet（具体的servlet处理类，用于返回客户端数据）

package com.ty.servlet.impl;

import java.io.OutputStream;

import com.ty.httpEntity.Request;
import com.ty.httpEntity.Response;
import com.ty.servlet.Servlet;

/**
 * @author Taoyong
 * @date 2018年5月24日
 * 天下没有难敲的代码！
 */
public class TestServlet implements Servlet {

    @Override
    public void process(Request request, Response response) {
        OutputStream output = response.getOutput();
        String succMessage = "HTTP/1.1 200 
" + "Content-Type: text/html
"
                + "Content-Length: 63
" + "
" + "请求动态资源:我不管,我最帅,我是你们的小可爱";
        try {
            output.write(succMessage.getBytes("utf-8"));
            output.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

 

 8、ErrorServlet（对于错误的请求url，要求是动态请求，统一的处理servlet）

 

package com.ty.servlet.impl;

import java.io.OutputStream;

import com.ty.httpEntity.Request;
import com.ty.httpEntity.Response;
import com.ty.servlet.Servlet;

/**
 * @author Taoyong
 * @date 2018年5月24日
 * 天下没有难敲的代码！
 */
public class ErrorServlet implements Servlet {

    @Override
    public void process(Request request, Response response) {
        OutputStream output = response.getOutput();
        String succMessage = "HTTP/1.1 404 File Not Found
" + "Content-Type: text/html
"
                + "Content-Length: 21
" + "
" + "请求url出现错误";
        try {
            output.write(succMessage.getBytes("utf-8"));
            output.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

}

 

 四、测试结果

 1、请求动态or静态

由于实现的只是简单的Tomcat功能，不实现解析页面传参，另外对于请求url定义如下：
a、动态请求url样例： /dynamic/对应的servlet名称
b、静态请求url样例： /static/静态资源名称

 

2、运行server的main方法

首先启动server容器，启动ok后，监听客户端的请求。

 

3、正确静态url请求本机txt文件

文件路径为：E:workspaceTomcatProwebroot omcatProTest.txt

项目路径：E:workspaceTomcatPro

文件内容：

注意点：文件格式需符合http响应头格式，content-length要与具体内容长度对应，还要注意空行一定要有，否则会报错！！！

测试结果：

 

4、错误的静态请求url

 

5、正确动态请求url

 

 

6、错误动态请求url

 所有测试结果都ok，洗澡睡觉！！！

所有源码已经上传至github上：https://github.com/ali-mayun/tomcat