在Android上实现HttpServer-51CTO.COM

在最近的项目中因为要用Android作为一个服务器去做一个实时接收数据的功能，所以这个时候就要去做一个Android本地的微型服务器。

那么此时我首先想到了spring boot，因为他是一个服务器的框架。但是实际上我们根本用不到这么大型的服务器框架，配置这些都太麻烦。所以，我又找到了Ijetty、NanoHttpd和AndroidAsync这三个框架，都是比较微型的，适用于Android的。

经过对比，Ijetty使用起来过于复杂，而且会莫名其妙的报一些不太容易解决的问题，所以，舍弃掉了。

因为没仔细深究Ijetty，所以就重点放到NanoHttpd和AndroidAsync;

那么就先来说下两个的优缺点：

1.NanoHttpd是BIO为底层封装的框架，而AndroidAsync是NIO为底层封装的，其他的是一样的，而且其实AndroidAsync是仿照NanoHttpd框架写的。所以，一定意义上来说，AndroidAsync是NanoHttpd的优化版，当然也要看具体应用场景辣。

2.NanoHttpd只能用于HttpServer，但是AndroidAsync除了HttpServer的应用还能用在webSocket、HttpClient等方面，其中从AndroidAsync中脱离出来的Ion的库也是比较有名的。

3.NanoHttpd底层处理包含的返回状态码(例如： 200、300、400、500等)比较多;但是经过笔者阅读AndroidAsync的源码发现，AndroidAsync底层封装返回的状态码只有两种：200、404，正好笔者发现了这个坑(下面会讲到，OPTIONS的例子)

下面看一下具体使用方法吧。

1.先说NanoHttpd：

因为NanoHttpd的框架实际就是一个单文件，可以直接去github上下载，下载地址

有了下载的文件，那么就可以继承这个文件写一个类，具体如下：

public class HttpServer extends NanoHTTPD { 
    private static final String TAG = "HttpServer"; 
 
    public static final String DEFAULT_SHOW_PAGE = "index.html"; 
    public static final int DEFAULT_PORT = 9511;//此参数随便定义，***定义1024-65535；1-1024是系统常用端口,1024-65535是非系统端口 
 
    public enum Status implements Response.IStatus { 
        REQUEST_ERROR(500, "请求失败"), 
        REQUEST_ERROR_API(501, "无效的请求接口"), 
        REQUEST_ERROR_CMD(502, "无效命令"); 
 
        private final int requestStatus; 
        private final String description; 
 
        Status(int requestStatus, String description) { 
            this.requestStatus = requestStatus; 
            this.description = description; 
        } 
 
        @Override 
        public String getDescription() { 
            return description; 
        } 
 
        @Override 
        public int getRequestStatus() { 
            return requestStatus; 
        } 
    } 
 
    public HttpServer() {//初始化端口 
        super(DEFAULT_PORT); 
    } 
 
    @Override 
    public Response serve(IHTTPSession session) { 
        String uri = session.getUri(); 
        Map<String, String> headers = session.getHeaders(); 
 
        //接收不到post参数的问题，              http://blog.csdn.net/obguy/article/details/53841559 
        try { 
            session.parseBody(new HashMap<String, String>()); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } catch (ResponseException e) { 
            e.printStackTrace(); 
        } 
        Map<String, String> parms = session.getParms(); 
        try { 
            LogUtil.d(TAG, uri); 
 
//判断uri的合法性，自定义方法，这个是判断是否是接口的方法 
            if (checkUri(uri)) { 
                // 针对的是接口的处理 
                if (headers != null) { 
                    LogUtil.d(TAG, headers.toString()); 
                } 
                if (parms != null) { 
                    LogUtil.d(TAG, parms.toString()); 
                } 
 
                if (StringUtil.isEmpty(uri)) { 
                    throw new RuntimeException("无法获取请求地址"); 
                } 
 
                if (Method.OPTIONS.equals(session.getMethod())) { 
                    LogUtil.d(TAG, "OPTIONS探测性请求"); 
                    return addHeaderResponse(Response.Status.OK); 
                } 
 
                switch (uri) { 
                    case "/test": {//接口2 
                       //此方法包括了封装返回的接口请求数据和处理异常以及跨域 
                        return getXXX(parms); 
                    } 
                    default: { 
                        return addHeaderResponse(Status.REQUEST_ERROR_API); 
                    } 
                } 
            } else { 
                //针对的是静态资源的处理 
                String filePath = getFilePath(uri); // 根据url获取文件路径 
 
                if (filePath == null) { 
                    LogUtil.d(TAG, "sd卡没有找到"); 
                    return super.serve(session); 
                } 
                File file = new File(filePath); 
 
                if (file != null && file.exists()) { 
                    LogUtil.d(TAG, "file path = " + file.getAbsolutePath()); 
//根据文件名返回mimeType： image/jpg, video/mp4, etc 
                    String mimeType = getMimeType(filePath);  
 
                    Response res = null; 
                    InputStream is = new FileInputStream(file); 
                    res = newFixedLengthResponse(Response.Status.OK, mimeType, is, is.available()); 
//下面是跨域的参数（因为一般要和h5联调，所以***设置一下） 
                    response.addHeader("Access-Control-Allow-Headers", allowHeaders); 
                    response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, HEAD"); 
                    response.addHeader("Access-Control-Allow-Credentials", "true"); 
                    response.addHeader("Access-Control-Allow-Origin", "*"); 
                    response.addHeader("Access-Control-Max-Age", "" + 42 * 60 * 60); 
 
                    return res; 
                } else { 
                    LogUtil.d(TAG, "file path = " + file.getAbsolutePath() + "的资源不存在"); 
                } 
 
            } 
 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
        //自己封装的返回请求 
        return addHeaderRespose(Status.REQUEST_ERROR); 
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.

根据上面的例子，主要说以下几点： 1)请求都能接收到，无论post还是get，或者是其他请求，如果需要过滤则自己去处理;

2)注意上面处理的接收不到post参数的问题，已经给了参考链接在代码注释中，请查阅;

3)如果请求中既有接口又有静态资源(例如html)，那注意区分两种请求，例如可以用uri去识别;当然返回都可以用流的形式，都可以调用API方法newFixedLengthResponse();

4)笔者建议，***处理一下跨域的问题，因为是Android有可能和h5联调，所以设置了跨域以后比较方便调试，当然某些场景也可以忽略，看个人需求;方法已经在以上代码中写了;

5)当然***最重要的一点肯定是开启和关闭的代码了：

/** 
 * 开启本地网页点歌的服务 
 */ 
public static void startLocalChooseMusicServer() { 
 
    if (httpServer == null) { 
        httpServer = new HttpServer(); 
    } 
 
    try { 
        // 启动web服务 
        if (!httpServer.isAlive()) { 
            httpServer.start(); 
        } 
        Log.i(TAG, "The server started."); 
    } catch (Exception e) { 
        httpServer.stop(); 
        Log.e(TAG, "The server could not start. e = " + e.toString()); 
    } 
 
} 
 
/** 
 * 关闭本地服务 
 */ 
public static void quitChooseMusicServer() { 
    if (httpServer != null) { 
        if (httpServer.isAlive()) { 
            httpServer.stop(); 
            Log.d(TAG, "关闭局域网点歌的服务"); 
        } 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

2再看一下AndroidAsync：这个框架就比较有意思了，功能也多，本文直说HttpServer方面的相关知识，其余按下不表。

老规矩，先说用法：在Gradle中加入:

dependencies { 
 
  compile 'com.koushikdutta.async:androidasync:2.2.1' 
 
} 
1.
2.
3.
4.
5.

代码示例：(此处没有处理跨域，如果需要的话，请根据上一个例子去处理)

public class NIOHttpServer implements HttpServerRequestCallback { 
 
    private static final String TAG = "NIOHttpServer"; 
 
    private static NIOHttpServer mInstance; 
 
    public static int PORT_LISTEN_DEFALT = 5000; 
 
    AsyncHttpServer server = new AsyncHttpServer(); 
 
    public static NIOHttpServer getInstance() { 
        if (mInstance == null) { 
            // 增加类锁,保证只初始化一次 
            synchronized (NIOHttpServer.class) { 
                if (mInstance == null) { 
                    mInstance = new NIOHttpServer(); 
                } 
            } 
        } 
        return mInstance; 
    } 
 
//仿照nanohttpd的写法 
    public static enum Status { 
        REQUEST_OK(200, "请求成功"), 
        REQUEST_ERROR(500, "请求失败"), 
        REQUEST_ERROR_API(501, "无效的请求接口"), 
        REQUEST_ERROR_CMD(502, "无效命令"), 
        REQUEST_ERROR_DEVICEID(503, "不匹配的设备ID"), 
        REQUEST_ERROR_ENV(504, "不匹配的服务环境"); 
 
        private final int requestStatus; 
        private final String description; 
 
        Status(int requestStatus, String description) { 
            this.requestStatus = requestStatus; 
            this.description = description; 
        } 
 
        public String getDescription() { 
            return description; 
        } 
 
        public int getRequestStatus() { 
            return requestStatus; 
        } 
    } 
 
    /** 
 * 开启本地服务 
 */ 
    public void startServer() { 
//如果有其他的请求方式，例如下面一行代码的写法 
        server.addAction("OPTIONS", "[\\d\\D]*", this); 
        server.get("[\\d\\D]*", this); 
        server.post("[\\d\\D]*", this); 
        server.listen(PORT_LISTEN_DEFALT); 
    } 
 
    @Override 
    public void onRequest(AsyncHttpServerRequest request, AsyncHttpServerResponse response) { 
        Log.d(TAG, "进来了，哈哈"); 
        String uri = request.getPath(); 
//这个是获取header参数的地方，一定要谨记哦 
        Multimap headers = request.getHeaders().getMultiMap(); 
 
        if (checkUri(uri)) {// 针对的是接口的处理 
            //注意：这个地方是获取post请求的参数的地方，一定要谨记哦 
            Multimap parms = (( AsyncHttpRequestBody<Multimap>)request.getBody()).get(); 
            if (headers != null) { 
                LogUtil.d(TAG, headers.toString()); 
            } 
            if (parms != null) { 
                LogUtil.d(TAG, "parms = " + parms.toString()); 
            } 
 
            if (StringUtil.isEmpty(uri)) { 
                throw new RuntimeException("无法获取请求地址"); 
            } 
 
            if ("OPTIONS".toLowerCase().equals(request.getMethod().toLowerCase())) { 
                LogUtil.d(TAG, "OPTIONS探测性请求"); 
                addCORSHeaders(Status.REQUEST_OK, response); 
                return; 
            } 
 
            switch (uri) { 
                    case "/test": {//接口2 
                       //此方法包括了封装返回的接口请求数据和处理异常以及跨域 
                        return getXXX(parms); 
                    } 
                    default: { 
                        return addHeaderResponse(Status.REQUEST_ERROR_API); 
                    } 
                } 
        } else { 
            // 针对的是静态资源的处理 
            String filePath = getFilePath(uri); // 根据url获取文件路径 
 
            if (filePath == null) { 
                LogUtil.d(TAG, "sd卡没有找到"); 
                response.send("sd卡没有找到"); 
                return; 
            } 
            File file = new File(filePath); 
 
            if (file != null && file.exists()) { 
                Log.d(TAG, "file path = " + file.getAbsolutePath()); 
 
                response.sendFile(file);//和nanohttpd不一样的地方 
 
            } else { 
                Log.d(TAG, "file path = " + file.getAbsolutePath() + "的资源不存在"); 
            } 
        } 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.

根据上面的例子，主要说以下几点：{大概说的就是api用法啊这一类的｝

1)例如：server.addAction(“OPTIONS”, “[\d\D]“, this)是通用的过滤请求的方法。***个参数是请求的方法，例如用“OPTIONS”、“DELETE”、“POST”、“GET”等(注意用大写)，第二个参数是过滤uri的正则表达式，此处是过滤所有的uri，第三个是回调参数。server.post(“[\d\D]“, this)、server.get(“[\d\D]*”, this)这个是上一个方法的特例。server.listen(PORT_LISTEN_DEFALT)这个是监听端口;

2) request.getHeaders().getMultiMap()

这个是获取header参数的地方，一定要谨记哦;

3)(( AsyncHttpRequestBody<Multimap>)request.getBody()).get()这个地方是获取post请求的参数的地方;

4)获取静态资源的代码是在回调方法onResponse的else中，例子如上。

5)说一下OPTIONS的坑点，因为AndroidAsync这个框架中封装的返回http的状态码只有两种，假如过滤方法中没有包含例如OPTIONS的请求方法，实际上返回给客户端的http状态码是400，而反映到浏览器的报错信息竟然是跨域的问题，找了很久才找到，请注意。

总结：

1)同一个页面：

NanoHttpd耗时：1.4s

AndroidAsync耗时：1.4s

但是在第二次进去的时候，AndroidAsync的耗时明显比***个少了，笔者猜测是因为AndroidAsync底层做了一些处理。

2)从api分析的话，NanoHttpd的用法比较方便，获取传递的参数那些的api比较好用;AndroidAsync的api就相对来说要复杂一些，例如params的获取。

3)从场景来分析的话，如果需要并发量高的需求，一定要用AndroidAsync;但是如果不需要的话，那就再具体分析。