手写基于NIO的迷你版tomcat

四月底瞄了几眼NIO，写了个聊天室小demo。今天中午回想了一下果然是忘了七七八八了，所以决定再写个小demo来勾起自己这条咸鱼的记忆。。。

BIO

同步阻塞IO, Block IO,IO操作会阻塞线程，并发处理能力低。
我们熟知的Socket编程就是BIO,一个Socket连接一个处理现线程（这个线程负责这个Socket连接的一系列数据传输操作）。阻塞的原因在于，操作系统允许的线程数量是优先的，多个Socket申请与服务端建立连接时，服务端不能提供相应数量的处理线程，没有分配到处理线程的链接就会阻塞等待或被拒绝。

NIO

同步非阻塞IO，None- BLock IO
NO是对BIO的改进，基于 Reactor模型,一个socekt速只有在连接时候才会发生数据传IO操作，大分时闻这个“数据通道”是空闲的，但
还是占用着线程。NIO作出的改进就是“一个请求一个线程”在连接到服务端的众多socket中，只有需要要进行IO操作时才能获取服务端的处理线程进行IO。
这样就不会因为线程不够用而限制了socket的接入。

Tomcat

**做java web开发的都知道tomcat，就是图片上的这只小猫，tomcat的老版本基于BIO，不过现在陆续更新为NIO，不知道tomcat的同学请自行百度。。这里不再讲述。。- . - **

以下直接进入主题

1. 提供socket服务

tomcat启动是socket提供服务，支持http协议

2. 进行请求分发

tomcat将不同的url请求分发到不同的web应用

3.把请求和响应封装为Request/Response

平时我们在web应用都没有手动封装过request/response，那是因为tomcat都帮我们做好了，所以我们今天就自己来实现以下。

开发工具 idea

项目结构：使用maven构建项目，也可以使用普通project，只不过我这里是引用了lombok插件和slf4j记录日志便(bi)捷(ge)观(geng)看(gao)。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.it.yip</groupId>
    <artifactId>mytomcat-nio</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
        <!--日志相关-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.6</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.6</version>
        </dependency>
    </dependencies>
</project>

日志配置文件

# rootLogger参数分别为：根Logger级别，输出器stdout，输出器log
log4j.rootLogger = info,stdout,log
# 输出信息到控制台
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d [%-5p] %l %rms: %m%n

# 输出DEBUG级别以上的日志到D://logs/debug.log
log4j.appender.log = org.apache.log4j.DailyRollingFileAppender
log4j.appender.log.DatePattern = '.'yyyy-MM-dd
log4j.appender.log.File = D://debug.log
log4j.appender.log.Encoding = UTF-8
#log4j.appender.log.Threshold = INFO
log4j.appender.log.layout = org.apache.log4j.PatternLayout
log4j.appender.log.layout.ConversionPattern = %d [%-5p] (%c.%t): %m%n

项目结构如下

Request与Response

既然基于Http协议，那么Http的头部信息由请求行、请求头部、空行、请求数据组成，只需要拆分这些数据即可处理http请求。以下封装request请求的代码

package cn.it.yip;

import lombok.AllArgsConstructor;
import lombok.Cleanup;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.HashMap;

/**
 *
 *  请求体解析数据
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:14
 **/
@Data
@Slf4j
@NoArgsConstructor
@AllArgsConstructor
public class MyRequest {
    private String url;
    private String method;
    private HashMap<String,String> param = new HashMap<>();

    public MyRequest(SelectionKey selectionKey) throws IOException {
        //  从契约获取通道
        SocketChannel channel = (SocketChannel) selectionKey.channel();

        String httpRequest = "";
       @Cleanup("flip") ByteBuffer bb = ByteBuffer.allocate(16*1024);   //  从堆内存中获取内存
        int length = 0; //  读取byte数组的长度
        length = channel.read(bb);  //  从通道中读取数据到ByteBuffer容器中
        if (length < 0){
            selectionKey.cancel();  //  取消该契约
        }else {
            httpRequest = new String(bb.array()).trim();    //  将ByteBuffer转为String
            String httpHead = httpRequest.split("\n")[0];   //  获取请求头
            url = httpHead.split("\\s")[1].split("\\?")[0]; //  获取请求路径
            String path = httpHead.split("\\s")[1]; //  请求全路径，包含get的参数数据
            method = httpHead.split("\\s")[0];

            // 拆分get请求的参数数据
            String[] params = path.indexOf("?") > 0 ? path.split("\\?")[1].split("\\&") : null;
            if (params != null){
                try{
                    for (String tmp : params){
                        param.put(tmp.split("\\=")[0],tmp.split("\\=")[1]);
                    }
                }catch (NullPointerException e){
                    e.printStackTrace();
                }
            }
            log.info("当前请求详情 -> {}",this);
        }
    }
}

Response响应体封装

package cn.it.yip;

import lombok.Cleanup;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 *
 * 响应体处理数据
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:17
 **/
@Data
@NoArgsConstructor
public class MyResponse {
    private SelectionKey selectionKey;

    public MyResponse(SelectionKey selectionKey) {
        this.selectionKey = selectionKey;
    }

    public void write(String content) throws IOException {
        //  拼接相应数据包
        StringBuffer httpResponse = new StringBuffer();
        httpResponse.append("HTTP/1.1 200 OK\n")
                .append("Content-type:text/html\n")
                .append("\r\n")
                .append("<html><body>")
                .append(content)
                .append("</body></html>");
        // 转换为ByteBuffer 这里使用了lombok注解，更优雅的关流
        @Cleanup("flip") ByteBuffer bb = ByteBuffer.wrap(httpResponse.toString().getBytes(StandardCharsets.UTF_8));
        @Cleanup SocketChannel channel = (SocketChannel) selectionKey.channel(); //  从契约获取通道
        long len = channel.write(bb);   //  向通道中写入数据
        if (len == -1) {
            selectionKey.cancel();
        }
        selectionKey.cancel();
    }
}

Sevlet、Mapping、和配置类

在我们使用servlet时，都会进行serlet与mapping映射路径的配置，都是一些必须要配置的东西。

MyServlet

有常用的dopost、doget抽象处理请求

package cn.it.yip;

/**
 * 该抽象类处理请求和响应
 *
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:19
 **/
public abstract class MyServlet {
    public abstract void doGet(MyRequest myRequest, MyResponse myResponse);

    public abstract void doPost(MyRequest myRequest, MyResponse myResponse);

    public void service(MyRequest myRequest, MyResponse myResponse) {
        if (myRequest.getMethod().equalsIgnoreCase("POST")) {
            doPost(myRequest, myResponse);
        } else if (myRequest.getMethod().equalsIgnoreCase("GET")) {
            doGet(myRequest, myResponse);
        }
    }
}

ServletMapping

package cn.it.yip;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Mapping映射负责处理将某些请求路径分发到各自的类进行处理
 *
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:21
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ServletMapping {
    private String servletName;     //servlet类名
    private String url; //请求路径
    private String clazz;   //对应的servlet类名全路径
}

ServletMappingConfig

以下配置一般都是使用xml配置，但是我这里为了方便测试就不搞这些的，有兴趣的可以自己搞了xml进行解析。

package cn.it.yip;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * Servlet配置类
 *
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:23
 **/
public class ServletMappingConfig {
    public static List<ServletMapping> servletMappingList = new ArrayList<>();
    static {
        servletMappingList.add(new ServletMapping("helloWorld","/world","cn.it.yip.test.HelloWorldServlet"));
    }
}

MyTomcat

以下是基于NIO实现的简单tomcat服务器，使用nio的逻辑代码基本都写到注释上了，哦，还有使用了线程池处理数据，这里就概述了。。请各位看注释

package cn.it.yip;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.*;
import java.nio.channels.spi.SelectorProvider;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * tomcat启动类
 *
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:27
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Slf4j
public class MyTomcat {

    public MyTomcat(int port) {
        this.port = port;
    }

    private int port;
    private Map<String, String> urlServletMap = new HashMap<>();

    private Selector selector;
    //采用线程池处理数据
    private ExecutorService executorService = Executors.newCachedThreadPool();

    /**
     * 启动
     */
    public void start() throws IOException {
        //1.首先初始化映射关系
        initMapping();
        //2.启动selector，和Channel通道
        selector = SelectorProvider.provider().openSelector();
        ServerSocketChannel channel = ServerSocketChannel.open();
        //3.配置通道非阻塞
        channel.configureBlocking(false);
        //4.监听端口
        InetSocketAddress address = new InetSocketAddress(port);
        channel.socket().bind(address);
        //5.将通道注册给监听器
        SelectionKey register = channel.register(selector, SelectionKey.OP_ACCEPT);

        log.info("MyTomcat started....");
        //6.干活
        ConcurrentLinkedQueue<MyRequest> requestList = new ConcurrentLinkedQueue<>();
        ConcurrentLinkedQueue<MyResponse> responseList = new ConcurrentLinkedQueue<>();
        while (true) {
            //等待数据,没有人发送请求连接可以做其他事情,这里也是nio比普通bio的优势所在，简单来说不用一直等待连接，可以做其他的工作。
            if(selector.select(5000) == 0){
                log.info("[Server]: 目前没有人连接，我做其他事情咯！！");
                continue;
            }
            //获取监听器的所有事件并进行业务处理
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            //迭代处理
            while (iterator.hasNext()) {
                SelectionKey next = iterator.next();

                //连接事件
                if (next.isAcceptable()) {
                    //开启读取监听
                    doRead(next);
                } else if (next.isValid() && next.isReadable()) { //可读事件
                    requestList.add(getRequest(next));
                    //切换可写的状态
                  next.interestOps(SelectionKey.OP_WRITE);
                } else if (next.isValid() && next.isWritable()) { //可写事件
                    responseList.add(getResponse(next));
                    //切换可读的状态
                   next.interestOps(SelectionKey.OP_READ);
                }
                //等待请求和响应都准备好的时候进行处理
                if (!requestList.isEmpty() && !responseList.isEmpty()) {
                    dispatch(requestList.poll(), responseList.poll());
                }
                //删除事件，免得后面会重复处理该事件
                iterator.remove();
            }
        }

    }

    /**
     * 调用请求
     *
     * @param request
     * @param response
     */
    private void dispatch(MyRequest request, MyResponse response) {
        if (request == null) {
            log.info("request is null...");
            return;
        }
        if (response == null) {
            log.info("response is null...");
            return;
        }
        //根据连接获取全路径类名
        String clazzName = urlServletMap.get(request.getUrl());
        try {
            if ( clazzName == null || clazzName.equals("")) {
                response.write("404 NOT FOUND...");
                log.error("404 NOT FOUND...");
                return;
            }
            //执行处理请求
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Class<MyServlet> myServletClazz = (Class<MyServlet>) Class.forName(clazzName);
                        //反射创建实例，执行方法
                        MyServlet myServletInstance = myServletClazz.newInstance();
                        myServletInstance.service(request, response);
                    } catch (ClassNotFoundException e) {
                        log.error("find No this ServletClass.... {}", e.getMessage());
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        log.error("find No this ServletClass.... {}", e.getMessage());
                        e.printStackTrace();
                    } catch (InstantiationException e) {
                        log.error("find No this ServletClass.... {}", e.getMessage());
                        e.printStackTrace();
                    }
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 开启读取监听
     *
     * @param next
     */
    private void doRead(SelectionKey next) {
        ServerSocketChannel channel = (ServerSocketChannel) next.channel();
        SocketChannel socketChannel = null;
        try {
            socketChannel = channel.accept();
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_READ);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始化映射
     */
    private void initMapping() {
        ServletMappingConfig.servletMappingList.forEach(s -> {
            urlServletMap.put(s.getUrl(), s.getClazz());
        });
    }

    /**
     * 从通道中获取请求并进行包装我们自己的MyRequest
     *
     * @param selectionKey
     * @return
     * @throws IOException
     */
    private MyRequest getRequest(SelectionKey selectionKey) throws IOException {
        return new MyRequest(selectionKey);
    }

    /**
     * 从通道中获取响应并进行包装MyResponse
     *
     * @param selectionKey
     * @return
     */
    private MyResponse getResponse(SelectionKey selectionKey) {
        return new MyResponse(selectionKey);
    }

    public static void main(String[] args) throws IOException {
        new MyTomcat(8080).start();
    }
}

HelloWroldServlet

该类就是我们平时使用的servlet类，没什么特别的。

package cn.it.yip.test;

import cn.it.yip.MyRequest;
import cn.it.yip.MyResponse;
import cn.it.yip.MyServlet;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

/**
 * 该类就是平时我们使用的servlet类
 *
 * @program: NIO__Socket_Chat
 * @author: YipSouL
 * @create: 2019-05-13 12:25
 **/
@Slf4j
public class HelloWorldServlet extends MyServlet {
    @Override
    public void doGet(MyRequest myRequest, MyResponse myResponse) {
        try {
            myResponse.write("GET hello MyTomcat....");
        } catch (IOException e) {
            log.error("请求有误!! -> {}",e.getMessage());
            e.printStackTrace();
        }
    }

    @Override
    public void doPost(MyRequest myRequest, MyResponse myResponse) {
        try {
            myResponse.write("POST hello MyTomcat....");
        } catch (IOException e) {
            log.error("请求有误!! -> {}",e.getMessage());
            e.printStackTrace();
        }
    }
}

最后简单的概述一下tomcat的执行流程：

1. 将浏览器发送的请求url解析成对应处理的Servlet映射关系。
2.解析http协议，封装request/response对象。
3.利用反射实例化执行具体的servlet然后进行处理。

打完收工。