“NanoHttpd微型服务器”使用及源码阅读

偶然返现NanoHttpd，仅仅一个Java文件，可在嵌入式设备（例：Android手机）中启动一个本地服务器，接收客户端本地部分请求。
认真学习了其源码实现，这里按照我的学习顺序写了一篇简单的文章（算是学习笔记吧）：

了解官方描述
写个Demo使用一下（Android中本地代理，播放Sdcard中的m3u8）
最后学习其源码实现

NanoHttpd GitHub地址：
https://github.com/NanoHttpd/nanohttpd

首先看一下官方相关描述。

NanoHttpd 官方描述

Tiny, easily embeddable HTTP server in Java.
微小的，轻量级适合嵌入式设备的Java Http服务器；
NanoHTTPD is a light-weight HTTP server designed for embedding in other applications, released under a Modified BSD licence.
NanoHTTPD是一个轻量级的、为嵌入式设备应用设计的HTTP服务器，遵循修订后的BSD许可协议。

Core

Only one Java file, providing HTTP 1.1 support.

仅一个Java文件，支持Http 1.1

No fixed config files, logging, authorization etc. (Implement by yourself if you need them. Errors are passed to java.util.logging, though.)

没有固定的配置文件、日志系统、授权等等（如果你有需要需自己实现。工程中的日志输出，通过java.util.logging实现的）

Support for HTTPS (SSL).

支持Https

Basic support for cookies.

支持cookies

Supports parameter parsing of GET and POST methods.

支持POST和GET 参数请求

Some built-in support for HEAD, POST and DELETE requests. You can easily implement/customize any HTTP method, though.

内置支持HEAD、POST、DELETE请求，你可以方便的实现或自定义任何HTTP方法请求。

Supports file upload. Uses memory for small uploads, temp files for large ones.

支持文件上传。小文件上传使用内存缓存，大文件使用临时文件缓存。

Never caches anything.

不缓存任何内容

Does not limit bandwidth, request time or simultaneous connections by default.
默认不限制带宽、请求时间和最大请求量
All header names are converted to lower case so they don't vary between browsers/clients.

所有Header 名都被转换为小写，因此不会因客户端或浏览器的不同而有所差别

Persistent connections (Connection "keep-alive") support allowing multiple requests to be served over a single socket connection.

支持一个socket连接服务多个长连接请求。

一、Android 本地代理方式播放 Sdcard中的m3u8视频

为了学习NanoHttpd，做了一个简单Demo：Android 本地代理方式播放 Sdcard中的m3u8视频

Demo实现下载

Android 本地代理方式播放 Sdcard中的m3u8视频（使用的NanoHttpd 版本为 2.3.1）

NanoHttpd 2.3.1版本下载

实现效果如下图所示：

NanoHttpd的使用，使 “本地代理方式播放Android Sdcard中的m3u8视频” Demo实现变得很简单，这里不做具体介绍，有兴趣的朋友可以自行下载了解。

下边来主要来跟踪学习NanoHttpd的源码...

二、NanoHttpd源码跟踪学习

注：基于 NanoHttpd 2.3.1版本
NanoHttpd 2.3.1版本下载

NanoHTTPD大概的处理流程是：

开启一个服务端线程，绑定对应的端口，调用 ServerSocket.accept()方法进入等待状态
每个客户端连接均开启一个线程，执行ClientHandler.run()方法
客户端线程中，创建一个HTTPSession会话。执行HTTPSession.execute()
HTTPSession.execute() 中会完成 uri, method, headers, parms, files 的解析，并调用方法

// 自定义服务器时，亦需要重载该方法
// 该方法传入参数中，已解析出客户端请求的所有数据，重载该方法进行相应的业务处理
HTTPSession.serve(String uri, Method method, Map headers, Map parms, Map files)

组织Response数据，并调用ChunkedOutputStream.send(outputStream)返回给客户端

建议：对于Http request、response 数据组织形式不是很了解的同学，建议自己了解后再阅读NanoHTTPD源码。 也可参考我的另一篇文章：Http请求数据格式

NanoHTTPD.start

从服务器启动开始学习...

/**
 * Start the server. 启动服务器
 *
 * @param timeout timeout to use for socket connections. 超时时间
 * @param daemon  start the thread daemon or not. 守护线程
 * @throws IOException if the socket is in use.
 */
public void start(final int timeout, boolean daemon) throws IOException {
    // 创建一个ServerSocket
    this.myServerSocket = this.getServerSocketFactory().create();
    this.myServerSocket.setReuseAddress(true);

    // 创建 ServerRunnable
    ServerRunnable serverRunnable = createServerRunnable(timeout);
    // 启动一个线程监听客户端请求
    this.myThread = new Thread(serverRunnable);
    this.myThread.setDaemon(daemon);
    this.myThread.setName("NanoHttpd Main Listener");
    this.myThread.start();
    //
    while (!serverRunnable.hasBinded && serverRunnable.bindException == null) {
        try {
            Thread.sleep(10L);
        } catch (Throwable e) {
            // on android this may not be allowed, that's why we
            // catch throwable the wait should be very short because we are
            // just waiting for the bind of the socket
        }
    }
    if (serverRunnable.bindException != null) {
        throw serverRunnable.bindException;
    }
}

从以上代码中，可以看到：

代码前两行，创建一个ServerSocket
开启一个线程，执行ServerRunnable。这里其实就是服务端启动一个线程，用来监听客户端的请求，具体代码在ServerRunnable中。

ServerRunnable.run()

@Override
public void run() {
    Log.e(TAG, "---run---");
    try {
        // bind
        myServerSocket.bind(hostname != null ? new InetSocketAddress(hostname, myPort) : new InetSocketAddress(myPort));
        hasBinded = true;
    } catch (IOException e) {
        this.bindException = e;
        return;
    }
    Log.e(TAG, "bind ok");
    do {
        try {
            Log.e(TAG, "before accept");
            // 等待客户端连接
            final Socket finalAccept = NanoHTTPD.this.myServerSocket.accept();
            // 设置超时时间
            if (this.timeout > 0) {
                finalAccept.setSoTimeout(this.timeout);
            }
            // 服务端：输入流
            final InputStream inputStream = finalAccept.getInputStream();
            Log.e(TAG, "asyncRunner.exec");
            // 执行客户端 ClientHandler
            NanoHTTPD.this.asyncRunner.exec(createClientHandler(finalAccept, inputStream));
        } catch (IOException e) {
            NanoHTTPD.LOG.log(Level.FINE, "Communication with the client broken", e);
        }
    } while (!NanoHTTPD.this.myServerSocket.isClosed());
}

ServerRunnable的run()方法：

调用 ServerSocket.bind 方法，绑定对应的端口
调用 ServerSocket.accept() 线程进入阻塞等待状态
客户端连接后，会执行createClientHandler(finalAccept, inputStream)创建一个ClientHandler，并开启一个线程，执行其对应的ClientHandler.run()方法
自定义服务器时，重载Response HTTPSession.serve(uri, method, headers, parms, files)方法，进行相应的业务处理
完成处理后，对于

ClientHandler.run()

@Override
public void run() {
    Log.e(TAG, "---run---");
    // 服务端 输出流
    OutputStream outputStream = null;
    try {
        // 服务端的输出流
        outputStream = this.acceptSocket.getOutputStream();
        // 创建临时文件
        TempFileManager tempFileManager = NanoHTTPD.this.tempFileManagerFactory.create();
        // session 会话
        HTTPSession session = new HTTPSession(tempFileManager, this.inputStream, outputStream, this.acceptSocket.getInetAddress());
        // 执行会话
        while (!this.acceptSocket.isClosed()) {
            session.execute();
        }
    } catch (Exception e) {
        // When the socket is closed by the client,
        // we throw our own SocketException
        // to break the "keep alive" loop above. If
        // the exception was anything other
        // than the expected SocketException OR a
        // SocketTimeoutException, print the
        // stacktrace
        if (!(e instanceof SocketException && "NanoHttpd Shutdown".equals(e.getMessage())) && !(e instanceof SocketTimeoutException)) {
            NanoHTTPD.LOG.log(Level.SEVERE, "Communication with the client broken, or an bug in the handler code", e);
        }
    } finally {
        safeClose(outputStream);
        safeClose(this.inputStream);
        safeClose(this.acceptSocket);
        NanoHTTPD.this.asyncRunner.closed(this);
    }
}

TempFileManager临时文件是为了缓存客户端Post请求的请求Body数据（如果数据较小，内存缓存；文件较大，缓存到文件中）
创建一个HTTPSession会话，并执行其对应的HTTPSession.execute()方法
HTTPSession.execute()中会对客户端的请求进行解析

HTTPSession.execute()


@Override
public void execute() throws IOException {
    Log.e(TAG, "---execute---");
    Response r = null;
    try {
        // Read the first 8192 bytes.
        // The full header should fit in here.
        // Apache's default header limit is 8KB.
        // Do NOT assume that a single read will get the entire header
        // at once!
        // Apache默认header限制8k
        byte[] buf = new byte[HTTPSession.BUFSIZE];
        this.splitbyte = 0;
        this.rlen = 0;
        // 客户端输入流
        int read = -1;
        this.inputStream.mark(HTTPSession.BUFSIZE);
        // 读取8k的数据
        try {
            read = this.inputStream.read(buf, 0, HTTPSession.BUFSIZE);
        } catch (SSLException e) {
            throw e;
        } catch (IOException e) {
            safeClose(this.inputStream);
            safeClose(this.outputStream);
            throw new SocketException("NanoHttpd Shutdown");
        }
        if (read == -1) {
            // socket was been closed
            safeClose(this.inputStream);
            safeClose(this.outputStream);
            throw new SocketException("NanoHttpd Shutdown");
        }
        // 分割header数据
        while (read > 0) {
            this.rlen += read;
            // header
            this.splitbyte = findHeaderEnd(buf, this.rlen);
            // 找到header
            if (this.splitbyte > 0) {
                break;
            }
            // 8k中剩余数据
            read = this.inputStream.read(buf, this.rlen, HTTPSession.BUFSIZE - this.rlen);
        }
        // header数据不足8k，跳过header数据
        if (this.splitbyte < this.rlen) {
            this.inputStream.reset();
            this.inputStream.skip(this.splitbyte);
        }
        //
        this.parms = new HashMap>();
        // 清空header列表
        if (null == this.headers) {
            this.headers = new HashMap();
        } else {
            this.headers.clear();
        }
        // 解析 客户端请求
        // Create a BufferedReader for parsing the header.
        BufferedReader hin = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(buf, 0, this.rlen)));
        // Decode the header into parms and header java properties
        Map pre = new HashMap();
        decodeHeader(hin, pre, this.parms, this.headers);
        //
        if (null != this.remoteIp) {
            this.headers.put("remote-addr", this.remoteIp);
            this.headers.put("http-client-ip", this.remoteIp);
        }
        Log.e(TAG, "headers: " + headers);

        this.method = Method.lookup(pre.get("method"));
        if (this.method == null) {
            throw new ResponseException(Response.Status.BAD_REQUEST, "BAD REQUEST: Syntax error. HTTP verb " + pre.get("method") + " unhandled.");
        }
        Log.e(TAG, "method: " + method);

        this.uri = pre.get("uri");
        Log.e(TAG, "uri: " + uri);

        this.cookies = new CookieHandler(this.headers);
        Log.e(TAG, "cookies: " + this.cookies.cookies);

        String connection = this.headers.get("connection");
        Log.e(TAG, "connection: " + connection);
        boolean keepAlive = "HTTP/1.1".equals(protocolVersion) && (connection == null || !connection.matches("(?i).*close.*"));
        Log.e(TAG, "keepAlive: " + keepAlive);
        // Ok, now do the serve()

        // TODO: long body_size = getBodySize();
        // TODO: long pos_before_serve = this.inputStream.totalRead()
        // (requires implementation for totalRead())
        // 构造一个response
        r = serve(HTTPSession.this);
        // TODO: this.inputStream.skip(body_size -
        // (this.inputStream.totalRead() - pos_before_serve))

        if (r == null) {
            throw new ResponseException(Response.Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: Serve() returned a null response.");
        } else {
            String acceptEncoding = this.headers.get("accept-encoding");
            this.cookies.unloadQueue(r);
            // method
            r.setRequestMethod(this.method);
            r.setGzipEncoding(useGzipWhenAccepted(r) && acceptEncoding != null && acceptEncoding.contains("gzip"));
            r.setKeepAlive(keepAlive);

            // 发送response
            r.send(this.outputStream);
        }
        if (!keepAlive || r.isCloseConnection()) {
            throw new SocketException("NanoHttpd Shutdown");
        }
    } catch (SocketException e) {
        // throw it out to close socket object (finalAccept)
        throw e;
    } catch (SocketTimeoutException ste) {
        // treat socket timeouts the same way we treat socket exceptions
        // i.e. close the stream & finalAccept object by throwing the
        // exception up the call stack.
        throw ste;
    } catch (SSLException ssle) {
        Response resp = newFixedLengthResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SSL PROTOCOL FAILURE: " + ssle.getMessage());
        resp.send(this.outputStream);
        safeClose(this.outputStream);
    } catch (IOException ioe) {
        Response resp = newFixedLengthResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
        resp.send(this.outputStream);
        safeClose(this.outputStream);
    } catch (ResponseException re) {
        Response resp = newFixedLengthResponse(re.getStatus(), NanoHTTPD.MIME_PLAINTEXT, re.getMessage());
        resp.send(this.outputStream);
        safeClose(this.outputStream);
    } finally {
        safeClose(r);
        this.tempFileManager.clear();
    }
}

HTTPSession.execute() 完成了 uri, method, headers, parms, files 的解析
完成解析后，调用Response serve(IHTTPSession session)方法，创建了一个Response
完成Response数据组织后，这里会调用ChunkedOutputStream.send(outputStream)方法将数据发出去。

到这里，主要流程结束，其他细节需大家自己去用心研读源码了。我的Demo中增加了很多中文注释，可以帮助大家省下一部分力气，就这样了

三、相关参考

NanoHttpd GitHub

NanoHttpd源码分析

“NanoHttpd微型服务器”使用及源码阅读

“NanoHttpd微型服务器”使用及源码阅读

NanoHttpd 官方描述

一、Android 本地代理方式播放 Sdcard中的m3u8视频

二、NanoHttpd源码跟踪学习

NanoHTTPD.start

ServerRunnable.run()

ClientHandler.run()

HTTPSession.execute()

三、相关参考

你可能感兴趣的:(socket编程,java,服务器,服务器开发)