Java IO编程由浅入深 - 4 (bio http协议解编码器，实现http服务器)

逃离我推掉我的手 2022-11-07 04:08 7阅读 0赞

### 实现基于http协议的解编码器，并通过浏览器请求，返回数据 ###

*  目录
 *  创建HttpRequest类
 *  创建HttpResponse类
 *  创建HttpMessageCodec
 *  启动服务端

# 目录 #

1.  [Java IO编程由浅入深 - 1 (bio c/s架构实现)][Java IO_ - 1 _bio c_s]
2.  [Java IO编程由浅入深 - 2(bio 基于字符串的消息编解码器)][Java IO_ - 2_bio]
3.  [Java IO编程由浅入深 - 3 (bio 基于消息长度的解编码器)][Java IO_ - 3 _bio]
4.  [Java IO编程由浅入深 - 4 (bio http协议解编码器，实现http服务器)][Java IO_ - 4 _bio http_http]
5.  [Java IO编程由浅入深 - 5 (项目架构重构)][Java IO_ - 5]
6.  [Java IO编程由浅入深 - 6 (bio实现C/S聊天室 1 )][Java IO_ - 6 _bio_C_S_ 1]
7.  [Java IO编程由浅入深 - 7 (bio实现C/S聊天室 2 )][Java IO_ - 7 _bio_C_S_ 2]
8.  [Java IO编程由浅入深 - 8 (bio实现C/S聊天室 3 )][Java IO_ - 8 _bio_C_S_ 3]
9.  [Java IO编程由浅入深 - 9 (bio实现http升级到websocket )][Java IO_ - 9 _bio_http_websocket]
10. [Java IO编程由浅入深 - 10 (bio 基于websocket的心跳检测实现 )][Java IO_ - 10 _bio _websocket_]

# 创建HttpRequest类 #

package com.lhstack.bio.codec.http;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    
    import java.nio.charset.Charset;
    import java.util.Map;
    
    /** * @author lhstack */
    public class HttpRequest { 
    
        private String version;
    
        private String uri;
    
        private String method;
    
        private final Map<String,String> headers;
    
        private ByteBuf content;
    
        public HttpRequest(String version, String uri, String method, Map<String, String> headers) { 
            this.version = version;
            this.uri = uri;
            this.method = method;
            this.headers = headers;
            this.content = Unpooled.EMPTY_BUFFER;
        }
    
        public String version() { 
            return version;
        }
    
        public void setVersion(String version) { 
            this.version = version;
        }
    
        public String uri() { 
            return uri;
        }
    
        public void setUri(String uri) { 
            this.uri = uri;
        }
    
        public String method() { 
            return method;
        }
    
        public void setMethod(String method) { 
            this.method = method;
        }
    
        public Map<String, String> headers() { 
            return headers;
        }
    
    
        public ByteBuf getContent() { 
            return content;
        }
    
        public void setContent(ByteBuf content) { 
            this.content = content;
        }
    
        /** * clone一份 * @return */
        public HttpRequest copy(){ 
            HttpRequest httpRequest = new HttpRequest(this.version, this.uri, this.method, this.headers);
            httpRequest.setContent(this.content.copy());
            return httpRequest;
        }
    
        @Override
        public String toString() { 
            return "HttpRequest{" +
                    "version='" + version + '\'' +
                    ", uri='" + uri + '\'' +
                    ", method='" + method + '\'' +
                    ", headers=" + headers +
                    ", content=" + this.content.toString(Charset.defaultCharset()) +
                    '}';
        }
    }

# 创建HttpResponse类 #

package com.lhstack.bio.codec.http;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    
    import java.nio.charset.StandardCharsets;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * @author lhstack */
    public class HttpResponse { 
        private String version;
    
        private int status;
    
        private ByteBuf content;
    
        private Map<String,String> headers;
    
        public HttpResponse(String version, int status) { 
            this(version,status,Unpooled.EMPTY_BUFFER);
        }
    
        public HttpResponse(String version, int status, ByteBuf content) { 
            this(version,status,content,new HashMap<>());
        }
    
        public HttpResponse(String version, int status, ByteBuf content, Map<String, String> headers) { 
            this.version = version;
            this.status = status;
            this.content = content;
            this.headers = headers;
            this.init();
        }
    
        private void init() { 
            this.headers.put("Server","lhstack");
            if(this.content.readableBytes() > 0){ 
                this.headers.put("Content-Length",String.valueOf(this.content.readableBytes()));
            }
        }
    
        public String version() { 
            return version;
        }
    
        public void setVersion(String version) { 
            this.version = version;
        }
    
        public int status() { 
            return status;
        }
    
        public void setStatus(int status) { 
            this.status = status;
        }
    
        public ByteBuf content() { 
            return content;
        }
    
        public void setContent(ByteBuf content) { 
            this.content = content;
        }
    
        public Map<String, String> headers() { 
            return headers;
        }
    
        @Override
        public String toString() { 
            return "HttpResponse{" +
                    "version='" + version + '\'' +
                    ", status=" + status +
                    ", content=" + content.toString(StandardCharsets.UTF_8) +
                    ", headers=" + headers +
                    '}';
        }
    }

# 创建HttpMessageCodec #

实现将http请求封装成HttpRequest对象，将服务端响应的数据封装成HttpResponse

package com.lhstack.bio.codec.http;
    
    import com.lhstack.bio.codec.MessageCodec;
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    
    import java.nio.charset.StandardCharsets;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * @author lhstack * http解编码器 */
    public class HttpMessageCodec implements MessageCodec<HttpResponse> { 
    
        /** * 解析状态 */
        enum State{ 
            //http读取行状态
            READ_LINE,
            //http请求体状态
            READ_BODY,
            //http读取完成状态
            READ_FINISH
        }
    
        /** * 保存上一次读取的字节 */
        private byte oldByte = ' ';
    
        private static final String LR_LF = "\r\n";
    
        private static final String SPACE = " ";
    
        private State state = State.READ_LINE;
    
        private HttpRequest httpRequest;
    
        private static final String CONTENT_LENGTH = "Content-Length";
    
        /** * 读取的http请求信息 */
        private ByteBuf httpBody = Unpooled.buffer(128);
    
        @Override
        public ByteBuf messageEncoder(HttpResponse msg) { 
            ByteBuf result = Unpooled.buffer(128);
            result.writeBytes(String.format("%s %s %s\r\n",msg.version(),msg.status(),"OK").getBytes(StandardCharsets.UTF_8));
            msg.headers().forEach((k,v) ->{ 
                result.writeBytes(String.format("%s: %s\r\n",k,v).getBytes(StandardCharsets.UTF_8));
            });
            if(msg.headers().containsKey(CONTENT_LENGTH)){ 
                result.writeBytes(new byte[]{ '\r','\n'})
                        .writeBytes(msg.content());
            }
            result.writeBytes(new byte[]{ '\r','\n'});
            return result;
        }
    
        @Override
        public Object messageDecoder(ByteBuf buf) { 
            if(state == State.READ_LINE){ 
                //循环判断是否可读
                while(buf.isReadable()){ 
                    buf.markReaderIndex();
                    //获取一个字节
                    byte b = buf.readByte();
                    if(this.oldByte == '\n' && b == '\r'){ 
                        //如果不可读，则返回到上一个状态
                        if(!buf.isReadable()){ 
                            buf.resetReaderIndex();
                            return null;
                        }
                        //读取完最后一个\n
                        buf.readByte();
                        //开始解析http协议
                        httpParse();
                        break;
                    }
                    this.oldByte = b;
                    this.httpBody.writeByte(b);
                }
            }
            if(this.state == State.READ_BODY){ 
                int length = Integer.parseInt(this.httpRequest.headers().get(CONTENT_LENGTH));
                //如果长度不够，等待下一次数据到达
                if(buf.readableBytes() < length){ 
                    return null;
                }
                ByteBuf requestBody = Unpooled.buffer(length);
                buf.readBytes(requestBody);
                this.httpRequest.setContent(requestBody);
                this.state = State.READ_FINISH;
            }
            if(this.state == State.READ_FINISH){ 
                //初始化
                this.state = State.READ_LINE;
                //回收httpBody
                this.httpBody.release();
                this.httpBody = Unpooled.buffer(128);
                this.oldByte = ' ';
                HttpRequest copy = this.httpRequest.copy();
                //回收httpRequest
                this.httpRequest.getContent().release();
                this.httpRequest = null;
                return copy;
            }
            return null;
        }
    
        private void httpParse() { 
            byte[] bytes = new byte[this.httpBody.readableBytes()];
            //读取这一次的请求
            this.httpBody.readBytes(bytes);
            //存储解析出来的请求头
            Map<String,String> headers = new HashMap<>();
            //获取每一行数据
            String[] lines = new String(bytes, StandardCharsets.UTF_8).split(LR_LF);
    
            //GET /index.html HTTP/1.1
            String[] line0 = lines[0].split(SPACE);
    
            String method = line0[0].strip();
    
            String uri = line0[1].strip();
    
            String version = line0[2].strip();
    
            for (int i = 1; i < lines.length; i++) { 
                String[] kv = lines[i].split(":",2);
                //获取key
                String key = kv[0].strip();
                if(!headers.containsKey(key) && kv.length == 1){ 
                    headers.put(key,"");
                }else if(!headers.containsKey(key) && kv.length == 2){ 
                    headers.put(key,kv[1].strip());
                }else { 
                    headers.put(key,headers.get(key) + "," + kv[1].strip());
                }
            }
            httpRequest = new HttpRequest(version,uri,method,headers);
            if(headers.containsKey(CONTENT_LENGTH)){ 
                this.state = State.READ_BODY;
            }else{ 
                this.state = State.READ_FINISH;
            }
        }
    }

# 启动服务端 #

public static void main(String[] args) throws Exception { 
            Server server = new Server(8080, 200, HttpMessageCodec::new, () -> (MessageHandler<HttpRequest>) (msg, socket) -> { 
                System.out.println(msg);
                HttpResponse httpResponse = new HttpResponse("HTTP/1.1", 200, Unpooled.wrappedBuffer("hello world".getBytes(StandardCharsets.UTF_8)));
                httpResponse.headers().put("Content-Type","text/plain;charset=utf-8");
                return httpResponse;
            });
            server.start();
        }

使用浏览器访问，查看服务端控制台，可以看到，解析到了浏览器的请求数据  
![在这里插入图片描述][2021031020513167.png]  
再查看浏览器，浏览器也将服务端响应的hello world打印到了页面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70]  
我们再使用PostMan实现带文件的请求，看服务端是否接受到了文件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 1]  
可以看到，postman的请求到了服务端，并接收到了服务端响应的hello world  
这个时候，我们查看服务端，同时服务端也接收到了客户端发送过来的文件，说明我们这次针对http协议的解析，是成功的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 2]  
下一期，我将实现一个群聊服务器，实现多个客户端互相聊天

[Java IO_ - 1 _bio c_s]: https://blog.csdn.net/qq_42413011/article/details/114553235
[Java IO_ - 2_bio]: https://blog.csdn.net/qq_42413011/article/details/114579502
[Java IO_ - 3 _bio]: https://blog.csdn.net/qq_42413011/article/details/114636827
[Java IO_ - 4 _bio http_http]: https://blog.csdn.net/qq_42413011/article/details/114646159
[Java IO_ - 5]: https://blog.csdn.net/qq_42413011/article/details/114802496
[Java IO_ - 6 _bio_C_S_ 1]: https://blog.csdn.net/qq_42413011/article/details/114852932
[Java IO_ - 7 _bio_C_S_ 2]: https://blog.csdn.net/qq_42413011/article/details/114878895
[Java IO_ - 8 _bio_C_S_ 3]: https://blog.csdn.net/qq_42413011/article/details/114896029
[Java IO_ - 9 _bio_http_websocket]: https://blog.csdn.net/qq_42413011/article/details/114925184
[Java IO_ - 10 _bio _websocket_]: https://blog.csdn.net/qq_42413011/article/details/114947311
[2021031020513167.png]: /images/20221023/f8fd9f389ce04e57b3eb6a4fc219af3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70]: /images/20221023/fa5bda53b1ba4523b035791d13bc251a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 1]: /images/20221023/c3a268beff8344ad8fa96dc9c20fb001.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDEzMDEx_size_16_color_FFFFFF_t_70 2]: /images/20221023/ba606f8484ec49d29b65cef002d7d708.png