中国领先的IT技术网站
|
|

在Android上实现HttpServer

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

作者:佚名来源:Android开发中文站|2017-08-15 19:20

沙龙活动 | 去哪儿、陌陌、ThoughtWorks在自动化运维中的实践!10.28不见不散!


在Android上实现HttpServer

在最近的项目中因为要用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上下载,下载地址

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

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

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

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

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

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

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

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

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

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

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

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

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

根据上面的例子,主要说以下几点:{大概说的就是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;但是如果不需要的话,那就再具体分析。

【编辑推荐】

  1. 2017 Android GitHub常用开源框架汇总
  2. Android Coding利器之掌握小技巧,助你Coding更上一层楼~
  3. Android线程间通信之handler
  4. 一种粗暴快速的Android全屏幕适配方案
  5. Android 7.0动态权限大总结
【责任编辑:庞桂玉 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

软件工程:实践者的研究方法

20多年以来,《软件工程:实践者的研究方法》一书是最受学生和行业专业人员欢迎的软件工程指南。它在全面而系统、概括而清晰地介绍软件工程...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× Python最火的编程语言