用Java的BIO和NIO、Netty实现HTTP服务器(一) BIO与绪论

// true 代表BIO,false代表NIO
public final SelectableChannel configureBlocking(boolean block)

ByteBuffer byteBuffer = ByteBuffer.allocate(4096);

ByteBuffer byteBuffer = ByteBuffer.allocate(1);
 byteBuffer.put("hello world".getBytes(StandardCharsets.UTF_8));

public int read(ByteBuffer buf) throws IOException {
        Objects.requireNonNull(buf);
        readLock.lock();
        try {
            ensureOpenAndConnected();
            boolean blocking = isBlocking();
            int n = 0;
            try {
                beginRead(blocking);
                // check if input is shutdown
                if (isInputClosed)
                    return IOStatus.EOF;
                if (blocking) {
                    do {
                        n = IOUtil.read(fd, buf, -1, nd);
                    } while (n == IOStatus.INTERRUPTED && isOpen());
                } else {
                    n = IOUtil.read(fd, buf, -1, nd);
                }
            } finally {
                endRead(blocking, n > 0);
                if (n <= 0 && isInputClosed)
                    return IOStatus.EOF;
            }
            return IOStatus.normalize(n);
        } finally {
            readLock.unlock();
        }
    }

static int read(FileDescriptor fd, ByteBuffer dst, long position,
                    boolean directIO, int alignment, NativeDispatcher nd)
        throws IOException
    {
        if (dst.isReadOnly())
            throw new IllegalArgumentException("Read-only buffer");
        if (dst instanceof DirectBuffer)
            return readIntoNativeBuffer(fd, dst, position, directIO, alignment, nd);
        // Substitute a native buffer
        ByteBuffer bb;
        int rem = dst.remaining();
        if (directIO) {
            Util.checkRemainingBufferSizeAligned(rem, alignment);
            bb = Util.getTemporaryAlignedDirectBuffer(rem, alignment);
        } else {
            bb = Util.getTemporaryDirectBuffer(rem);
        }
        try {
            int n = readIntoNativeBuffer(fd, bb, position, directIO, alignment,nd);
            bb.flip();
            if (n > 0)
                dst.put(bb);
            return n;
        } finally {
            Util.offerFirstTemporaryDirectBuffer(bb);
        }
 }

java -jar jar名

@SpringBootApplication
public class SsmApplication {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(args));
        SpringApplication.run(SsmApplication.class, args);
    }
}

mvn package

java -jar jar名 hello

package org.example.http;
import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.util.Arrays;
/**
 * @author xingke
 * @date 2023-07-15 15:36
 */
public abstract class Server {
    protected ServerSocketChannel serverSocketChannel;
    protected SSLContext sslContext;
   static int port = 8000;
   static int backlog = 1024;
   static boolean secure = false;
    public Server(int port, int backlog, boolean secure) throws IOException {
        // 创建一个ServerSocketChannel
        serverSocketChannel =  ServerSocketChannel.open();
        /**
         * 可以重用ip+端口这个链接,TCP以链接为单位,当TCP链接要关闭的时候，会等待一段时间再进行关闭,
         * 如果我想要重用端口,那么channel就无法绑定,在绑定到对应地址之前,设定重用地址。即使在这个端口上的tcp连接
         * 处于处于TIME_WAIT状态,我们仍然可以使用
         */
        serverSocketChannel.socket().setReuseAddress(true);
        // 绑定端口和backlog
        serverSocketChannel.bind(new InetSocketAddress(port),backlog);
    }
    /**
     * 这里是抽象方法,我们后面要用NIO再实现一遍
     * 所以这里交给子类来实现
      */
   protected  abstract void runServer();
    /**
     * 我们要写的是一个简单的HTTP服务器,
     * 这个服务器可以从命令行方式启动的时候接收参数
     * 我们可以选择从main函数
     * @param args
     */
   public static void main(String[] args) throws IOException {
       Server server = null;
       if (args.length == 0){
           System.out.println("http server running default model");
           server = new BlockingServer(port,backlog,secure);
           server.runServer();
       }
       // 端口目前先固定死, 我们目前只读一个参数
       if ("B".equals(args[0])){
            server = new BlockingServer(port,backlog,secure);
       }else if ("N".equals(args[0])){
            server = new NonBlockingServer(port,backlog,secure);
       }else{
           System.out.println("input args error only support B OR N");
           return;
       }
       server.runServer();
   }
}

public class BlockingServer extends Server{
    public BlockingServer(int port, int backlog, boolean secure) throws IOException {
        super(port, backlog, secure);
    }
    @Override
    protected void runServer() throws IOException {
        SocketChannel socketChannel = serverSocketChannel.accept();
        ChannelIO channelIO = ChannelIO.getInstance(socketChannel, true);
        RequestServicer requestServicer = new RequestServicer(channelIO);
        requestServicer.run();
    }
}

package org.example.http;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class ChannelIO {
    private SocketChannel socketChannel;
    
    private ByteBuffer requestBuffer;
    int defaultByteBufferSize = 4096;
    private ChannelIO(SocketChannel socketChannel, boolean blocking) throws IOException {
        this.socketChannel = socketChannel;
        this.requestBuffer = ByteBuffer.allocate(4096);
        this.socketChannel.configureBlocking(blocking);
    }
    public static ChannelIO getInstance(SocketChannel socketChannel, boolean blocking) throws IOException {
        return  new ChannelIO(socketChannel,blocking);
    }
    public int read() throws IOException {
        // 剩余的小于百分之五自动扩容
        resizeByteBuffer(defaultByteBufferSize / 20);
        return socketChannel.read(requestBuffer);
    }
    private void resizeByteBuffer(int remaining) {
        if (requestBuffer.remaining() < remaining){
            // 扩容一倍
            ByteBuffer newRequestBuffer = ByteBuffer.allocate(requestBuffer.capacity() * 2);
            // 转为读模式
            requestBuffer.flip();
            //  将旧的buffer放入到新的buffer中
            newRequestBuffer.put(requestBuffer);
            requestBuffer = newRequestBuffer;
        }
    }
    public ByteBuffer getReadBuf(){
        return this.requestBuffer;
    }
    public int write(ByteBuffer byteBuffer) throws IOException{
        return socketChannel.write(byteBuffer);
    }
    
    public void close() throws IOException{
        socketChannel.close();
    }
}

public class Request {
    private Action action;
    private URI uri;
    private String version;
    public Request(Action action, URI uri, String version) {
        this.action = action;
        this.uri = uri;
        this.version = version;
    }
    static class Action{
        private String name;
        static Action GET = new Action("GET");
        static Action POST = new Action("POST");
        static Action PUT = new Action("PUT");
        static Action HEAD = new Action("HEAD");
        public Action(String name) {
            this.name = name;
        }
        public String toString(){
            return this.name;
        }
        static Action parse(String s){
            if ("GET".equals(s)){
                return GET;
            }
            if ("POST".equals(s)){
                return POST;
            }
            if ("PUT".equals(s)){
                return PUT;
            }
            if ("HEAD".equals(s)){
                return HEAD;
            }
            // 参数不合法
            throw new IllegalArgumentException(s);
        }
    }
    public  static boolean isComplete(ByteBuffer byteBuffer){
        int position = byteBuffer.position() - 4;
        if (position < 0){
            return false;
        }
        return byteBuffer.get(position + 0) == '\r'
                && byteBuffer.get(position + 1) == '\n'
                && byteBuffer.get(position + 2) == '\r'
                && byteBuffer.get(position + 2) == '\n';
    }
    private static Charset ascii = StandardCharsets.US_ASCII;
    /**
     * 正则表达式 用来分割请求报文
     * http 请求的报文是: GET /dir/file HTTP/1.1
     *  Host: hostname
     *  被正则表达式分割以后:
     *      group[1] = "GET"
     *      group[2] = "/dir/file"
     *      group[3] = "1.1"
     *      group[4] = "hostname"
     */
    private static Pattern requestPattern
            = Pattern.compile("\\A([A-Z]+) +([^ ]+) +HTTP/([0-9\\.]+)$"
                    + ".*^Host: ([^ ]+)$.*\r\n\r\n\\z",
            Pattern.MULTILINE | Pattern.DOTALL);
    public static  Request parse(ByteBuffer byteBuffer) throws RequestException {
        // byte to char
        CharBuffer charBuffer = ascii.decode(byteBuffer);
        Matcher matcher = requestPattern.matcher(charBuffer);
        // 未匹配
        if (matcher.matches()){
            throw new  RequestException();
        }
        Action a;
        try {
            a = Action.parse(matcher.group(1));
        }catch (IllegalArgumentException  e){
            throw new RequestException();
        }
        URI u = null;
        try {
             u = new URI("http://" + matcher.group(4) + matcher.group(2));
        }catch (URISyntaxException e){
            throw new RequestException(e);
        }
        return new Request(a,u,matcher.group(3));
    }
}

public interface Sendable {
    void prepare() throws IOException;
    boolean send(ChannelIO channelIO);
    
    void release();
}

public interface Content extends Sendable {
    
    String type();
    long length();
}

public class StringContent implements Content{
    private String type;    // MIME type
    private String content;
    private ByteBuffer byteBuffer;
    private static final Charset ascii = StandardCharsets.US_ASCII;
    StringContent(CharSequence c, String t) {
        content = c.toString();
        type = t + "; charset=iso-8859-1";
    }
    StringContent(CharSequence c) {
        this(c, "text/plain");
    }
    StringContent(Exception x) {
        StringWriter sw = new StringWriter();
        x.printStackTrace(new PrintWriter(sw));
        type = "text/plain; charset=iso-8859-1";
        content = sw.toString();
    }
    @Override
    public String type() {
        return type;
    }
    @Override
    public long length() {
        return byteBuffer.remaining();
    }
    @Override
    public void prepare() throws IOException {
        encode();
        byteBuffer.rewind();
    }
    private void encode() {
        if (byteBuffer == null){
            byteBuffer =  ascii.encode(CharBuffer.wrap(content));
        }
    }
    @Override
    public boolean send(ChannelIO channelIO) throws IOException {
        if (byteBuffer == null)
            throw new IllegalStateException();
        channelIO.write(byteBuffer);
        return  byteBuffer.hasRemaining();
    }
    /**
     * 这是个空方法
     * 后面只是为了统一调用
     */
    @Override
    public void release() {
    }
}

public class Reply implements Sendable {
    static class Code{
        private int number;
        private String description;
        public Code(int number, String description) {
            this.number = number;
            this.description = description;
        }
        static Code OK = new Code(200,"OK");
        static Code BAD_REQUEST = new Code(400,"Bad Request");
        static Code NOT_FOUND = new Code(404,"Not Found");
        static Code METHOD_NOT_ALLOWED = new Code(405,"Method Not Allowed");
    }
    private Code code;
    private Content content;
    private ByteBuffer headerBuffer;
    private static String CRLF = "\r\n";
    private static Charset ascii = Charset.forName("US-ASCII");
    public Reply(Code code, Content content) {
        this.code = code;
        this.content = content;
    }
    /**
     * 这个方法负责添加请求头
     * @return
     */
    private ByteBuffer headers(){
        CharBuffer cb = CharBuffer.allocate(1024);
        cb.put("HTTP/1.0 ").put(code.toString()).put(CRLF);
        cb.put("Server: niossl/0.1").put(CRLF);
        cb.put("Content-type: ").put(content.type()).put(CRLF);
        cb.put("Content-length: ")
                .put(Long.toString(content.length())).put(CRLF);
        cb.put(CRLF);
        cb.flip();
        return ascii.encode(cb);
    }
    @Override
    public void prepare() throws IOException {
        content.prepare();
        headerBuffer = headers();
    }
    @Override
    public boolean send(ChannelIO channelIO) throws IOException {
         // 先写请求头
        if (headerBuffer.hasRemaining()){
            if (channelIO.write(headerBuffer) <= 0)
                return true;
        }
        // 再写响应内容
        if (content.send(channelIO))
            return true;
        return false;
    }
    @Override
    public void release() {
        content.release();
    }
}

public class RequestServicer implements Runnable {
    private ChannelIO channelIO;
    public RequestServicer(ChannelIO channelIO) {
        this.channelIO = channelIO;
    }
    private void service() throws IOException {
        ByteBuffer byteBuffer = receive(); // 接收数据
        Request request = null;
        Reply reply = null;
        try {
            request = Request.parse(byteBuffer);
        } catch (RequestException e) {
            reply = new Reply(Reply.Code.BAD_REQUEST, new StringContent(e));
        }
        // 说明正常解析
        if (reply == null) {
            reply  = build(request); // 构建回复
        }
        reply.prepare();
        do {} while (reply.send(channelIO));         // Send
    }
    @Override
    public void run() {
        try {
            service();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    ByteBuffer receive() throws IOException {
        for (; ; ) {
            int read = channelIO.read();
            ByteBuffer bb = channelIO.getReadBuf();
            if ((read < 0) || (Request.isComplete(bb))) {
                bb.flip();
                return bb;
            }
        }
    }
    Reply build(Request rq) throws IOException {
        Reply rp = null;
        Request.Action action = rq.action();
        if ((action != Request.Action.GET)) {
            rp = new Reply(Reply.Code.METHOD_NOT_ALLOWED,
                    new StringContent(rq.toString()));
            rp.prepare();
            return rp;
        }
        rp = new Reply(Reply.Code.OK,
                new StringContent("hello world"));
        rp.prepare();
        return rp;
    }
}

public class BlockingServer extends Server{
    private static final ExecutorService POOL  = Executors.newFixedThreadPool(8);
    public BlockingServer(int port, int backlog, boolean secure) throws IOException {
        super(port, backlog, secure);
    }
    @Override
    protected void runServer() throws IOException {
        SocketChannel socketChannel = serverSocketChannel.accept();
        ChannelIO channleIO = ChannelIO.getInstance(socketChannel, true);
        RequestServicer requestServicer = new RequestServicer(channleIO);
        POOL.submit(requestServicer);
    }
}