BinCat V3-实现Servlet3.x API

V1和V2我们完成了一个简单的文件访问服务和请求参数解析服务，V3我们继续添加Servlet API，从而理解Servlet的工作原理。

添加Servlet3.x依赖：

  1. <dependency>
  2.     <groupId>javax.servlet</groupId>
  3.     <artifactId>javax.servlet-api</artifactId>
  4.     <version>3.0.1</version>
  5. </dependency>

创建com.anbai.sec.server.servlet.BinCatRequest类并继承javax.servlet.http.HttpServletRequest，然后需要实现HttpServletRequest接口方法，作为一个非标准的Servlet容器我们自然是没必要严格的是实现里面的所有方法，选择几个方法实现一下就行了。

注意：示例以下中省去了解析协议Servlet接口的代码，完整代码请参考：com.anbai.sec.server.servlet包下的完整实现代码。

HttpServletRequest实现

BinCatRequest.java示例代码片段:

  1. package com.anbai.sec.server.servlet;
  3. import org.javaweb.utils.StringUtils;
  5. import javax.servlet.*;
  6. import javax.servlet.http.*;
  7. import java.io.*;
  8. import java.net.Socket;
  9. import java.net.URLDecoder;
  10. import java.security.Principal;
  11. import java.util.*;
  12. import java.util.concurrent.ConcurrentHashMap;
  13. import java.util.logging.Logger;
  15. /**
  16.  * BinCat 请求解析实现对象，解析Http请求协议和参数
  17.  */
  18. public class BinCatRequest implements HttpServletRequest {
  20.     // 客户端Socket连接对象
  21.     private final Socket clientSocket;
  23.     // Socket输入流对象
  24.     private final InputStream socketInputStream;
  26.     // Http请求头对象
  27.     private Map<String, String> headerMap;
  29.     // Http请求参数对象
  30.     private Map<String, String[]> parameterMap;
  32.     // Http请求attribute对象
  33.     private final Map<String, Object> attributeMap = new ConcurrentHashMap<String, Object>();
  35.     // Http请求Cookie对象
  36.     private Cookie[] cookie;
  38.     // Http请求Cookie对象
  39.     private final Map<String, String> cookieMap = new ConcurrentHashMap<String, String>();
  41.     // Http请求Session对象
  42.     private final Map<String, BinCatSession> sessionMap = new ConcurrentHashMap<String, BinCatSession>();
  44.     // Http请求方法类型
  45.     private String requestMethod;
  47.     // Http请求URL
  48.     private String requestURL;
  50.     // Http请求QueryString
  51.     private String queryString;
  53.     // Http请求协议版本信息
  54.     private String httpVersion;
  56.     // 是否已经解析过Http请求参数，防止多次解析请求参数
  57.     private volatile boolean parsedParameter = false;
  59.     // Http请求内容长度
  60.     private int contentLength;
  62.     // Http请求内容类型
  63.     private String contentType;
  65.     // 存储Session的ID名称
  66.     private static final String SESSION_ID_NAME = "JSESSIONID";
  68.     // Http请求主机名
  69.     private String host;
  71.     // Http请求主机端口
  72.     private int port;
  74.     private static final Logger LOG = Logger.getLogger("info");
  76.     public BinCatRequest(Socket clientSocket) throws IOException {
  77.         this.clientSocket = clientSocket;
  78.         this.socketInputStream = clientSocket.getInputStream();
  80.         // 解析Http协议
  81.         parse();
  82.     }
  84.     /**
  85.      * 解析Http请求协议，不解析Body部分
  86.      *
  87.      * @throws IOException
  88.      */
  89.     private void parse() throws IOException {
  90.         // 此处省略Http请求协议解析、参数解析等内容...
  91.     }
  93.     /**
  94.      * 解析Http请求参数
  95.      *
  96.      * @throws IOException Http协议解析异常
  97.      */
  98.     private synchronized void parseParameter() {
  99.         // 此处省略Http请求协议解析、参数解析等内容...
  100.     }
  102.   // 此处省略HttpServletRequest接口中的大部分方法，仅保留几个示例方法...
  104.     public String getHeader(String name) {
  105.         return this.headerMap.get(name);
  106.     }
  108.     public ServletInputStream getInputStream() throws IOException {
  109.         return new ServletInputStream() {
  110.             @Override
  111.             public int read() throws IOException {
  112.                 return socketInputStream.read();
  113.             }
  114.         };
  115.     }
  117.     public String getParameter(String name) {
  118.         if (!parsedParameter) {
  119.             this.parseParameter();
  120.         }
  122.         if (parameterMap.containsKey(name)) {
  123.             return this.parameterMap.get(name)[0];
  124.         }
  126.         return null;
  127.     }
  129.     public String getRemoteAddr() {
  130.         return clientSocket.getInetAddress().getHostAddress();
  131.     }
  133.     public void setAttribute(String name, Object o) {
  134.         attributeMap.put(name, o);
  135.     }
  137. }

HttpServletResponse实现

BinCatResponse.java示例代码片段:

  1. package com.anbai.sec.server.servlet;
  3. import javax.servlet.ServletOutputStream;
  4. import javax.servlet.http.Cookie;
  5. import javax.servlet.http.HttpServletResponse;
  6. import java.io.ByteArrayOutputStream;
  7. import java.io.IOException;
  8. import java.io.PrintWriter;
  9. import java.net.Socket;
  10. import java.net.URLEncoder;
  11. import java.util.*;
  13. public class BinCatResponse implements HttpServletResponse {
  15.     private final Socket socket;
  17.     private final Map<String, String> header;
  19.     private final ByteArrayOutputStream out;
  21.     private int status = 404;
  23.     private String statusMessage = "Not Found";
  25.     private String charset = "UTF-8";
  27.     private int contentLength = 0;
  29.     private String contentType = "text/html; charset=UTF-8";
  31.     private String location;
  33.     public BinCatResponse(Socket socket, Map<String, String> header, ByteArrayOutputStream out) {
  34.         this.socket = socket;
  35.         this.header = header;
  36.         this.out = out;
  37.     }
  39.   // 此处省略HttpServletResponse接口中的大部分方法，仅保留几个示例方法...
  41.     public void setHeader(String name, String value) {
  42.         this.header.put(name, value);
  43.     }
  45.     public String getHeader(String name) {
  46.         return header.get(name);
  47.     }
  49.     public PrintWriter getWriter() throws IOException {
  50.         return new PrintWriter(out);
  51.     }
  53. }

HttpSession实现

BinCatSession.java示例代码片段:

  1. package com.anbai.sec.server.servlet;
  3. import javax.servlet.ServletContext;
  4. import javax.servlet.http.HttpSession;
  5. import javax.servlet.http.HttpSessionContext;
  6. import java.util.Enumeration;
  7. import java.util.Map;
  8. import java.util.concurrent.ConcurrentHashMap;
  10. /**
  11.  * BinCat Session实现
  12.  */
  13. public class BinCatSession implements HttpSession {
  15.     private final String sessionID;
  17.     // Http请求Session对象
  18.     private final Map<String, Object> sessionMap = new ConcurrentHashMap<String, Object>();
  20.     public BinCatSession(String sessionID) {
  21.         this.sessionID = sessionID;
  22.     }
  24.   // 此处省略HttpSession接口中的大部分方法，仅保留几个示例方法...
  26.     public Object getAttribute(String name) {
  27.         return this.sessionMap.get(name);
  28.     }
  30.     public void setAttribute(String name, Object value) {
  31.         this.sessionMap.put(name, value);
  32.     }
  34. }

Servlet类注册

Servlet3.0支持web.xml和注解两种方式配置，但不管是通过那种方式都需要知道Servlet的处理类和映射的URL地址，这里为了方法理解我将解析web.xml和扫描@WebServlet注解的步骤省略了，直接改成了手动配置一个Servlet映射类对象。

注册Servlet类对象代码片段：

  1. // 初始化Servlet映射类对象
  2. final Set<Class<? extends HttpServlet>> servletList = new HashSet<Class<? extends HttpServlet>>();
  4. // 手动注册Servlet类
  5. servletList.add(TestServlet.class);
  6. servletList.add(CMDServlet.class);

当接收到浏览器请求时候我们需要根据请求的URL地址来动态调用Servlet类相关的代码。

调用Servlet类处理Http请求代码片段：

  1. // 处理Http请求URL
  2. for (Class<? extends HttpServlet> clazz : servletList) {
  3.     WebServlet webServlet  = clazz.getAnnotation(WebServlet.class);
  4.     String[]   urlPatterns = webServlet.urlPatterns();
  6.     for (String urlPattern : urlPatterns) {
  7.         try {
  8.           // 检测请求的URL地址和Servlet的地址是否匹配
  9.           if (Pattern.compile(urlPattern).matcher(uri).find()) {
  10.               // 修改状态码
  11.               response.setStatus(200, "OK");
  13.               // 创建Servlet类实例
  14.               HttpServlet httpServlet = clazz.newInstance();
  16.               // 调用Servlet请求处理方法
  17.               httpServlet.service(request, response);
  18.               break;
  19.           }
  20.         } catch (IOException e) {
  21.            // 修改状态码
  22.                    response.setStatus(500, "Internal Server Error");
  23.               e.printStackTrace();
  24.         }
  25.     }
  26. }

BinCat V3实现

V3简单的封装了BinCatRequest、BinCatResponse、BinCatSession，还是先了部分的Servlet API从而实现了一个最初级的Servlet容器。

V3处理流程:

  1. 创建服务端Socket连接(ServerSocket)。
  2. 手动注册Servlet类。
  3. 创建用于处理请求的BinCatRequest对象。
  4. BinCatRequest解析请求协议、请求头、请求参数、Cookie等。
  5. 创建用于处理请求的BinCatResponse对象。
  6. 解析Servlet类的@WebServlet注解，反射调用Servlet类方法处理Http请求。
  7. 输出响应信息以及Servlet处理结果。
  8. 关闭Socket连接。

BinCatServerV3实现代码:

  1. package com.anbai.sec.server;
  3. import com.anbai.sec.server.servlet.BinCatRequest;
  4. import com.anbai.sec.server.servlet.BinCatResponse;
  5. import com.anbai.sec.server.test.servlet.CMDServlet;
  6. import com.anbai.sec.server.test.servlet.TestServlet;
  7. import org.javaweb.utils.StringUtils;
  9. import javax.servlet.annotation.WebServlet;
  10. import javax.servlet.http.HttpServlet;
  11. import java.io.ByteArrayOutputStream;
  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.io.OutputStream;
  15. import java.net.ServerSocket;
  16. import java.net.Socket;
  17. import java.util.HashSet;
  18. import java.util.Map;
  19. import java.util.Set;
  20. import java.util.concurrent.ConcurrentHashMap;
  21. import java.util.logging.Logger;
  22. import java.util.regex.Pattern;
  24. /**
  25.  * ServerSocket Http 服务器示例
  26.  */
  27. public class BinCatServerV3 {
  29.     private static final Logger LOG = Logger.getLogger("info");
  31.     public static void main(String[] args) {
  32.         try {
  33.             // 设置服务监听端口
  34.             int port = 8080;
  36.             // 设置服务名称
  37.             String serverName = "BinCat-0.0.3";
  39.             // 创建ServerSocket，监听本地端口
  40.             ServerSocket ss = new ServerSocket(port);
  42.             // 初始化Servlet映射类对象
  43.             final Set<Class<? extends HttpServlet>> servletList = new HashSet<Class<? extends HttpServlet>>();
  45.             // 手动注册Servlet类
  46.             servletList.add(TestServlet.class);
  47.             servletList.add(CMDServlet.class);
  49.             LOG.info(serverName + " 启动成功，监听端口: " + port);
  51.             while (true) {
  52.                 // 等待客户端连接
  53.                 Socket socket = ss.accept();
  55.                 try {
  56.                     // 获取Socket输入流对象
  57.                     InputStream in = socket.getInputStream();
  59.                     // 获取Socket输出流对象
  60.                     OutputStream out = socket.getOutputStream();
  62.                     // 创建BinCat请求处理对象
  63.                     BinCatRequest request = new BinCatRequest(socket);
  65.                     // 创建BinCat请求处理结果输出流
  66.                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
  68.                     // 创建BinCat请求处理结果Header对象
  69.                     Map<String, String> responseHeader = new ConcurrentHashMap<String, String>();
  71.                     // 创建BinCat响应处理对象
  72.                     BinCatResponse response = new BinCatResponse(socket, responseHeader, baos);
  74.                     // 请求URI地址
  75.                     String uri = request.getRequestURI();
  77.                     // 处理Http请求URL
  78.                     for (Class<? extends HttpServlet> clazz : servletList) {
  79.                         WebServlet webServlet  = clazz.getAnnotation(WebServlet.class);
  80.                         String[]   urlPatterns = webServlet.urlPatterns();
  82.                         for (String urlPattern : urlPatterns) {
  83.                             try {
  84.                                 // 检测请求的URL地址和Servlet的地址是否匹配
  85.                                 if (Pattern.compile(urlPattern).matcher(uri).find()) {
  86.                                     // 修改状态码
  87.                                     response.setStatus(200, "OK");
  89.                                     // 创建Servlet类实例
  90.                                     HttpServlet httpServlet = clazz.newInstance();
  92.                                     // 调用Servlet请求处理方法
  93.                                     httpServlet.service(request, response);
  94.                                     break;
  95.                                 }
  96.                             } catch (Exception e) {
  97.                                 // 修改状态码
  98.                                 response.setStatus(500, "Internal Server Error");
  99.                                 e.printStackTrace();
  101.                                 baos.write(("<pre>" + StringUtils.exceptionToString(e) + "</pre>").getBytes());
  102.                             }
  103.                         }
  104.                     }
  106.                     // 处理Http响应内容
  107.                     out.write(("HTTP/1.1 " + response.getStatus() + " " + response.getMessage() + "\n").getBytes());
  108.                     // 输出Web服务器信息
  109.                     out.write(("Server: " + serverName + "\n").getBytes());
  110.                     // 输出返回的消息类型
  111.                     out.write(("Content-Type: " + response.getContentType() + "\n").getBytes());
  112.                     // 输出返回字节数
  113.                     out.write(("Content-Length: " + baos.size() + "\n").getBytes());
  115.                     // 输出用户自定义的Header
  116.                     for (String key : responseHeader.keySet()) {
  117.                         out.write((key + ": " + responseHeader.get(key) + "\n").getBytes());
  118.                     }
  120.                     // 写入换行
  121.                     out.write("\n".getBytes());
  122.                     // 将读取到的数据写入到客户端Socket
  123.                     out.write(baos.toByteArray());
  125.                     in.close();
  126.                     out.close();
  127.                 } catch (Exception e) {
  128.                     LOG.info("处理客户端请求异常:" + e);
  129.                 } finally {
  130.                     socket.close();
  131.                 }
  132.             }
  133.         } catch (IOException e) {
  134.             e.printStackTrace();
  135.         }
  136.     }
  138. }

Servlet功能测试

为了验证BinCat是否真的具备了Servlet处理能力，我们写两个测试用例：TestServlet和CMDServlet。

TestServlet示例代码：

  1. package com.anbai.sec.server.test.servlet;
  3. import javax.servlet.annotation.WebServlet;
  4. import javax.servlet.http.HttpServlet;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. import java.io.IOException;
  8. import java.io.OutputStream;
  10. @WebServlet(name = "TestServlet", urlPatterns = "/TestServlet/")
  11. public class TestServlet extends HttpServlet {
  13.    @Override
  14.    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
  15.       doPost(request, response);
  16.    }
  18.    @Override
  19.    public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
  20.       OutputStream out = response.getOutputStream();
  21.       out.write(("Hello....<br/>Request Method:" + request.getMethod() + "<br/>Class:" + this.getClass()).getBytes());
  22.    }
  24. }

浏览器请求http://localhost:8080/TestServlet/:

image-20200910201502285

CMDServlet示例代码：

  1. package com.anbai.sec.server.test.servlet;
  3. import org.javaweb.utils.IOUtils;
  5. import javax.servlet.annotation.WebServlet;
  6. import javax.servlet.http.HttpServlet;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9. import java.io.IOException;
  10. import java.io.OutputStream;
  12. @WebServlet(name = "CMDServlet", urlPatterns = "/CMD/")
  13. public class CMDServlet extends HttpServlet {
  15.    @Override
  16.    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
  17.       doPost(request, response);
  18.    }
  20.    @Override
  21.    public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
  22.       String cmd   = request.getParameter("cmd");
  23.       byte[] bytes = IOUtils.toByteArray(Runtime.getRuntime().exec(cmd).getInputStream());
  25.       OutputStream out = response.getOutputStream();
  26.       out.write(bytes);
  27.       out.flush();
  28.       out.close();
  29.    }
  31. }

浏览器请求http://localhost:8080/CMD/?cmd=whoami:

image-20200910201725672

使用curl发送POST请求:curl -i localhost:8080/CMD/ -d "cmd=pwd"，服务器可以正常接收POST参数，处理结果如图：

image-20200910203406943

请求一个错误服务：

image-20200910203858328

至此，我们已经实现了一个非常初级的Servlet容器了。