最新消息:欢迎访问Android开发中文站!商务联系微信:loading_in

在Android上实现HttpServer

开发进阶 loading 1314浏览 0评论
在最近的项目中因为要用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)请求都能接收到,无论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, "关闭局域网点歌的服务");
        }
    }
}

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

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

dependencies {
    compile 'com.koushikdutta.async:androidasync:2.2.1'
}

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

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() + "的资源不存在");
            }
        }
    }
}

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

原文链接:http://www.jianshu.com/p/e475b3b87490

转载请注明:Android开发中文站 » 在Android上实现HttpServer

您必须 登录 才能发表评论!