简单实现 http Server (版本1、2)

转x33g5p2x  于2022-02-07 转载在 其他  
字(8.7k)|赞(0)|评价(0)|浏览(213)

版本1

代码实现：

  1. public class HttpServerV1 {
  2.     /*
  3.     *  http 底层要基于 tcp 来实现
  4.     *  需要按照 tcp 的基本格式来进行开发
  5.     * */
  6.     private ServerSocket serverSocket = null;
  8.     public HttpServerV1(int port) throws IOException {
  9.         serverSocket = new ServerSocket(port);
  10.     }
  12.     public void start() throws IOException {
  13.         System.out.println("服务器启动...");
  14.         ExecutorService executorService = Executors.newCachedThreadPool();
  15.         while (true){
  16.             // 1.获取连接
  17.             Socket clientSocket = serverSocket.accept();
  18.             // 2.处理连接 (使用短连接方式)
  19.             executorService.execute(new Runnable() {
  20.                 @Override
  21.                 public void run() {
  22.                     process(clientSocket);
  23.                 }
  24.             });
  25.         }
  26.     }
  28.     private void process(Socket clientSocket) {
  29.         // 由于 http 是一个文本协议，仍然使用字符流来处理
  30.         try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
  31.              BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()))){
  32.             // 下面的操作要按照 http 协议的格式来进行操作
  34.             // 1.读取请求并解析
  35.             //  a)解析首行  三个部分按照空格切分
  36.             String fistLine = bufferedReader.readLine();
  37.             String[] fistLineTokens = fistLine.split(" ");
  38.             String method = fistLineTokens[0];
  39.             String url = fistLineTokens[1];
  40.             String version = fistLineTokens[2];
  41.             //  b)解析 header  按行读取 按照冒号空格分割键值对
  42.             Map<String,String> headers = new HashMap<>();
  43.             String line = " ";
  44.             while ((line = bufferedReader.readLine()) != null && line.length() != 0){
  45.                 String[] headerTokens = line.split(": ");
  46.                 headers.put(headerTokens[0],headerTokens[1]);
  47.             }
  48.             //  c)解析 body (暂时不考虑)
  49.             // 打印日志
  50.             System.out.printf("%s %s %s\n",method,url,version);
  51.             for (Map.Entry<String,String> entry : headers.entrySet()) {
  52.                 System.out.println(entry.getKey() + ": " + entry.getValue() + "\n");
  53.             }
  54.             System.out.println();
  56.             // 2.根据请求计算响应
  57.             // 不管是什么请求，都返回一个 hello 这样的 html
  58.             String resp = "<h1>hello</h1>";
  59.             // 3.把响应写回客户端
  60.             bufferedWriter.write(version + "200 OK\n");
  61.             bufferedWriter.write("Content-Type: text/html\n");
  62.             bufferedWriter.write("Content-Length: " + resp.getBytes().length + "\n"); //此处的长度是以为字节为单位的
  63.             bufferedWriter.write("\n");
  64.             bufferedWriter.write(resp); // body
  65.             //刷新缓冲区, 此处的flash 没有，问题也不大,
  66.             // 紧接着 bufferedWriter 对象就要关闭了 close 时，就会自动触发刷新操作
  67.             bufferedWriter.flush();
  69.         } catch (IOException e) {
  70.             e.printStackTrace();
  71.         } finally {
  72.             try {
  73.                 clientSocket.close();
  74.             } catch (IOException e) {
  75.                 e.printStackTrace();
  76.             }
  77.         }
  78.     }
  79. }

测试：

  1. public static void main(String[] args) throws IOException {
  2.     HttpServerV1 serverV1 = new HttpServerV1(6060);
  3.     serverV1.start();
  4. }

使用 fiddler 查看：

浏览器访问咱们自己的服务器时，就会构造一个 http 请求

服务器收到请求后，就返回一个响应：

把代码改一下：让不同的需求，来看到不同的响应

修改部分代码：

  1. String resp = null;
  2. if(url.equals("/OK")){
  3. 	bufferedWriter.write(version + "200 OK\n");
  4. 	resp = "<h1>hello</h1>";
  5. }
  6. else if(url.equals("/notfound")){
  7. 	bufferedWriter.write(version + "404 Not Found\n");
  8. 	resp = "<h1>not found</h1>";
  9. }
  10. // 重定向情况
  11. else if(url.equals("/seeother")){
  12.     bufferedWriter.write(version + " 303 See Other\n");
  13.     bufferedWriter.write("Location: http://www.sogou.com\n");
  14.     resp = "";
  15. }
  16. else{
  17. 	bufferedWriter.write(version + "200 OK\n");
  18. 	resp = "<h1>default</h1>";
  19. }

运行程序，连接服务器：

default：

重定向：

版本2

1.整理代码格式，让代码更规范
2.解析 URL 中包含的参数(键值对)，能够方便的处理用户传过来的参数
3.演示 Cookie 的工作流程

request 类：

  1. /*
  2. *  专门表示 Http 请求
  3. *  表示一个 http 请求，并解析
  4. * */
  5. public class HttpRequest {
  6.     private String method;
  7.     private String url;
  8.     private String version;
  9.     private Map<String,String> headers = new HashMap<>();
  10.     // 表示 url中的参数
  11.     private Map<String,String> parameters = new HashMap<>();
  13.     // 请求的构造逻辑,仍使用工厂模式来构造
  14.     // 此处的参数就是从 socket 中获取到的 InputStream 对象
  15.     // 这个过程本质上是在 "反序列化"   把一个比特流，转换成一个结构化数据
  16.     public static HttpRequest build(InputStream inputStream) throws IOException {
  17.         HttpRequest request = new HttpRequest();
  18.         // 此处的逻辑，不能把 bufferedReader 写入到 try() 中
  19.         // 一旦写进去之后就意味着 bufferedReader就会被关闭,会影响到 clientSocket 的状态
  20.         // 等到最后整个请求处理完了， 再统一关闭
  21.         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
  23.         // 此处的 build 的过程就是解析请求的过程
  24.         //1.解析首行
  25.         String firstLine = bufferedReader.readLine();
  26.         String[] firstLineTokens = firstLine.split(" ");
  27.         request.method = firstLineTokens[0];
  28.         request.url = firstLineTokens[1];
  29.         request.version = firstLineTokens[2];
  31.         //2.解析 url 中的参数
  32.         int pos = request.url.indexOf("?");
  33.         if(pos != -1){
  34.             // 检查url中是否有 ? ,若没有，说明不带参数，就不需要解析了
  35.             // pos 表示 ? 的下标   /index.html?a=10&bb=20
  36.             // parameters 的结果就相当于是 a=10&bb=20
  37.             String parameters = request.url.substring(pos + 1);
  38.             // 切分的最终结果，key-a,value-10 ;  key-b,value-20
  39.             parseKV(parameters,request.parameters);
  40.         }
  41.         //3.解析header
  42.         String line = "";
  43.         while ((line = bufferedReader.readLine()) != null && line.length() != 0){
  44.             String[] headerTokens = line.split(": ");
  45.             request.headers.put(headerTokens[0],headerTokens[1]);
  46.         }
  47.         //4.解析 body(暂时不考虑)
  48.         return request;
  49.     }
  51.     private static void parseKV(String input, Map<String, String> output) {
  52.         // 1.先按照 & 切分成若干组键值对
  53.         String[] kvTokens =  input.split("&");
  54.         // 2.针对切分结果，再分别进行 按照 = 切分，得到键和值
  55.         for (String kv : kvTokens) {
  56.             String[] result = kv.split("=");
  57.             output.put(result[0],result[1]);
  58.         }
  59.     }
  61.     // 给这个类构造一些 getter方法 (不要搞 setter 方法)
  62.     // 请求对象的内容应该从网络上解析来的，用户不应该修改
  63.     public String getMethod() {
  64.         return method;
  65.     }
  67.     public String getUrl() {
  68.         return url;
  69.     }
  71.     public String getVersion() {
  72.         return version;
  73.     }
  75.     public String getHeader(String key) {
  76.         return headers.get(key);
  77.     }
  79.     public String getParameter(String key) {
  80.         return parameters.get(key);
  81.     }
  82.     
  83.     @Override
  84.     public String toString() {
  85.         return "HttpRequest{" +
  86.                 "method='" + method + '\'' +
  87.                 ", url='" + url + '\'' +
  88.                 ", version='" + version + '\'' +
  89.                 ", headers=" + headers +
  90.                 ", parameters=" + parameters +
  91.                 '}';
  92.     }
  93. }

response 类：

  1. /*
  2. * 专门表示 Http 响应
  3. * 表示一个 http 响应，负责构造
  4. * */
  5. public class HttpResponse {
  6.     private String version = "HTTP/1.1";
  7.     private int status;  // 状态码
  8.     private String message; // 状态码描述性信息
  9.     private Map<String,String> headers = new HashMap<>();
  10.     // 使用StringBuilder 方便进行拼接
  11.     private StringBuilder body = new StringBuilder();
  12.     // 写回给客户端时需要用到
  13.     // 代码把响应写回到客户端时，就往 outputStream 中写
  14.     private OutputStream outputStream = null;
  16.     public static HttpResponse build(OutputStream outputStream){
  17.         HttpResponse response = new HttpResponse();
  18.         response.outputStream = outputStream;
  19.         // 除了outputStream外，其他的属性内容，暂时无法确定，要根据代码的具体逻辑，来决定
  20.         return response;
  21.     }
  23.     // 提供一些 setter 方法
  24.     public void setVersion(String version) {
  25.         this.version = version;
  26.     }
  28.     public void setStatus(int status) {
  29.         this.status = status;
  30.     }
  32.     public void setMessage(String message) {
  33.         this.message = message;
  34.     }
  36.     public void setHeader(String key,String value) {
  37.         headers.put(key,value);
  38.     }
  40.     public void writeBody(String content) {
  41.         body.append(content);
  42.     }
  44.     // 以上设置属性操作，都是在内存中
  45.     // 还需要一个专门de方法，把这些属性，按照 Http 协议写到socket中
  46.     public void flush() throws IOException {
  47.         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
  48.         // 构造首行
  49.         bufferedWriter.write(version + " " + status + " " + message + "\n");
  51.         headers.put("Content-Length",body.toString().getBytes().length +"");
  52.         for (Map.Entry<String,String> entry : headers.entrySet()){
  53.             bufferedWriter.write(entry.getKey() + ": " + entry.getValue() + "\n");
  54.         }
  55.         bufferedWriter.write("\n");
  56.         bufferedWriter.write(body.toString());
  57.         bufferedWriter.flush();
  58.     }
  59. }

主类：

  1. public class HttpServerV2 {
  2.     private ServerSocket serverSocket = null;
  4.     public HttpServerV2(int port) throws IOException {
  5.         serverSocket = new ServerSocket(port);
  6.     }
  8.     public void start() throws IOException {
  9.         System.out.println("服务器启动...");
  10.         ExecutorService executorService = Executors.newCachedThreadPool();
  11.         while (true) {
  12.             Socket clientSocket = serverSocket.accept();
  13.             executorService.execute(new Runnable() {
  14.                 @Override
  15.                 public void run() {
  16.                     process(clientSocket);
  17.                 }
  18.             });
  19.         }
  20.     }
  21.     public void process(Socket clientSocket) {
  22.         try {
  23.             // 1.读取并解析请求
  24.             HttpRequest request = HttpRequest.build(clientSocket.getInputStream());
  25.             System.out.println("request: " + request);
  26.             HttpResponse response = HttpResponse.build(clientSocket.getOutputStream());
  27.             response.setHeader("Content-Type","text/html");
  28.             // 2.根据请求计算响应
  29.             if(request.getUrl().startsWith("/hello")) {
  30.                 response.setStatus(200);
  31.                 response.setMessage("OK");
  32.                 response.writeBody("<h1>hello</h1>");
  33.             }
  34.             else{
  35.                 response.setStatus(200);
  36.                 response.setMessage("OK");
  37.                 response.writeBody("<h1>default</h1>");
  38.             }
  39.             // 3.把响应写回客户端
  40.             response.flush();
  41.         } catch (IOException e) {
  42.             e.printStackTrace();
  43.         } finally {
  44.             try {
  45.                 // 这个操作会同时关闭 getInputStream 和 getOutputStream 对象
  46.                 clientSocket.close();
  47.             } catch (IOException e) {
  48.                 e.printStackTrace();
  49.             }
  50.         }
  51.     }
  53.     public static void main(String[] args) throws IOException {
  54.         HttpServerV2 serverV2 = new HttpServerV2(6060);
  55.         serverV2.start();
  56.     }
  57. }

测试结果：

添加参数计算：

  1. else if(request.getUrl().startsWith("/calc")){
  2. 	// 根据参数的内容进行计算
  3. 	// 先获取到 a 和 b 两个参数的值
  4. 	String aStr = request.getParameter("a");
  5. 	String bStr = request.getParameter("b");
  6. 	int a = Integer.parseInt(aStr);
  7. 	int b = Integer.parseInt(bStr);
  8. 	int result = a + b;
  9. 	response.setStatus(200);
  10. 	response.setMessage("OK");
  11. 	response.writeBody("<h1>result = " + result + "</h1>");
  12. }

测试结果：

基本流程：

1.服务器启动

2.在 process 方法中，要处理一次请求

  • a) 读取请求并解析
  1. HttpRequest request = HttpRequest.build(clientSocket.getInputStream());

build 方法：解析请求，严格遵守 http 协议

  • b) 根据请求计算响应 (主要业务逻辑)
    不唯一，需根据具体请求，来决定代码怎样实现
  • c) 把响应写回到客户端
  1. response.flush();

通过 flush 操作，把 response 中设置好的属性写到 socket 中，这个过程也要遵守 Http 协议，本质上是一个 序列化 的过程

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://xhuahua.blog.csdn.net/article/details/122130666

内容来源于网络，如有侵权，请联系作者删除！

HTTPtcp/ip网络

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com