BinCat V2-简单解析请求参数

V2版本我们需要支持请求参数解析以及简单的HTML页面渲染功能。

BinCatServerV2实现代码：

  1. package com.anbai.sec.server;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6. import java.net.URLDecoder;
  7. import java.util.Map;
  8. import java.util.concurrent.ConcurrentHashMap;
  9. import java.util.logging.Logger;
  11. /**
  12.  * ServerSocket Http 服务器示例
  13.  */
  14. public class BinCatServerV2 {
  16.     private static final Logger LOG = Logger.getLogger("info");
  18.     public static void main(String[] args) {
  19.         try {
  20.             // 设置服务监听端口
  21.             int port = 8080;
  23.             // 设置服务名称
  24.             String serverName = "BinCat-0.0.2";
  26.             // 创建ServerSocket，监听本地端口
  27.             ServerSocket ss = new ServerSocket(port);
  29.             LOG.info(serverName + " 启动成功，监听端口: " + port);
  31.             while (true) {
  32.                 // 等待客户端连接
  33.                 Socket socket = ss.accept();
  35.                 try {
  36.                     // 获取Socket输入流对象
  37.                     InputStream in = socket.getInputStream();
  39.                     // 获取Socket输出流对象
  40.                     OutputStream out = socket.getOutputStream();
  42.                     // 创建数据输出流对象
  43.                     DataInputStream dis = new DataInputStream(in);
  45.                     // 从Socket中读取一行数据，读取请求的URL
  46.                     String str = dis.readLine();
  48.                     if (str == null) {
  49.                         socket.close();
  50.                         continue;
  51.                     }
  53.                     // 切割请求Http协议信息
  54.                     String[] strs = str.split("\\s+");
  56.                     // 解析Http请求方法类型
  57.                     String method = strs[0];
  59.                     // 解析Http请求URL地址
  60.                     String url = strs[1];
  62.                     // 初始化Http请求URL地址
  63.                     String requestURL = url;
  65.                     // 初始化Http请求的QueryString
  66.                     String queryString;
  68.                     // 解析Http请求版本信息
  69.                     String httpVersion = strs[2];
  71.                     // 创建Header对象
  72.                     Map<String, String> header = new ConcurrentHashMap<String, String>();
  74.                     // 初始化请求参数数组
  75.                     Map<String, String> parameterMap = new ConcurrentHashMap<String, String>();
  77.                     // 解析GET请求参数
  78.                     if (url.contains("?")) {
  79.                         String[] parameterStrs = url.split("\\?");
  80.                         requestURL = parameterStrs[0];
  81.                         queryString = parameterStrs[1];
  83.                         // 按"&"切割GET请求的参数
  84.                         String[] parameters = queryString.split("&");
  86.                         // 解析GET请求参数
  87.                         for (String parameter : parameters) {
  88.                             String[] tmp = parameter.split("=", -1);
  90.                             if (tmp.length == 2) {
  91.                                 parameterMap.put(tmp[0], URLDecoder.decode(tmp[1]));
  92.                             }
  93.                         }
  94.                     }
  96.                     // 解析请求头信息
  97.                     while (true) {
  98.                         // 按行读取Header头信息
  99.                         String line = dis.readLine();
  101.                         // 当读取到空行时停止解析Header
  102.                         if ("".equals(line)) {
  103.                             break;
  104.                         }
  106.                         // 切割Header的Key/Value
  107.                         String[] headers = line.split(":\\s*", -1);
  109.                         header.put(headers[0], headers[1]);
  110.                     }
  112.                     // 输出服务器返回信息
  113.                     StringBuffer msg = new StringBuffer();
  115.                     // 处理Http请求,当浏览器请求主页时返回服务器信息
  116.                     if ("/".equals(requestURL)) {
  117.                         out.write("HTTP/1.1 200 OK\n".getBytes());
  119.                         // 根据Http请求类型处理不同的请求
  120.                         if ("GET".equalsIgnoreCase(method)) {
  121.                             // 输出服务器处理结果
  122.                             msg.append("<html>\n" +
  123.                                     "<head>\n" +
  124.                                     "    <title>Login Test</title>\n" +
  125.                                     "</head>\n" +
  126.                                     "<body>\n" +
  127.                                     "<div style=\"margin: 30px;\">\n" +
  128.                                     "    <form action=\"/\" method=\"POST\">\n" +
  129.                                     "        Username:<input type=\"text\" name=\"username\" value=\"admin\"/><br/>\n" +
  130.                                     "        Password:<input type=\"text\" name=\"password\" value=\"'=0#\"/><br/>\n" +
  131.                                     "        <input type=\"submit\" value=\"Login\"/>\n" +
  132.                                     "    </form>\n" +
  133.                                     "</div>\n" +
  134.                                     "</body>\n" +
  135.                                     "</html>");
  136.                         } else if ("POST".equalsIgnoreCase(method)) {
  137.                             String contentType = header.get("Content-Type");
  139.                             // 解析POST请求参数
  140.                             if ("application/x-www-form-urlencoded".equalsIgnoreCase(contentType)) {
  141.                                 // 获取请求的主体长度
  142.                                 int contentLength = Integer.parseInt(header.get("Content-Length"));
  144.                                 // 创建一个和请求体一样大小的缓冲区
  145.                                 byte[] bytes = new byte[contentLength];
  147.                                 // 读取POST主体内容
  148.                                 dis.read(bytes);
  150.                                 // 解析POST请求内容
  151.                                 String body = new String(bytes, "ISO8859-1");
  153.                                 // 按"&"切割POST请求的参数
  154.                                 String[] parameters = body.split("&");
  156.                                 // 解析POST请求参数
  157.                                 for (String parameter : parameters) {
  158.                                     String[] tmp = parameter.split("=", -1);
  160.                                     if (tmp.length == 2) {
  161.                                         parameterMap.put(tmp[0], URLDecoder.decode(tmp[1]));
  162.                                     }
  163.                                 }
  165.                                 // 定义SQL语句
  166.                                 String sql = "select id,username,password from sys_user where username = '" +
  167.                                         parameterMap.get("username") + "' and password = '" +
  168.                                         parameterMap.get("password") + "'";
  170.                                 msg.append("<font color='red'>JDBC 查询SQL:" + sql + "</font>\n");
  171.                                 msg.append("<h3>请求头:</h3>\n");
  172.                                 msg.append("<pre>\n");
  174.                                 for (String key : header.keySet()) {
  175.                                     msg.append(key + ": " + header.get(key) + "\n");
  176.                                 }
  178.                                 msg.append("<pre>\n");
  179.                                 msg.append("<h3>请求参数:</h3>\n");
  181.                                 // 循环遍历请求参数
  182.                                 for (String key : parameterMap.keySet()) {
  183.                                     msg.append(key + ": " + parameterMap.get(key) + "\n");
  184.                                 }
  185.                             }
  186.                         }
  187.                     } else {
  188.                         out.write("HTTP/1.1 404 Not Found\n".getBytes());
  190.                         // 输出错误信息
  191.                         msg.append("404");
  192.                     }
  194.                     // 输出Web服务器信息
  195.                     out.write(("Server: " + serverName + "\n").getBytes());
  197.                     // 输出返回的消息类型
  198.                     out.write(("Content-Type: text/html; charset=UTF-8\n").getBytes());
  200.                     // 请求响应内容
  201.                     byte[] responseByte = msg.toString().getBytes();
  203.                     // 输出返回字节数
  204.                     out.write(("Content-Length: " + responseByte.length + "\n").getBytes());
  206.                     // 写入换行
  207.                     out.write("\n".getBytes());
  209.                     // 将读取到的数据写入到客户端Socket
  210.                     out.write(responseByte);
  212.                     in.close();
  213.                     out.close();
  214.                 } catch (IOException e) {
  215.                     LOG.info("处理客户端请求异常:" + e);
  216.                 } finally {
  217.                     socket.close();
  218.                 }
  219.             }
  220.         } catch (IOException e) {
  221.             e.printStackTrace();
  222.         }
  223.     }
  225. }

请求参数解析测试

访问Web服务测试http://localhost:8080:

image-20200909214652771

提交登陆表单测试：

image-20200909214804184